goscript 0.1.0 → 0.1.1

package/compiler/override-facts.go

@@ -0,0 +1,307 @@
+package compiler
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"io/fs"
+	"maps"
+	"path"
+	"slices"
+	"strings"
+
+	gs "github.com/aperturerobotics/goscript"
+	jsoniter "github.com/aperturerobotics/json-iterator-lite"
+)
+
+// OverrideFacts is the immutable compiler-visible view of GoScript overrides.
+type OverrideFacts struct {
+	packages map[string]overridePackageFacts
+}
+
+type overridePackageFacts struct {
+	metadata     OverrideMetadata
+	copyPackage  overrideCopyPackage
+	dependencies []string
+}
+
+// HasPackage returns true when pkgPath has a GoScript override package.
+func (f *OverrideFacts) HasPackage(pkgPath string) bool {
+	if f == nil || pkgPath == "" {
+		return false
+	}
+	_, ok := f.packages[pkgPath]
+	return ok
+}
+
+// Metadata returns compiler-visible override metadata for a package path.
+func (f *OverrideFacts) Metadata(pkgPath string) OverrideMetadata {
+	if f == nil {
+		return newOverrideMetadata()
+	}
+	pkg := f.packages[pkgPath]
+	return cloneOverrideMetadata(pkg.metadata)
+}
+
+// IsMethodAsync returns true when override metadata marks a method async.
+func (f *OverrideFacts) IsMethodAsync(pkgPath, method string) bool {
+	if f == nil {
+		return false
+	}
+	pkg := f.packages[pkgPath]
+	return pkg.metadata.AsyncMethods[method]
+}
+
+// IsFunctionAsync returns true when override metadata marks a package-level function async.
+func (f *OverrideFacts) IsFunctionAsync(pkgPath, function string) bool {
+	if f == nil {
+		return false
+	}
+	pkg := f.packages[pkgPath]
+	return pkg.metadata.AsyncFunctions[function]
+}
+
+func (f *OverrideFacts) copyPackage(pkgPath string) (overrideCopyPackage, []string, bool) {
+	if f == nil {
+		return overrideCopyPackage{}, nil, false
+	}
+	pkg, ok := f.packages[pkgPath]
+	if !ok {
+		return overrideCopyPackage{}, nil, false
+	}
+	return cloneOverrideCopyPackage(pkg.copyPackage), slices.Clone(pkg.dependencies), true
+}
+
+func (f *OverrideFacts) importPackageRoot(importPath string) (string, bool) {
+	if f == nil {
+		return "", false
+	}
+	importPath = strings.TrimPrefix(importPath, "@goscript/")
+	importPath = strings.TrimSuffix(importPath, ".js")
+	importPath = strings.TrimSuffix(importPath, ".ts")
+	if before, ok := strings.CutSuffix(importPath, "/index"); ok {
+		importPath = before
+	}
+	parts := strings.Split(importPath, "/")
+	for idx := len(parts); idx > 0; idx-- {
+		candidate := strings.Join(parts[:idx], "/")
+		if f.HasPackage(candidate) {
+			return candidate, true
+		}
+	}
+	return "", false
+}
+
+func buildOverrideFacts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
+	roots, err := discoverOverridePackageRoots()
+	if err != nil {
+		return nil, []Diagnostic{overrideError("discover override packages", "", err)}
+	}
+	paths := make([]string, 0, len(roots))
+	for pkgPath := range roots {
+		paths = append(paths, pkgPath)
+	}
+	slices.Sort(paths)
+
+	facts := &OverrideFacts{packages: make(map[string]overridePackageFacts, len(paths))}
+	var diagnostics []Diagnostic
+	for _, pkgPath := range paths {
+		if err := ctx.Err(); err != nil {
+			return facts, []Diagnostic{contextCanceledDiagnostic(err)}
+		}
+		metadata, err := loadOverrideMetadata(pkgPath)
+		if err != nil {
+			diagnostics = append(diagnostics, overrideError("read override metadata", pkgPath, err))
+			continue
+		}
+		copyPackage, dependencies, packageDiagnostics := loadOverrideCopyPackage(pkgPath, roots, metadata)
+		diagnostics = append(diagnostics, packageDiagnostics...)
+		if diagnosticsHaveErrors(packageDiagnostics) {
+			continue
+		}
+		facts.packages[pkgPath] = overridePackageFacts{
+			metadata:     cloneOverrideMetadata(metadata),
+			copyPackage:  copyPackage,
+			dependencies: dependencies,
+		}
+	}
+	if diagnosticsHaveErrors(diagnostics) {
+		return facts, diagnostics
+	}
+	return facts, diagnostics
+}
+
+func discoverOverridePackageRoots() (map[string]bool, error) {
+	roots := make(map[string]bool)
+	if err := fs.WalkDir(gs.GsOverrides, "gs", func(filePath string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() || path.Base(filePath) != "index.ts" {
+			return nil
+		}
+		pkgPath := strings.TrimPrefix(path.Dir(filePath), "gs/")
+		if pkgPath != "." && pkgPath != "" {
+			roots[pkgPath] = true
+		}
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return roots, nil
+}
+
+func loadOverrideMetadata(pkgPath string) (OverrideMetadata, error) {
+	metadata := newOverrideMetadata()
+	data, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/meta.json")
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return metadata, nil
+		}
+		return OverrideMetadata{}, err
+	}
+
+	iter := jsoniter.ParseBytes(data)
+	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
+		switch field {
+		case "dependencies":
+			for iter.ReadArray() {
+				metadata.Dependencies = append(metadata.Dependencies, iter.ReadString())
+			}
+		case "asyncMethods":
+			for method := iter.ReadObject(); method != ""; method = iter.ReadObject() {
+				metadata.AsyncMethods[method] = iter.ReadBool()
+			}
+		case "asyncFunctions":
+			for function := iter.ReadObject(); function != ""; function = iter.ReadObject() {
+				metadata.AsyncFunctions[function] = iter.ReadBool()
+			}
+		default:
+			iter.Skip()
+		}
+	}
+	if iter.Error != nil && !errors.Is(iter.Error, io.EOF) {
+		return OverrideMetadata{}, iter.Error
+	}
+	return metadata, nil
+}
+
+func loadOverrideCopyPackage(
+	pkgPath string,
+	roots map[string]bool,
+	metadata OverrideMetadata,
+) (overrideCopyPackage, []string, []Diagnostic) {
+	if !roots[pkgPath] {
+		return overrideCopyPackage{}, nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:missing-package",
+			Message:  "override package does not exist",
+			Detail:   pkgPath,
+		}}
+	}
+
+	facts := &OverrideFacts{packages: make(map[string]overridePackageFacts, len(roots))}
+	for root := range roots {
+		facts.packages[root] = overridePackageFacts{}
+	}
+
+	copyPackage := overrideCopyPackage{path: pkgPath}
+	dependencySet := make(map[string]bool)
+	for _, dependency := range metadata.Dependencies {
+		dependency = strings.TrimSpace(dependency)
+		if dependency != "" && dependency != pkgPath {
+			dependencySet[dependency] = true
+		}
+	}
+
+	root := "gs/" + pkgPath
+	err := fs.WalkDir(gs.GsOverrides, root, func(filePath string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			nestedPkg := strings.TrimPrefix(filePath, "gs/")
+			if nestedPkg != pkgPath && roots[nestedPkg] {
+				return fs.SkipDir
+			}
+			return nil
+		}
+		if !isOverrideSourceFile(filePath) {
+			return nil
+		}
+		data, readErr := gs.GsOverrides.ReadFile(filePath)
+		if readErr != nil {
+			return readErr
+		}
+		rel := strings.TrimPrefix(filePath, "gs/")
+		copyPackage.files = append(copyPackage.files, overrideCopyFile{
+			path: rel,
+			data: data,
+		})
+		for _, imported := range scanOverrideImports(string(data)) {
+			dependency, ok := facts.importPackageRoot(imported)
+			if ok && dependency != "builtin" && dependency != pkgPath {
+				dependencySet[dependency] = true
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return overrideCopyPackage{}, nil, []Diagnostic{overrideError("read override package", pkgPath, err)}
+	}
+
+	if len(copyPackage.files) == 0 {
+		return overrideCopyPackage{}, nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:empty-package",
+			Message:  "override package does not contain TypeScript source files",
+			Detail:   pkgPath,
+		}}
+	}
+	slices.SortFunc(copyPackage.files, func(a, b overrideCopyFile) int {
+		return strings.Compare(a.path, b.path)
+	})
+
+	dependencies := make([]string, 0, len(dependencySet))
+	for dependency := range dependencySet {
+		dependencies = append(dependencies, dependency)
+	}
+	slices.Sort(dependencies)
+	return copyPackage, dependencies, nil
+}
+
+func newOverrideMetadata() OverrideMetadata {
+	return OverrideMetadata{
+		AsyncFunctions: make(map[string]bool),
+		AsyncMethods:   make(map[string]bool),
+	}
+}
+
+func cloneOverrideMetadata(metadata OverrideMetadata) OverrideMetadata {
+	return OverrideMetadata{
+		Dependencies:   slices.Clone(metadata.Dependencies),
+		AsyncFunctions: cloneBoolMap(metadata.AsyncFunctions),
+		AsyncMethods:   cloneBoolMap(metadata.AsyncMethods),
+	}
+}
+
+func cloneBoolMap(values map[string]bool) map[string]bool {
+	cloned := make(map[string]bool, len(values))
+	maps.Copy(cloned, values)
+	return cloned
+}
+
+func cloneOverrideCopyPackage(pkg overrideCopyPackage) overrideCopyPackage {
+	cloned := overrideCopyPackage{
+		path:  pkg.path,
+		files: make([]overrideCopyFile, 0, len(pkg.files)),
+	}
+	for _, file := range pkg.files {
+		cloned.files = append(cloned.files, overrideCopyFile{
+			path: file.path,
+			data: bytes.Clone(file.data),
+		})
+	}
+	return cloned
+}

package/compiler/override-registry.go

@@ -2,82 +2,56 @@ package compiler
 
 import (
 	"context"
-	"errors"
-	"io"
-	"io/fs"
 	"os"
-	"path"
 	"path/filepath"
 	"slices"
 	"strings"
-
-	gs "github.com/aperturerobotics/goscript"
-	jsoniter "github.com/aperturerobotics/json-iterator-lite"
 )
 
 // OverrideMetadata describes compiler-visible facts from a package override.
 type OverrideMetadata struct {
 	// Dependencies are override package dependencies.
 	Dependencies []string
+	// AsyncFunctions maps package-level function names to async status.
+	AsyncFunctions map[string]bool
 	// AsyncMethods maps Type.Method keys to async status.
 	AsyncMethods map[string]bool
 }
 
 // OverrideRegistryOwner owns GoScript override package metadata and copy plans.
 type OverrideRegistryOwner struct {
-	metadata         map[string]*OverrideMetadata
-	packageRootCache map[string]bool
+	facts *OverrideFacts
 }
 
 // NewOverrideRegistryOwner creates the override registry owner.
 func NewOverrideRegistryOwner() *OverrideRegistryOwner {
-	return &OverrideRegistryOwner{
-		metadata: make(map[string]*OverrideMetadata),
-	}
+	return &OverrideRegistryOwner{}
 }
 
-// Metadata returns compiler-visible override metadata for a package path.
-func (o *OverrideRegistryOwner) Metadata(pkgPath string) (*OverrideMetadata, error) {
+// Facts returns the immutable compiler-visible override facts.
+func (o *OverrideRegistryOwner) Facts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
 	if o == nil {
 		o = NewOverrideRegistryOwner()
 	}
-	if metadata := o.metadata[pkgPath]; metadata != nil {
-		return metadata, nil
-	}
-
-	metadata := &OverrideMetadata{
-		AsyncMethods: make(map[string]bool),
+	if o.facts != nil {
+		return o.facts, nil
 	}
-	data, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/meta.json")
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			o.metadata[pkgPath] = metadata
-			return metadata, nil
-		}
-		return nil, err
+	facts, diagnostics := buildOverrideFacts(ctx)
+	if diagnosticsHaveErrors(diagnostics) {
+		return facts, diagnostics
 	}
+	o.facts = facts
+	return facts, diagnostics
+}
 
-	iter := jsoniter.ParseBytes(data)
-	for field := iter.ReadObject(); field != ""; field = iter.ReadObject() {
-		switch field {
-		case "dependencies":
-			for iter.ReadArray() {
-				metadata.Dependencies = append(metadata.Dependencies, iter.ReadString())
-			}
-		case "asyncMethods":
-			for method := iter.ReadObject(); method != ""; method = iter.ReadObject() {
-				metadata.AsyncMethods[method] = iter.ReadBool()
-			}
-		default:
-			iter.Skip()
-		}
-	}
-	if iter.Error != nil && !errors.Is(iter.Error, io.EOF) {
-		return nil, iter.Error
+// Metadata returns compiler-visible override metadata for a package path.
+func (o *OverrideRegistryOwner) Metadata(pkgPath string) (*OverrideMetadata, error) {
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, NewCompileError(diagnostics)
 	}
-
-	o.metadata[pkgPath] = metadata
-	return metadata, nil
+	metadata := facts.Metadata(pkgPath)
+	return &metadata, nil
 }
 
 // CopyPlan builds the ordered override package copy plan for a request.
@@ -107,17 +81,17 @@ func (o *OverrideRegistryOwner) CopyPlan(
 			Message:  "override copy planning requires a package graph",
 		}}
 	}
-	if _, err := o.packageRoots(); err != nil {
-		return nil, []Diagnostic{overrideError("discover override packages", "", err)}
+	facts, diagnostics := o.Facts(ctx)
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, diagnostics
 	}
 
-	var diagnostics []Diagnostic
 	visiting := make(map[string]bool)
 	visited := make(map[string]bool)
-	diagnostics = append(diagnostics, o.addPackageToPlan(ctx, plan, "builtin", visiting, visited)...)
+	diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, "builtin", visiting, visited)...)
 	for _, node := range graph.Nodes {
 		if node.OverrideCandidate {
-			diagnostics = append(diagnostics, o.addPackageToPlan(ctx, plan, node.PkgPath, visiting, visited)...)
+			diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, node.PkgPath, visiting, visited)...)
 		}
 	}
 	if diagnosticsHaveErrors(diagnostics) {
@@ -181,11 +155,20 @@ func (o *OverrideRegistryOwner) CopyPackages(
 
 // IsMethodAsync returns true when override metadata marks a method async.
 func (o *OverrideRegistryOwner) IsMethodAsync(pkgPath, method string) (bool, error) {
-	metadata, err := o.Metadata(pkgPath)
-	if err != nil {
-		return false, err
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return false, NewCompileError(diagnostics)
+	}
+	return facts.IsMethodAsync(pkgPath, method), nil
+}
+
+// IsFunctionAsync returns true when override metadata marks a package-level function async.
+func (o *OverrideRegistryOwner) IsFunctionAsync(pkgPath, function string) (bool, error) {
+	facts, diagnostics := o.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		return false, NewCompileError(diagnostics)
 	}
-	return metadata.AsyncMethods[method], nil
+	return facts.IsFunctionAsync(pkgPath, function), nil
 }
 
 type overrideCopyPlan struct {
@@ -204,6 +187,7 @@ type overrideCopyFile struct {
 
 func (o *OverrideRegistryOwner) addPackageToPlan(
 	ctx context.Context,
+	facts *OverrideFacts,
 	plan *overrideCopyPlan,
 	pkgPath string,
 	visiting map[string]bool,
@@ -228,13 +212,19 @@ func (o *OverrideRegistryOwner) addPackageToPlan(
 		}}
 	}
 
-	pkg, dependencies, diagnostics := o.loadCopyPackage(pkgPath)
-	if diagnosticsHaveErrors(diagnostics) {
-		return diagnostics
+	pkg, dependencies, ok := facts.copyPackage(pkgPath)
+	if !ok {
+		return []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/overrides:missing-package",
+			Message:  "override package does not exist",
+			Detail:   pkgPath,
+		}}
 	}
 	visiting[pkgPath] = true
+	var diagnostics []Diagnostic
 	for _, dependency := range dependencies {
-		diagnostics = append(diagnostics, o.addPackageToPlan(ctx, plan, dependency, visiting, visited)...)
+		diagnostics = append(diagnostics, o.addPackageToPlan(ctx, facts, plan, dependency, visiting, visited)...)
 	}
 	delete(visiting, pkgPath)
 	if diagnosticsHaveErrors(diagnostics) {
@@ -246,135 +236,6 @@ func (o *OverrideRegistryOwner) addPackageToPlan(
 	return diagnostics
 }
 
-func (o *OverrideRegistryOwner) loadCopyPackage(pkgPath string) (overrideCopyPackage, []string, []Diagnostic) {
-	roots, err := o.packageRoots()
-	if err != nil {
-		return overrideCopyPackage{}, nil, []Diagnostic{overrideError("discover override packages", "", err)}
-	}
-	if !roots[pkgPath] {
-		return overrideCopyPackage{}, nil, []Diagnostic{{
-			Severity: DiagnosticSeverityError,
-			Code:     "goscript/overrides:missing-package",
-			Message:  "override package does not exist",
-			Detail:   pkgPath,
-		}}
-	}
-
-	metadata, err := o.Metadata(pkgPath)
-	if err != nil {
-		return overrideCopyPackage{}, nil, []Diagnostic{overrideError("read override metadata", pkgPath, err)}
-	}
-
-	copyPackage := overrideCopyPackage{path: pkgPath}
-	dependencySet := make(map[string]bool)
-	for _, dependency := range metadata.Dependencies {
-		dependency = strings.TrimSpace(dependency)
-		if dependency != "" && dependency != pkgPath {
-			dependencySet[dependency] = true
-		}
-	}
-
-	root := "gs/" + pkgPath
-	err = fs.WalkDir(gs.GsOverrides, root, func(filePath string, entry fs.DirEntry, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if entry.IsDir() {
-			nestedPkg := strings.TrimPrefix(filePath, "gs/")
-			if nestedPkg != pkgPath && roots[nestedPkg] {
-				return fs.SkipDir
-			}
-			return nil
-		}
-		if !isOverrideSourceFile(filePath) {
-			return nil
-		}
-		data, readErr := gs.GsOverrides.ReadFile(filePath)
-		if readErr != nil {
-			return readErr
-		}
-		rel := strings.TrimPrefix(filePath, "gs/")
-		copyPackage.files = append(copyPackage.files, overrideCopyFile{
-			path: rel,
-			data: data,
-		})
-		for _, imported := range scanOverrideImports(string(data)) {
-			dependency, ok := o.importPackageRoot(imported)
-			if ok && dependency != "builtin" && dependency != pkgPath {
-				dependencySet[dependency] = true
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return overrideCopyPackage{}, nil, []Diagnostic{overrideError("read override package", pkgPath, err)}
-	}
-
-	if len(copyPackage.files) == 0 {
-		return overrideCopyPackage{}, nil, []Diagnostic{{
-			Severity: DiagnosticSeverityError,
-			Code:     "goscript/overrides:empty-package",
-			Message:  "override package does not contain TypeScript source files",
-			Detail:   pkgPath,
-		}}
-	}
-	slices.SortFunc(copyPackage.files, func(a, b overrideCopyFile) int {
-		return strings.Compare(a.path, b.path)
-	})
-
-	dependencies := make([]string, 0, len(dependencySet))
-	for dependency := range dependencySet {
-		dependencies = append(dependencies, dependency)
-	}
-	slices.Sort(dependencies)
-	return copyPackage, dependencies, nil
-}
-
-func (o *OverrideRegistryOwner) packageRoots() (map[string]bool, error) {
-	if o.packageRootCache != nil {
-		return o.packageRootCache, nil
-	}
-	roots := make(map[string]bool)
-	if err := fs.WalkDir(gs.GsOverrides, "gs", func(filePath string, entry fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if entry.IsDir() || path.Base(filePath) != "index.ts" {
-			return nil
-		}
-		pkgPath := strings.TrimPrefix(path.Dir(filePath), "gs/")
-		if pkgPath != "." && pkgPath != "" {
-			roots[pkgPath] = true
-		}
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-	o.packageRootCache = roots
-	return roots, nil
-}
-
-func (o *OverrideRegistryOwner) importPackageRoot(importPath string) (string, bool) {
-	roots, err := o.packageRoots()
-	if err != nil {
-		return "", false
-	}
-	importPath = strings.TrimPrefix(importPath, "@goscript/")
-	importPath = strings.TrimSuffix(importPath, ".js")
-	importPath = strings.TrimSuffix(importPath, ".ts")
-	if before, ok := strings.CutSuffix(importPath, "/index"); ok {
-		importPath = before
-	}
-	parts := strings.Split(importPath, "/")
-	for idx := len(parts); idx > 0; idx-- {
-		candidate := strings.Join(parts[:idx], "/")
-		if roots[candidate] {
-			return candidate, true
-		}
-	}
-	return "", false
-}
-
 func isOverrideSourceFile(filePath string) bool {
 	return strings.HasSuffix(filePath, ".ts") && !strings.HasSuffix(filePath, ".test.ts")
 }

package/compiler/override-registry_test.go

@@ -35,6 +35,53 @@ func TestOverrideRegistryPlansRuntimeAndOverrideDependencies(t *testing.T) {
 	}
 }
 
+func TestOverrideRegistryFactsAreImmutable(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	facts, diagnostics := owner.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
+
+	metadata := facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("expected sync Map.Load async metadata")
+	}
+	metadata.AsyncMethods["Map.Load"] = false
+	metadata.Dependencies = append(metadata.Dependencies, "mutated")
+
+	metadata = facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("override metadata mutation leaked back into facts")
+	}
+	if slices.Contains(metadata.Dependencies, "mutated") {
+		t.Fatalf("override dependency mutation leaked back into facts: %v", metadata.Dependencies)
+	}
+
+	pkg, dependencies, ok := facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts")
+	}
+	if !slices.Contains(dependencies, "errors") {
+		t.Fatalf("expected fmt dependency on errors, got %v", dependencies)
+	}
+	dependencies = append(dependencies, "mutated")
+	if len(pkg.files) == 0 {
+		t.Fatalf("expected fmt copy files")
+	}
+	pkg.files[0].data[0] = '!'
+
+	pkg, dependencies, ok = facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts after mutation")
+	}
+	if slices.Contains(dependencies, "mutated") {
+		t.Fatalf("copy dependency mutation leaked back into facts: %v", dependencies)
+	}
+	if len(pkg.files) == 0 || pkg.files[0].data[0] == '!' {
+		t.Fatalf("copy file mutation leaked back into facts")
+	}
+}
+
 func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
 	owner := NewOverrideRegistryOwner()
 	req := &CompileRequest{