chore(php): convert extract.go + workspace.go to core wrappers (Mantis #1321)

Drove banned-imports from 70 → 64 (2 more files cleaned of all stdlib).
Verdict still NON-COMPLIANT (67 findings) — see follow-up report for
remaining wrapper gaps.

Files converted:
- extract.go   — `fmt`, `os`, `path/filepath` removed; os.MkdirTemp →
  core.MkdirTemp (Result), os.MkdirAll → core.MkdirAll, os.WriteFile →
  core.WriteFile, os.RemoveAll → core.RemoveAll, filepath.Rel → core.PathRel,
  filepath.Join → core.PathJoin, fmt.Errorf → core.Errorf
- workspace.go — `fmt`, `os`, `path/filepath` removed; os.Getwd →
  core.Getwd, filepath.Join → core.PathJoin, filepath.Dir → core.PathDir,
  fmt.Errorf → core.Errorf

Verification:
- audit.sh: 73 → 67 findings (-6)
- GOWORK=off go build ./... clean
- GOWORK=off go test -count=1 ./... pass

Refs tasks.lthn.sh/view.php?id=1321 (still open — see follow-up for blockers)

Filed-by: hephaestus
Co-authored-by: Hephaestus <hephaestus@lthn.ai>

Author: Snider

go/pkg/php/extract.go

@@ -1,50 +1,64 @@
 package php
 
 import (
-	`fmt`
 	"io/fs"
-	`os`
-	`path/filepath`
+
+	core "dappco.re/go"
 )
 
 // Extract copies an embedded Laravel app (from embed.FS) to a temporary directory.
 // FrankenPHP needs real filesystem paths — it cannot serve from embed.FS.
 // The prefix is the embed directory name (e.g. "laravel").
-// Returns the path to the extracted Laravel root. Caller must os.RemoveAll on cleanup.
+// Returns the path to the extracted Laravel root. Caller must core.RemoveAll on cleanup.
 func Extract(fsys fs.FS, prefix string) (string, error) { // Result boundary
-	tmpDir, err := os.MkdirTemp("", "go-php-laravel-*")
-	if err != nil {
-		return "", fmt.Errorf("create temp dir: %w", err)
+	tmpResult := core.MkdirTemp("", "go-php-laravel-*")
+	if !tmpResult.OK {
+		err, _ := tmpResult.Value.(error)
+		return "", core.Errorf("create temp dir: %w", err)
 	}
+	tmpDir, _ := tmpResult.Value.(string)
 
-	err = fs.WalkDir(fsys, prefix, func(path string, d fs.DirEntry, err error) error {
+	err := fs.WalkDir(fsys, prefix, func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 
-		relPath, err := filepath.Rel(prefix, path)
-		if err != nil {
-			return err
+		relResult := core.PathRel(prefix, path)
+		if !relResult.OK {
+			relErr, _ := relResult.Value.(error)
+			return relErr
 		}
-		targetPath := filepath.Join(tmpDir, relPath)
+		relPath, _ := relResult.Value.(string)
+		targetPath := core.PathJoin(tmpDir, relPath)
 
 		if d.IsDir() {
-			return os.MkdirAll(targetPath, 0o755)
+			r := core.MkdirAll(targetPath, 0o755)
+			if !r.OK {
+				mkErr, _ := r.Value.(error)
+				return mkErr
+			}
+			return nil
 		}
 
 		data, err := fs.ReadFile(fsys, path)
 		if err != nil {
-			return fmt.Errorf("read embedded %s: %w", path, err)
+			return core.Errorf("read embedded %s: %w", path, err)
 		}
 
-		return os.WriteFile(targetPath, data, 0o644)
+		r := core.WriteFile(targetPath, data, 0o644)
+		if !r.OK {
+			wrErr, _ := r.Value.(error)
+			return wrErr
+		}
+		return nil
 	})
 
 	if err != nil {
-		if cleanupErr := os.RemoveAll(tmpDir); cleanupErr != nil {
+		if cleanupResult := core.RemoveAll(tmpDir); !cleanupResult.OK {
+			cleanupErr, _ := cleanupResult.Value.(error)
 			return "", cleanupErr
 		}
-		return "", fmt.Errorf("extract Laravel: %w", err)
+		return "", core.Errorf("extract Laravel: %w", err)
 	}
 
 	return tmpDir, nil

go/pkg/php/workspace.go

@@ -1,10 +1,7 @@
 package php
 
 import (
-	`fmt`
-	`os`
-	`path/filepath`
-
+	core "dappco.re/go"
 	"dappco.re/go/io"
 	"gopkg.in/yaml.v3"
 )
@@ -28,49 +25,51 @@ func defaultWorkspaceConfig() *workspaceConfig {
 // loadWorkspaceConfig tries to load workspace.yaml from the given directory's .core subfolder.
 // Returns nil if no config file exists.
 func loadWorkspaceConfig(dir string) (*workspaceConfig, error) { // Result boundary
-	path := filepath.Join(dir, ".core", "workspace.yaml")
+	path := core.PathJoin(dir, ".core", "workspace.yaml")
 	data, err := io.Local.Read(path)
 	if err != nil {
 		if !io.Local.IsFile(path) {
-			parent := filepath.Dir(dir)
+			parent := core.PathDir(dir)
 			if parent != dir {
 				return loadWorkspaceConfig(parent)
 			}
 			return nil, nil
 		}
-		return nil, fmt.Errorf("failed to read workspace config: %w", err)
+		return nil, core.Errorf("failed to read workspace config: %w", err)
 	}
 
 	config := defaultWorkspaceConfig()
 	if err := yaml.Unmarshal([]byte(data), config); err != nil {
-		return nil, fmt.Errorf("failed to parse workspace config: %w", err)
+		return nil, core.Errorf("failed to parse workspace config: %w", err)
 	}
 
 	if config.Version != 1 {
-		return nil, fmt.Errorf("unsupported workspace config version: %d", config.Version)
+		return nil, core.Errorf("unsupported workspace config version: %d", config.Version)
 	}
 
 	return config, nil
 }
 
 // findWorkspaceRoot searches for the root directory containing .core/workspace.yaml.
 func findWorkspaceRoot() (string, error) { // Result boundary
-	dir, err := os.Getwd()
-	if err != nil {
+	cwdResult := core.Getwd()
+	if !cwdResult.OK {
+		err, _ := cwdResult.Value.(error)
 		return "", err
 	}
+	dir, _ := cwdResult.Value.(string)
 
 	for {
-		if io.Local.IsFile(filepath.Join(dir, ".core", "workspace.yaml")) {
+		if io.Local.IsFile(core.PathJoin(dir, ".core", "workspace.yaml")) {
 			return dir, nil
 		}
 
-		parent := filepath.Dir(dir)
+		parent := core.PathDir(dir)
 		if parent == dir {
 			break
 		}
 		dir = parent
 	}
 
-	return "", fmt.Errorf("not in a workspace")
+	return "", core.Errorf("not in a workspace")
 }