goscript 0.1.1 → 0.1.2

package/compiler/override-facts.go

@@ -7,7 +7,9 @@ import (
 	"io"
 	"io/fs"
 	"maps"
+	"os"
 	"path"
+	"path/filepath"
 	"slices"
 	"strings"
 
@@ -26,6 +28,12 @@ type overridePackageFacts struct {
 	dependencies []string
 }
 
+type overridePackageRoot struct {
+	pkgPath string
+	fsys    fs.FS
+	dir     string
+}
+
 // HasPackage returns true when pkgPath has a GoScript override package.
 func (f *OverrideFacts) HasPackage(pkgPath string) bool {
 	if f == nil || pkgPath == "" {
@@ -93,10 +101,10 @@ func (f *OverrideFacts) importPackageRoot(importPath string) (string, bool) {
 	return "", false
 }
 
-func buildOverrideFacts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
-	roots, err := discoverOverridePackageRoots()
-	if err != nil {
-		return nil, []Diagnostic{overrideError("discover override packages", "", err)}
+func buildOverrideFacts(ctx context.Context, overrideDirs []string) (*OverrideFacts, []Diagnostic) {
+	roots, diagnostics := discoverOverridePackageRoots(overrideDirs)
+	if diagnosticsHaveErrors(diagnostics) {
+		return nil, diagnostics
 	}
 	paths := make([]string, 0, len(roots))
 	for pkgPath := range roots {
@@ -105,17 +113,16 @@ func buildOverrideFacts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
 	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)
+		metadata, err := loadOverrideMetadata(roots[pkgPath])
 		if err != nil {
 			diagnostics = append(diagnostics, overrideError("read override metadata", pkgPath, err))
 			continue
 		}
-		copyPackage, dependencies, packageDiagnostics := loadOverrideCopyPackage(pkgPath, roots, metadata)
+		copyPackage, dependencies, packageDiagnostics := loadOverrideCopyPackage(roots[pkgPath], roots, metadata)
 		diagnostics = append(diagnostics, packageDiagnostics...)
 		if diagnosticsHaveErrors(packageDiagnostics) {
 			continue
@@ -132,29 +139,62 @@ func buildOverrideFacts(ctx context.Context) (*OverrideFacts, []Diagnostic) {
 	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 {
+func discoverOverridePackageRoots(overrideDirs []string) (map[string]overridePackageRoot, []Diagnostic) {
+	roots := make(map[string]overridePackageRoot)
+	var diagnostics []Diagnostic
+	for _, dir := range overrideDirs {
+		dir = strings.TrimSpace(dir)
+		if dir == "" {
+			continue
+		}
+		abs, err := filepath.Abs(dir)
+		if err != nil {
+			diagnostics = append(diagnostics, overrideError("resolve override directory", dir, err))
+			continue
+		}
+		if err := discoverOverridePackageRootsInFS(roots, os.DirFS(abs), ".", false); err != nil {
+			diagnostics = append(diagnostics, overrideError("discover override packages", abs, err))
+		}
+	}
+	if err := discoverOverridePackageRootsInFS(roots, gs.GsOverrides, "gs", true); err != nil {
+		diagnostics = append(diagnostics, overrideError("discover override packages", "embedded gs", err))
+	}
+	return roots, diagnostics
+}
+
+func discoverOverridePackageRootsInFS(
+	roots map[string]overridePackageRoot,
+	fsys fs.FS,
+	rootDir string,
+	embedded bool,
+) error {
+	return fs.WalkDir(fsys, rootDir, 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/")
+		pkgPath := strings.TrimPrefix(path.Dir(filePath), rootDir+"/")
+		if rootDir == "." {
+			pkgPath = path.Dir(filePath)
+		}
 		if pkgPath != "." && pkgPath != "" {
-			roots[pkgPath] = true
+			if _, exists := roots[pkgPath]; !exists || !embedded {
+				roots[pkgPath] = overridePackageRoot{
+					pkgPath: pkgPath,
+					fsys:    fsys,
+					dir:     path.Dir(filePath),
+				}
+			}
 		}
 		return nil
-	}); err != nil {
-		return nil, err
-	}
-	return roots, nil
+	})
 }
 
-func loadOverrideMetadata(pkgPath string) (OverrideMetadata, error) {
+func loadOverrideMetadata(root overridePackageRoot) (OverrideMetadata, error) {
 	metadata := newOverrideMetadata()
-	data, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/meta.json")
+	data, err := fs.ReadFile(root.fsys, path.Join(root.dir, "meta.json"))
 	if err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
 			return metadata, nil
@@ -188,11 +228,12 @@ func loadOverrideMetadata(pkgPath string) (OverrideMetadata, error) {
 }
 
 func loadOverrideCopyPackage(
-	pkgPath string,
-	roots map[string]bool,
+	root overridePackageRoot,
+	roots map[string]overridePackageRoot,
 	metadata OverrideMetadata,
 ) (overrideCopyPackage, []string, []Diagnostic) {
-	if !roots[pkgPath] {
+	pkgPath := root.pkgPath
+	if _, ok := roots[pkgPath]; !ok {
 		return overrideCopyPackage{}, nil, []Diagnostic{{
 			Severity: DiagnosticSeverityError,
 			Code:     "goscript/overrides:missing-package",
@@ -215,14 +256,18 @@ func loadOverrideCopyPackage(
 		}
 	}
 
-	root := "gs/" + pkgPath
-	err := fs.WalkDir(gs.GsOverrides, root, func(filePath string, entry fs.DirEntry, walkErr error) error {
+	err := fs.WalkDir(root.fsys, root.dir, 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] {
+			nestedPkg := strings.TrimPrefix(filePath, root.dir+"/")
+			if root.dir == "." {
+				nestedPkg = filePath
+			} else if nestedPkg != filePath {
+				nestedPkg = path.Join(pkgPath, nestedPkg)
+			}
+			if _, ok := roots[nestedPkg]; nestedPkg != pkgPath && ok {
 				return fs.SkipDir
 			}
 			return nil
@@ -230,11 +275,16 @@ func loadOverrideCopyPackage(
 		if !isOverrideSourceFile(filePath) {
 			return nil
 		}
-		data, readErr := gs.GsOverrides.ReadFile(filePath)
+		data, readErr := fs.ReadFile(root.fsys, filePath)
 		if readErr != nil {
 			return readErr
 		}
-		rel := strings.TrimPrefix(filePath, "gs/")
+		rel := strings.TrimPrefix(filePath, root.dir+"/")
+		if root.dir == "." {
+			rel = filePath
+		} else if rel != filePath {
+			rel = path.Join(pkgPath, rel)
+		}
 		copyPackage.files = append(copyPackage.files, overrideCopyFile{
 			path: rel,
 			data: data,

package/compiler/override-registry.go

@@ -20,12 +20,13 @@ type OverrideMetadata struct {
 
 // OverrideRegistryOwner owns GoScript override package metadata and copy plans.
 type OverrideRegistryOwner struct {
-	facts *OverrideFacts
+	overrideDirs []string
+	facts        *OverrideFacts
 }
 
 // NewOverrideRegistryOwner creates the override registry owner.
-func NewOverrideRegistryOwner() *OverrideRegistryOwner {
-	return &OverrideRegistryOwner{}
+func NewOverrideRegistryOwner(overrideDirs ...string) *OverrideRegistryOwner {
+	return &OverrideRegistryOwner{overrideDirs: slices.Clone(overrideDirs)}
 }
 
 // Facts returns the immutable compiler-visible override facts.
@@ -36,7 +37,7 @@ func (o *OverrideRegistryOwner) Facts(ctx context.Context) (*OverrideFacts, []Di
 	if o.facts != nil {
 		return o.facts, nil
 	}
-	facts, diagnostics := buildOverrideFacts(ctx)
+	facts, diagnostics := buildOverrideFacts(ctx, o.overrideDirs)
 	if diagnosticsHaveErrors(diagnostics) {
 		return facts, diagnostics
 	}

package/compiler/override-registry_test.go

@@ -118,6 +118,47 @@ func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
 	}
 }
 
+func TestOverrideRegistryCopiesExternalOverride(t *testing.T) {
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/lib/index.ts", strings.Join([]string{
+		"import * as helper from '@goscript/example.test/helper/index.js'",
+		"export function Run(): void { helper.Run() }",
+		"",
+	}, "\n"))
+	writeFixtureFile(t, overrideDir, "example.test/lib/meta.json", `{"dependencies":["example.test/helper"]}`)
+	writeFixtureFile(t, overrideDir, "example.test/helper/index.ts", "export function Run(): void {}\n")
+
+	owner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}
+	plan, diagnostics := owner.CopyPlan(context.Background(), req, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "example.test/lib",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+	copied, diagnostics := owner.CopyPackages(context.Background(), req, plan)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy failed: %#v", diagnostics)
+	}
+	for _, pkg := range []string{"builtin", "example.test/helper", "example.test/lib"} {
+		if !slices.Contains(copied, pkg) {
+			t.Fatalf("missing copied package %s in %v", pkg, copied)
+		}
+	}
+	for _, path := range []string{
+		"@goscript/example.test/helper/index.ts",
+		"@goscript/example.test/lib/index.ts",
+	} {
+		if _, err := os.Stat(filepath.Join(req.OutputPath, filepath.FromSlash(path))); err != nil {
+			t.Fatalf("expected copied file %s: %v", path, err)
+		}
+	}
+}
+
 func TestOverrideRegistryReportsMissingOverridePackage(t *testing.T) {
 	_, diagnostics := NewOverrideRegistryOwner().CopyPlan(context.Background(), &CompileRequest{
 		RuntimeEmissionMode: RuntimeEmissionModeEmit,
@@ -252,3 +293,97 @@ func TestCompilePackagesAwaitsOverrideAsyncMethods(t *testing.T) {
 		t.Fatalf("override async method call was not awaited:\n%s", string(content))
 	}
 }
+
+func TestCompilePackagesPropagatesOverrideAsyncInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"net/http\"",
+			"type client struct { rt http.RoundTripper }",
+			"func (c *client) Do(req *http.Request) (*http.Response, error) {",
+			"  return c.rt.RoundTrip(req)",
+			"}",
+			"func Use(c *client, req *http.Request) (*http.Response, error) {",
+			"  return c.Do(req)",
+			"}",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "overrideasynciface", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"public async Do(req: http.Request | $.VarRef<http.Request> | null): globalThis.Promise<[http.Response | $.VarRef<http.Response> | null, $.GoError]>",
+		"return await $.pointerValue<Exclude<http.RoundTripper, null>>($.pointerValue<client>(c).rt).RoundTrip(req)",
+		"export async function Use(c: client | $.VarRef<client> | null, req: http.Request | $.VarRef<http.Request> | null): globalThis.Promise<[http.Response | $.VarRef<http.Response> | null, $.GoError]>",
+		"return await client.prototype.Do.call(c, req)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"io/fs\"",
+			"  \"path/filepath\"",
+			"  \"sync\"",
+			")",
+			"func main() {",
+			"  var m sync.Map",
+			"  _ = filepath.WalkDir(\".\", func(path string, d fs.DirEntry, err error) error {",
+			"    if _, ok := m.Load(path); ok {",
+			"      return nil",
+			"    }",
+			"    return nil",
+			"  })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "overrideasyncfunc", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), "await filepath.WalkDir") {
+		t.Fatalf("override async function call was not awaited:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), "$.functionValue(async") {
+		t.Fatalf("walk callback was not lowered as async:\n%s", string(content))
+	}
+}

package/compiler/package-graph_test.go

@@ -258,6 +258,55 @@ func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
 	}
 }
 
+func TestPackageGraphDetectsExternalOverrideCandidates(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": strings.Join([]string{
+			"module example.test/externaloverride",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/lib v0.0.0",
+			"replace example.test/lib => ./lib",
+			"",
+		}, "\n"),
+		"main.go": "package main\nimport \"example.test/lib\"\nfunc main() { lib.Run() }\n",
+		"lib/go.mod": strings.Join([]string{
+			"module example.test/lib",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/heavy v0.0.0",
+			"replace example.test/heavy => ../heavy",
+			"",
+		}, "\n"),
+		"lib/lib.go":     "package lib\nimport \"example.test/heavy\"\nfunc Run() { heavy.Run() }\n",
+		"heavy/go.mod":   "module example.test/heavy\n\ngo 1.25.3\n",
+		"heavy/heavy.go": "package heavy\nfunc Run() {}\n",
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/lib/index.ts", "export function Run(): void {}\n")
+
+	overrideOwner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}
+	graph, diagnostics := NewPackageGraphOwner(overrideOwner).Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("package graph failed: %#v", diagnostics)
+	}
+	lib := graph.NodesByPackagePath["example.test/lib"]
+	if lib == nil || !lib.OverrideCandidate {
+		t.Fatalf("expected external override candidate for lib")
+	}
+	if graph.NodesByPackagePath["example.test/heavy"] != nil {
+		t.Fatalf("external override dependency should not be collected")
+	}
+}
+
 func TestPackageGraphOverrideCandidatesRequirePackageIndex(t *testing.T) {
 	parent := "github.com/aperturerobotics/wasivm/wazero/kernel"
 	child := parent + "/runtime"
@@ -293,17 +342,23 @@ func writePackageGraphFixture(t *testing.T, files map[string]string) string {
 
 	dir := t.TempDir()
 	for name, contents := range files {
-		path := filepath.Join(dir, name)
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatal(err.Error())
-		}
-		if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
-			t.Fatal(err.Error())
-		}
+		writeFixtureFile(t, dir, name, contents)
 	}
 	return dir
 }
 
+func writeFixtureFile(t *testing.T, root, name, contents string) {
+	t.Helper()
+
+	path := filepath.Join(root, filepath.FromSlash(name))
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+		t.Fatal(err.Error())
+	}
+}
+
 func requireDiagnosticCode(t *testing.T, diagnostics []Diagnostic, code string) {
 	t.Helper()
 

package/compiler/package-test-graph-variant.go

@@ -2,8 +2,8 @@ package compiler
 
 import (
 	"go/ast"
-	"go/types"
 	"slices"
+	"strconv"
 	"strings"
 	"unicode"
 
@@ -57,13 +57,10 @@ func discoverPackageTestFunctions(pkg *packages.Package) []PackageTestFunction {
 	}
 	var tests []PackageTestFunction
 	for _, file := range pkg.Syntax {
+		testingAliases := fileTestingAliases(file)
 		for _, decl := range file.Decls {
-			fn, ok := decl.(*ast.FuncDecl)
-			if !ok || fn.Recv != nil || !isTestName(fn.Name.Name) {
-				continue
-			}
-			obj, _ := pkg.TypesInfo.Defs[fn.Name].(*types.Func)
-			if !isOrdinaryTestFunc(obj) {
+			fn, _ := decl.(*ast.FuncDecl)
+			if !isOrdinaryTestFuncDecl(fn, testingAliases) {
 				continue
 			}
 			tests = append(tests, PackageTestFunction{
@@ -75,23 +72,50 @@ func discoverPackageTestFunctions(pkg *packages.Package) []PackageTestFunction {
 	return tests
 }
 
-func isOrdinaryTestFunc(fn *types.Func) bool {
-	if fn == nil {
+func isOrdinaryTestFuncDecl(fn *ast.FuncDecl, testingAliases map[string]bool) bool {
+	if fn == nil || fn.Recv != nil || !isTestName(fn.Name.Name) || fn.Type == nil {
+		return false
+	}
+	if fn.Type.Results != nil && len(fn.Type.Results.List) != 0 {
 		return false
 	}
-	sig, _ := fn.Type().(*types.Signature)
-	if sig == nil || sig.Params().Len() != 1 || sig.Results().Len() != 0 {
+	if fn.Type.Params == nil || len(fn.Type.Params.List) != 1 {
 		return false
 	}
-	ptr, _ := sig.Params().At(0).Type().(*types.Pointer)
-	if ptr == nil {
+	param := fn.Type.Params.List[0]
+	if len(param.Names) > 1 {
 		return false
 	}
-	named, _ := ptr.Elem().(*types.Named)
-	if named == nil || named.Obj() == nil || named.Obj().Pkg() == nil {
+	ptr, ok := param.Type.(*ast.StarExpr)
+	return ok && isTestingT(ptr.X, testingAliases)
+}
+
+func fileTestingAliases(file *ast.File) map[string]bool {
+	aliases := make(map[string]bool)
+	for _, imp := range file.Imports {
+		path, err := strconv.Unquote(imp.Path.Value)
+		if err != nil || path != "testing" {
+			continue
+		}
+		name := "testing"
+		if imp.Name != nil {
+			name = imp.Name.Name
+		}
+		aliases[name] = true
+	}
+	return aliases
+}
+
+func isTestingT(expr ast.Expr, aliases map[string]bool) bool {
+	switch typed := expr.(type) {
+	case *ast.SelectorExpr:
+		base, _ := typed.X.(*ast.Ident)
+		return base != nil && aliases[base.Name] && typed.Sel.Name == "T"
+	case *ast.Ident:
+		return aliases["."] && typed.Name == "T"
+	default:
 		return false
 	}
-	return named.Obj().Name() == "T" && named.Obj().Pkg().Path() == "testing"
 }
 
 func isTestName(name string) bool {

package/compiler/package-test-graph.go

@@ -47,12 +47,7 @@ func (o *PackageGraphOwner) LoadTestGraph(ctx context.Context, req *CompileReque
 			packages.NeedFiles |
 			packages.NeedCompiledGoFiles |
 			packages.NeedImports |
-			packages.NeedDeps |
-			packages.NeedExportFile |
-			packages.NeedTypes |
 			packages.NeedSyntax |
-			packages.NeedTypesInfo |
-			packages.NeedTypesSizes |
 			packages.NeedForTest |
 			packages.NeedModule,
 	}

package/compiler/package-test-graph_test.go

@@ -3,6 +3,7 @@ package compiler
 import (
 	"context"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 )
@@ -21,9 +22,11 @@ func TestPackageGraphOwnerLoadTestGraphFacts(t *testing.T) {
 		"same/value_test.go": strings.Join([]string{
 			"package same",
 			"",
-			"import \"testing\"",
+			"import testpkg \"testing\"",
 			"",
-			"func TestAdd(t *testing.T) {}",
+			"func TestAdd(t *testpkg.T) {}",
+			"func TestIgnoredBadSignature(t *badT) {}",
+			"type badT struct{}",
 			"",
 		}, "\n"),
 		"external/value.go": strings.Join([]string{
@@ -69,6 +72,9 @@ func TestPackageGraphOwnerLoadTestGraphFacts(t *testing.T) {
 	if same == nil || same.SamePackageTests == nil || same.ExternalPackageTests != nil || !same.HasTests() {
 		t.Fatalf("unexpected same-package facts: %#v", same)
 	}
+	if len(same.SamePackageTests.Tests) != 1 || same.SamePackageTests.Tests[0].Name != "TestAdd" {
+		t.Fatalf("same-package test discovery should keep only ordinary tests: %#v", same.SamePackageTests.Tests)
+	}
 	external := graph.PackageByPath("example.test/testgraph/external")
 	if external == nil || external.ExternalPackageTests == nil || external.SamePackageTests != nil || !external.HasTests() {
 		t.Fatalf("unexpected external-package facts: %#v", external)
@@ -105,7 +111,7 @@ func TestPackageGraphOwnerLoadTestGraphScopesDiagnostics(t *testing.T) {
 			"import \"testing\"",
 			"",
 			"func TestBroken(t *testing.T) {",
-			"\tMissing()",
+			"\tif {",
 			"}",
 			"",
 		}, "\n"),
@@ -133,6 +139,58 @@ func TestPackageGraphOwnerLoadTestGraphScopesDiagnostics(t *testing.T) {
 	}
 }
 
+func TestPackageGraphOwnerLoadTestGraphDoesNotLoadDependencies(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testgraphdeps\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int {",
+			"\treturn 1",
+			"}",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\t\"example.test/testgraphdeps/brokendep\"",
+			")",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\t_ = brokendep.Value",
+			"}",
+			"",
+		}, "\n"),
+		"brokendep/value.go": strings.Join([]string{
+			"package brokendep",
+			"",
+			"const Value =",
+			"",
+		}, "\n"),
+	})
+
+	graph, diagnostics := loadPackageTestGraph(t, &CompileRequest{
+		Patterns:            []string{"./clean"},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("test graph discovery should not load dependency bodies: %#v", diagnostics)
+	}
+	clean := graph.PackageByPath("example.test/testgraphdeps/clean")
+	if clean == nil || clean.SamePackageTests == nil || len(clean.SamePackageTests.Tests) != 1 {
+		t.Fatalf("clean package test discovery failed: %#v", clean)
+	}
+	if !slices.Contains(clean.SamePackageTests.Imports, "example.test/testgraphdeps/brokendep") {
+		t.Fatalf("test graph should retain direct test imports: %#v", clean.SamePackageTests.Imports)
+	}
+}
+
 func loadPackageTestGraph(t *testing.T, req *CompileRequest) (*PackageTestGraph, []Diagnostic) {
 	t.Helper()