goscript 0.1.2 → 0.1.4

package/compiler/skeleton_test.go

@@ -132,7 +132,7 @@ func TestCompilePackagesEmitsSimplePackage(t *testing.T) {
 		"export async function main(): globalThis.Promise<void>",
 		"let size = 5",
 		"$.print(\"total:\", size)",
-		"$.println(Greeting, total)",
+		"$.println(\"Hello\", total)",
 		"$.panic(\"unreachable\")",
 		"await main()",
 	} {
@@ -215,11 +215,11 @@ func TestCompilePackagesLazilyInitializesCrossFilePackageVars(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let two: holder = undefined as unknown as holder",
+		"export var two: holder",
 		"export function __goscript_get_two(): holder",
-		"export let remoteZero: __goscript_a.remote = undefined as unknown as __goscript_a.remote",
+		"export var remoteZero: __goscript_a.remote",
 		"export function __goscript_get_remoteZero(): __goscript_a.remote",
-		"__goscript_a.one",
+		"__goscript_a.__goscript_get_one()",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -263,7 +263,7 @@ func TestCompilePackagesLazilyInitializesSameFileLaterPackageVars(t *testing.T)
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let table: $.Slice<detail> = undefined as unknown as $.Slice<detail>",
+		"export var table: $.Slice<detail>",
 		"export function __goscript_get_table(): $.Slice<detail>",
 		"export let later: detail = $.markAsStructValue(new detail({n: 7}))",
 	} {
@@ -305,7 +305,7 @@ func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *t
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let first: Point | $.VarRef<Point> | null = undefined as unknown as Point | $.VarRef<Point> | null",
+		"export var first: Point | $.VarRef<Point> | null",
 		"export function __goscript_get_first(): Point | $.VarRef<Point> | null",
 		"function __goscript_get___goscriptTuple",
 		"export let later: number = 7",
@@ -316,6 +316,67 @@ func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *t
 	}
 }
 
+func TestCompilePackagesLazilyInitializesEffectFreeTypeForFromCrossFileInit(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/lazytypefor\n\ngo 1.25.3\n",
+		"a.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"var stringType = reflect.TypeFor[string]()",
+			"var _ = marker",
+			"",
+		}, "\n"),
+		"b.go": strings.Join([]string{
+			"package main",
+			"func readStringType() { println(stringType != nil) }",
+			"func main() {}",
+			"",
+		}, "\n"),
+		"c.go": strings.Join([]string{
+			"package main",
+			"var marker = 1",
+			"func init() { readStringType() }",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	aFile := filepath.Join(outputDir, "@goscript", "example.test", "lazytypefor", "a.gs.ts")
+	aContent, err := os.ReadFile(aFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	aText := string(aContent)
+	for _, want := range []string{
+		"export var stringType: reflect.Type | null",
+		"export function __goscript_get_stringType(): reflect.Type | null",
+		"stringType = reflect.TypeFor",
+	} {
+		if !strings.Contains(aText, want) {
+			t.Fatalf("missing %q in generated a.go output:\n%s", want, aText)
+		}
+	}
+	bFile := filepath.Join(outputDir, "@goscript", "example.test", "lazytypefor", "b.gs.ts")
+	bContent, err := os.ReadFile(bFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	bText := string(bContent)
+	if !strings.Contains(bText, "__goscript_a.__goscript_get_stringType() != null") {
+		t.Fatalf("missing lazy TypeFor package var getter use:\n%s", bText)
+	}
+	if strings.Contains(bText, "__goscript_a.stringType != null") {
+		t.Fatalf("cross-file init still reads TypeFor package var directly:\n%s", bText)
+	}
+}
+
 func TestCompilePackagesInitializesLazyAsyncPackageVarsBeforeInit(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/lazyasyncvars\n\ngo 1.25.3\n",
@@ -392,8 +453,8 @@ func TestCompilePackagesAssignsLazyPackageVarsDirectly(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "table = $.append(__goscript_get_table(), 2)") {
-		t.Fatalf("missing direct lazy package var assignment:\n%s", text)
+	if !strings.Contains(text, "__goscript_set_table($.append(__goscript_get_table(), 2))") {
+		t.Fatalf("missing lazy package var assignment through setter:\n%s", text)
 	}
 	if strings.Contains(text, "__goscript_get_table() =") {
 		t.Fatalf("lazy getter used as assignment target:\n%s", text)
@@ -489,6 +550,204 @@ func TestCompilePackagesAliasesForInitShortDeclShadow(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesDoesNotAliasPackageShadowWithoutRead(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/packageshadow\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"var value = 1",
+			"func main() {",
+			"  value := 2",
+			"  var other = 3",
+			"  println(value, other)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, 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(outputDir, "@goscript", "example.test", "packageshadow", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "let value = 2") {
+		t.Fatalf("local package shadow was not emitted with its source name:\n%s", text)
+	}
+	if strings.Contains(text, "__goscriptShadow") {
+		t.Fatalf("package shadow without initializer read should not allocate a shadow alias:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAliasesPackageShadowInitializerReads(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/packageshadowread\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"var value = 1",
+			"func helper() int { return 4 }",
+			"func main() {",
+			"  println(helper())",
+			"  helper := 5",
+			"  println(helper)",
+			"  first := value",
+			"  value := value + 1",
+			"  {",
+			"    var first = first + value",
+			"    println(first)",
+			"  }",
+			"  println(value)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, 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(outputDir, "@goscript", "example.test", "packageshadowread", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "let value = value + 1") || strings.Contains(text, "let first: number = 0\n\t\tfirst = first + value") {
+		t.Fatalf("initializer read was emitted through a TDZ self-reference:\n%s", text)
+	}
+	if strings.Contains(text, "let helper = 5") {
+		t.Fatalf("same-file package function shadow was emitted with a TDZ-prone source name:\n%s", text)
+	}
+	if strings.Count(text, "__goscriptShadow") < 3 {
+		t.Fatalf("missing shadow aliases for initializer reads:\n%s", text)
+	}
+}
+
+func TestCompilePackagesLowersPackageConstBeforeLocalShadow(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/constshadow\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"const headerLength = 4",
+			"func parse(buf []byte) int {",
+			"  if len(buf) < headerLength {",
+			"    return headerLength",
+			"  }",
+			"  n := len(buf)",
+			"  headerLength := n",
+			"  return headerLength",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, 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(outputDir, "@goscript", "example.test", "constshadow", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "$.len(buf) < headerLength") || strings.Contains(text, "return headerLength\n\t}") {
+		t.Fatalf("package const read was emitted through local TDZ shadow:\n%s", text)
+	}
+	if !strings.Contains(text, "$.len(buf) < 4") || !strings.Contains(text, "return 4") {
+		t.Fatalf("package const read was not lowered to a value before local shadow:\n%s", text)
+	}
+	if !strings.Contains(text, "let headerLength = n") {
+		t.Fatalf("local shadow was not preserved:\n%s", text)
+	}
+}
+
+func TestCompilePackagesPreservesNamedUint64InterfaceTypeInfo(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/nameduint64\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Pol uint64",
+			"func (p Pol) String() string { return \"\" }",
+			"func box() any {",
+			"  var p Pol",
+			"  return &p",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, 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(outputDir, "@goscript", "example.test", "nameduint64", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	want := `$.namedValueInterfaceValue<any>(p, "*main.Pol"`
+	if !strings.Contains(text, want) {
+		t.Fatalf("missing named interface box %q in generated output:\n%s", want, text)
+	}
+	want = `elemType: { kind: $.TypeKind.Basic, name: "uint64", typeName: "main.Pol" }`
+	if !strings.Contains(text, want) {
+		t.Fatalf("named uint64 pointer interface box lost type metadata:\n%s", text)
+	}
+}
+
+func TestCompilePackagesLowersWideIntegerConstantsForUint64Targets(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/wideconst\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Pol uint64",
+			"func normalize(f Pol) Pol {",
+			"  f &= Pol((1 << 54) - 1)",
+			"  f |= (1 << 53) | 1",
+			"  return f",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, 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(outputDir, "@goscript", "example.test", "wideconst", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{`$.uint("18014398509481983", 64)`, `$.uint("9007199254740993", 64)`} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing wide integer constant %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesReadsShadowedVarRefStructFieldsOnce(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/shadowvarreffield\n\ngo 1.25.3\n",
@@ -803,6 +1062,47 @@ func TestCompilePackagesUsesEmbedOverride(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesEmbedsFS(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":             "module example.test/embedfs\n\ngo 1.25.3\n",
+		"assets/config.json": `{"ok":true}`,
+		"assets/nested.txt":  "nested",
+		"extra.txt":          "extra",
+		"main.go": strings.Join([]string{
+			"package embedfs",
+			"import \"embed\"",
+			"//go:embed assets *.txt",
+			"var StaticFS embed.FS",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir, 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(outputDir, "@goscript", "example.test", "embedfs", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), `export let StaticFS: embed.FS = $.markAsStructValue(new embed.FS`) {
+		t.Fatalf("embedded FS was not emitted as embed.FS:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), `["assets/config.json", new Uint8Array([123, 34, 111, 107, 34, 58, 116, 114, 117, 101, 125])]`) {
+		t.Fatalf("embedded FS file content was not emitted:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), `["assets/nested.txt", new Uint8Array([110, 101, 115, 116, 101, 100])]`) {
+		t.Fatalf("embedded FS directory file content was not emitted:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), `["extra.txt", new Uint8Array([101, 120, 116, 114, 97])]`) {
+		t.Fatalf("embedded FS glob file content was not emitted:\n%s", string(content))
+	}
+}
+
 func TestCompilePackagesEmitsPackageLocalImport(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/imports\n\ngo 1.25.3\n",
@@ -889,6 +1189,94 @@ func TestCompilePackagesEmitsPackageLocalImport(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesCallsCrossPackageUnexportedReceiverDynamically(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unexportedreceiver\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type hidden struct{}",
+			"func NewHidden() *hidden { return &hidden{} }",
+			"func (h *hidden) Value() int { return 7 }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/unexportedreceiver/dep\"",
+			"func main() {",
+			"  h := dep.NewHidden()",
+			"  println(h.Value())",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      outputDir,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	mainFile := filepath.Join(outputDir, "@goscript", "example.test", "unexportedreceiver", "main.gs.ts")
+	mainContent, err := os.ReadFile(mainFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(mainContent), "$.pointerValue<any>(h).Value()") {
+		t.Fatalf("cross-package unexported receiver method call was not dynamic:\n%s", string(mainContent))
+	}
+	if strings.Contains(string(mainContent), "dep.hidden.prototype.Value.call") {
+		t.Fatalf("cross-package unexported receiver leaked through imported prototype:\n%s", string(mainContent))
+	}
+}
+
+func TestCompilePackagesEmitsTypeOnlyLocalImports(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/typeonlylocal\n\ngo 1.25.3\n",
+		"a.go": strings.Join([]string{
+			"package main",
+			"type Acceptor interface {",
+			"  Accept(Payload)",
+			"}",
+			"",
+		}, "\n"),
+		"payload.go": strings.Join([]string{
+			"package main",
+			"type Payload struct {",
+			"  Value string",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{
+		Dir:        moduleDir,
+		OutputPath: outputDir,
+	}, 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(outputDir, "@goscript", "example.test", "typeonlylocal", "a.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "import type * as __goscript_payload from \"./payload.gs.ts\"") {
+		t.Fatalf("missing type-only same-package import:\n%s", text)
+	}
+	if strings.Contains(text, "import \"./payload.gs.ts\"") {
+		t.Fatalf("type-only same-package import should not force sibling module execution:\n%s", text)
+	}
+}
+
 func TestCompilePackagesPreservesSourceImportAliasesForAssociatedMethods(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/sourcealiases\n\ngo 1.25.3\n",
@@ -1004,8 +1392,7 @@ func TestCompilePackagesEmitsSideEffectImportsForInterfaceRegistry(t *testing.T)
 	for _, want := range []string{
 		"import * as dep from \"@goscript/example.test/interface-registry/dep/index.js\"",
 		"import \"@goscript/example.test/interface-registry/dep/index.js\"",
-		"import * as __goscript_local from \"./local.gs.ts\"",
-		"import \"./local.gs.ts\"",
+		"import type * as __goscript_local from \"./local.gs.ts\"",
 		"case $.typeAssert<Exclude<__goscript_local.Local, null>>(__goscriptTypeSwitchValue, \"main.Local\").ok",
 		"$.typeAssertTuple<dep.Remote | null>(v, \"dep.Remote\")",
 	} {
@@ -1130,7 +1517,7 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 		"Counter.prototype.Set.call(NewCounter(), 5)",
 		"let [, ok] = $.typeAssertTuple<Counter | $.VarRef<Counter> | null>(iface, { kind: $.TypeKind.Pointer, elemType: \"main.Counter\" })",
 		"\"Value\": { type: { kind: $.TypeKind.Basic, name: \"int\" }, tag: \"json:\\\"value\\\"\" }",
-		"\"ID\": { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.ObjectID\" }",
+		"\"ID\": { kind: $.TypeKind.Basic, name: \"int32\", typeName: \"main.ObjectID\" }",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -1138,7 +1525,153 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	}
 }
 
-func TestCompilePackagesClonesNestedStructFieldsWithCloneMethodCollision(t *testing.T) {
+func TestCompilePackagesEscapesReservedTypeNames(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/reservedtypes\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type static struct {",
+			"  Value int",
+			"}",
+			"func newStatic() *static {",
+			"  return &static{Value: 7}",
+			"}",
+			"func (s *static) Read() int {",
+			"  return s.Value",
+			"}",
+			"func main() {",
+			"  println(newStatic().Read())",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "reservedtypes", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export class _static",
+		"new _static({Value: 7})",
+		"public Read(): number",
+		"_static.prototype.Read.call(newStatic())",
+		"\"main.static\"",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "class static") {
+		t.Fatalf("reserved type name was not escaped:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAvoidsPointerMethodTypeNameShadow(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/methodshadow\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type item struct {",
+			"  Value int",
+			"}",
+			"func (i *item) read() int {",
+			"  return i.Value",
+			"}",
+			"func total(items []*item) int {",
+			"  sum := 0",
+			"  for _, item := range items {",
+			"    sum += item.read()",
+			"  }",
+			"  return sum",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "methodshadow", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.pointerValue<item>(item).read()") {
+		t.Fatalf("missing direct pointer method call for shadowed type name:\n%s", text)
+	}
+	if strings.Contains(text, "item.prototype.read.call(item") {
+		t.Fatalf("shadowed local variable used as method class:\n%s", text)
+	}
+}
+
+func TestCompilePackagesErasesUnimportedTransitiveInterfaceField(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/transitivefield\n\ngo 1.25.3\n",
+		"hash/hash.go": strings.Join([]string{
+			"package hash",
+			"type Hash interface {",
+			"  Write([]byte) (int, error)",
+			"}",
+			"",
+		}, "\n"),
+		"holder/holder.go": strings.Join([]string{
+			"package holder",
+			"import \"example.test/transitivefield/hash\"",
+			"type Hasher struct {",
+			"  hash.Hash",
+			"}",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/transitivefield/holder\"",
+			"func write(h holder.Hasher, p []byte) error {",
+			"  _, err := h.Hash.Write(p)",
+			"  return err",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "transitivefield", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.pointerValue<any>(h.Hash).Write(p)") {
+		t.Fatalf("missing erased transitive interface field type:\n%s", text)
+	}
+	if strings.Contains(text, "Exclude<Hash") {
+		t.Fatalf("unimported transitive interface type leaked into output:\n%s", text)
+	}
+}
+
+func TestCompilePackagesClonesNestedStructFieldsWithCloneMethodCollision(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/nestedclone\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
@@ -1341,6 +1874,47 @@ func TestCompilePackagesWrapsAddressedMapRangeValue(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersTupleAssignmentToMapIndexSet(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/maptupleassign\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func resolve(k string) (int, error) { return 7, nil }",
+			"func Apply(keys []string) (map[string]int, error) {",
+			"  out := make(map[string]int)",
+			"  var err error",
+			"  for _, k := range keys {",
+			"    out[k], err = resolve(k)",
+			"    if err != nil { return nil, err }",
+			"  }",
+			"  return out, nil",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "maptupleassign", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.mapSet(out, k, __goscriptTuple") {
+		t.Fatalf("tuple assignment to map index did not write through mapSet:\n%s", text)
+	}
+	if strings.Contains(text, "$.mapGet(out, k, 0)[0] =") {
+		t.Fatalf("tuple assignment still mutates mapGet tuple instead of map:\n%s", text)
+	}
+}
+
 func TestCompilePackagesLowersPromotedNamedPrimitiveMethod(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/promotedprimitive\n\ngo 1.25.3\n",
@@ -1673,6 +2247,51 @@ func TestCompilePackagesLowersStringOrderingThroughRuntime(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesConvertsOverrideNamedStringToString(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/reflecttag\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"reflect\"",
+			"  \"strings\"",
+			")",
+			"func tagText(st reflect.Type) string {",
+			"  field := st.Field(0)",
+			"  tag := field.Tag.Get(\"yaml\")",
+			"  if tag == \"\" && strings.Index(string(field.Tag), \":\") < 0 {",
+			"    tag = string(field.Tag)",
+			"  }",
+			"  return tag",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "reflecttag", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		`strings.Index(String(field.Tag), ":")`,
+		`tag = String(field.Tag)`,
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssertions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/interfaces\n\ngo 1.25.3\n",
@@ -1887,6 +2506,48 @@ func TestCompilePackagesBoxesTypedNilInterfaceValues(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesBoxesAliasPointerInterfacesWithTargetRuntimeType(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/alias-interface-box\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type CloudError struct{}",
+			"func (*CloudError) Error() string { return \"cloud\" }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/alias-interface-box/dep\"",
+			"type cloudError = dep.CloudError",
+			"func Build() error {",
+			"  return &cloudError{}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "alias-interface-box", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.interfaceValue<$.GoError>(new dep.CloudError(), \"*dep.CloudError\")") {
+		t.Fatalf("alias pointer was not boxed with target runtime type:\n%s", text)
+	}
+	if strings.Contains(text, "*main.cloudError") {
+		t.Fatalf("alias pointer leaked alias runtime type:\n%s", text)
+	}
+}
+
 func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/generics\n\ngo 1.25.3\n",
@@ -1951,9 +2612,66 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 		"$.mapSet(seen, 1, {})",
 		"$.genericZero(__typeArgs, \"T\", null)",
 		"$.callGenericMethod(__typeArgs, \"T\", \"String\", v)",
-		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }})",
-		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }}, zero)",
-		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }}, null)",
+		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }})",
+		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, zero)",
+		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, null)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesInfersGenericTypeArgsFromNamedArgument(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/genericnamedarg\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package genericnamedarg",
+			"type Source interface { Load() int }",
+			"type auto struct{}",
+			"func (a *auto) Load() int { return 7 }",
+			"type key[T any] struct { name string }",
+			"type entry struct { factory any }",
+			"var entries = map[string]*entry{}",
+			"func NewKey[T any](name string) key[T] {",
+			"  entries[name] = &entry{}",
+			"  return key[T]{name: name}",
+			"}",
+			"func Register[T any](key key[T], factory func() T) {",
+			"  entries[key.name].factory = factory",
+			"}",
+			"func Get[T any](key key[T]) T {",
+			"  f := entries[key.name].factory",
+			"  return f.(func() T)()",
+			"}",
+			"var loader = NewKey[Source](\"source\")",
+			"func Use() int {",
+			"  Register(loader, func() Source { return &auto{} })",
+			"  src := Get(loader)",
+			"  return src.Load()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "genericnamedarg", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"await Get({T: { type: \"genericnamedarg.Source\", zero: () => null, methods: {Load: (receiver: any, ...args: any[]) => receiver.Load(...args)} }}, $.markAsStructValue($.cloneStructValue(loader)))",
+		"return await $.mustTypeAssert<(() => any | globalThis.Promise<any>) | null>(f, ({ kind: $.TypeKind.Function, params: [], results: [{ kind: $.TypeKind.Interface, methods: [] }] } as $.FunctionTypeInfo))!()",
+		"return $.pointerValue<Exclude<Source, null>>(src).Load()",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -1974,8 +2692,10 @@ func TestCompilePackagesAttachesFunctionLiteralTypeInfo(t *testing.T) {
 			"  fn := func(value int) string {",
 			"    return \"\"",
 			"  }",
+			"  var zero Callback",
 			"  var cb Callback = nil",
 			"  _ = fn",
+			"  _ = zero",
 			"  _ = cb",
 			"  _ = call(fn)",
 			"}",
@@ -2000,6 +2720,8 @@ func TestCompilePackagesAttachesFunctionLiteralTypeInfo(t *testing.T) {
 	for _, want := range []string{
 		"export type Callback = ((value: number) => string | globalThis.Promise<string>) | null",
 		"export async function call(cb: ((value: number) => string | globalThis.Promise<string>) | null): globalThis.Promise<string> {\n\treturn await cb!(1)",
+		"let zero: Callback | null = null as unknown as Callback | null",
+		"let cb: Callback | null = (null as Callback | null)",
 		"$.functionValue((value: number): string => {",
 		"kind: $.TypeKind.Function",
 		"params: [{ kind: $.TypeKind.Basic, name: \"int\" }]",
@@ -2162,31 +2884,21 @@ func TestCompilePackagesPacksVariadicCallsInGeneratedSubpackage(t *testing.T) {
 	}
 }
 
-func TestCompilePackagesImportsSelectedExternalFieldTypes(t *testing.T) {
+func TestCompilePackagesBoxesNumericVariadicInterfaceArgs(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/selected-field-import\n\ngo 1.25.3\n",
-		"dep/dep.go": strings.Join([]string{
-			"package dep",
-			"type URL struct { Path string }",
-			"",
-		}, "\n"),
-		"api/api.go": strings.Join([]string{
-			"package api",
-			"import \"example.test/selected-field-import/dep\"",
-			"type Request struct { URL *dep.URL }",
-			"",
-		}, "\n"),
+		"go.mod": "module example.test/numeric-interface\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
-			"package main",
-			"import \"example.test/selected-field-import/api\"",
-			"func requestPath(r *api.Request) string {",
-			"  return r.URL.Path",
+			"package numericinterface",
+			"func collect(values ...any) {}",
+			"func main() {",
+			"  var version int32 = 2",
+			"  collect(version, uint32(3))",
 			"}",
 			"",
 		}, "\n"),
 	})
 	outputDir := filepath.Join(t.TempDir(), "output")
-	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir, AllDependencies: true}, nil, nil)
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -2194,15 +2906,15 @@ func TestCompilePackagesImportsSelectedExternalFieldTypes(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "selected-field-import", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "numeric-interface", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"import * as dep from \"@goscript/example.test/selected-field-import/dep/index.js\"",
-		"$.pointerValue<dep.URL>($.pointerValue<api.Request>(r).URL).Path",
+		"$.namedValueInterfaceValue<any>(version, \"int32\", {}, { kind: $.TypeKind.Basic, name: \"int32\" })",
+		"$.namedValueInterfaceValue<any>($.uint(3, 32), \"uint32\", {}, { kind: $.TypeKind.Basic, name: \"uint32\" })",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -2210,22 +2922,114 @@ func TestCompilePackagesImportsSelectedExternalFieldTypes(t *testing.T) {
 	}
 }
 
-func TestCompilePackagesErasesUnavailableOverrideFieldTypes(t *testing.T) {
+func TestCompilePackagesAwaitsFmtWriterOverrides(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/override-field-type\n\ngo 1.25.3\n",
-		"dep/dep.go": strings.Join([]string{
-			"package dep",
-			"type URL struct { Path string }",
-			"",
-		}, "\n"),
-		"api/api.go": strings.Join([]string{
-			"package api",
-			"import \"example.test/override-field-type/dep\"",
-			"type Request struct { URL *dep.URL }",
+		"go.mod": "module example.test/fmt-writer\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package fmtwriter",
+			"import \"fmt\"",
+			"type writer struct { buf []byte }",
+			"func (w *writer) Write(p []byte) (int, error) {",
+			"  w.buf = append(w.buf, p...)",
+			"  return len(p), nil",
+			"}",
+			"func Use(w *writer) error {",
+			"  _, err := fmt.Fprintf(w, \"%s\", \"ok\")",
+			"  return err",
+			"}",
 			"",
 		}, "\n"),
-		"main.go": strings.Join([]string{
-			"package main",
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "fmt-writer", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use",
+		"await fmt.Fprintf(",
+		"return err",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesImportsSelectedExternalFieldTypes(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/selected-field-import\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type URL struct { Path string }",
+			"",
+		}, "\n"),
+		"api/api.go": strings.Join([]string{
+			"package api",
+			"import \"example.test/selected-field-import/dep\"",
+			"type Request struct { URL *dep.URL }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/selected-field-import/api\"",
+			"func requestPath(r *api.Request) string {",
+			"  return r.URL.Path",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir, AllDependencies: true}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "selected-field-import", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"import * as dep from \"@goscript/example.test/selected-field-import/dep/index.js\"",
+		"$.pointerValue<dep.URL>($.pointerValue<api.Request>(r).URL).Path",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesErasesUnavailableOverrideFieldTypes(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/override-field-type\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type URL struct { Path string }",
+			"",
+		}, "\n"),
+		"api/api.go": strings.Join([]string{
+			"package api",
+			"import \"example.test/override-field-type/dep\"",
+			"type Request struct { URL *dep.URL }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
 			"import \"example.test/override-field-type/api\"",
 			"func requestPath(r *api.Request) string {",
 			"  return r.URL.Path",
@@ -2555,6 +3359,468 @@ func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesPropagatesAsyncGenericInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/genericasynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package genericasynciface",
+			"import \"context\"",
+			"type Watchable[T comparable] interface {",
+			"  Get() T",
+			"  Wait(ctx context.Context, old T) T",
+			"}",
+			"type Box[T comparable] struct { ch chan T; val T }",
+			"func (b *Box[T]) Get() T { return b.val }",
+			"func (b *Box[T]) Wait(ctx context.Context, old T) T {",
+			"  select {",
+			"  case v := <-b.ch:",
+			"    return v",
+			"  case <-ctx.Done():",
+			"    return old",
+			"  }",
+			"}",
+			"func Use(ctx context.Context, w Watchable[int], old int) int {",
+			"  return w.Wait(ctx, old)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "genericasynciface", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"Wait(ctx: context.Context | null, old: any): any | globalThis.Promise<any>",
+		"public async Wait(ctx: context.Context | null, old: any): globalThis.Promise<any>",
+		"return (await $.pointerValue<Exclude<Watchable, null>>(w).Wait(ctx, old) as number)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesPropagatesAsyncAnonymousInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/anonymousasynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package anonymousasynciface",
+			"import \"context\"",
+			"type Snapshot int",
+			"type Watcher struct { ch chan Snapshot }",
+			"func (w *Watcher) WaitValueChange(ctx context.Context, old Snapshot, errCh <-chan error) (Snapshot, error) {",
+			"  select {",
+			"  case v := <-w.ch:",
+			"    return v, nil",
+			"  case err := <-errCh:",
+			"    return old, err",
+			"  case <-ctx.Done():",
+			"    return old, ctx.Err()",
+			"  }",
+			"}",
+			"func Use(ctx context.Context, w interface {",
+			"  WaitValueChange(context.Context, Snapshot, <-chan error) (Snapshot, error)",
+			"}, old Snapshot) (Snapshot, error) {",
+			"  return w.WaitValueChange(ctx, old, nil)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "anonymousasynciface", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(ctx: context.Context | null, w: any, old: Snapshot): globalThis.Promise<[Snapshot, $.GoError]>",
+		"return await $.pointerValue<any>(w).WaitValueChange(ctx, old, null)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesPropagatesAsyncThroughInstantiatedNamedInterface(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/instantiatedasynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package instantiatedasynciface",
+			"import \"context\"",
+			"type Snapshot int",
+			"type Watchable[T any] interface {",
+			"  WaitValueChange(context.Context, T, <-chan error) (T, error)",
+			"}",
+			"type Container[T any] struct { ch chan T }",
+			"func (c *Container[T]) WaitValueChange(ctx context.Context, old T, errCh <-chan error) (T, error) {",
+			"  select {",
+			"  case v := <-c.ch:",
+			"    return v, nil",
+			"  case err := <-errCh:",
+			"    return old, err",
+			"  case <-ctx.Done():",
+			"    return old, ctx.Err()",
+			"  }",
+			"}",
+			"func Bind(w Watchable[Snapshot]) {}",
+			"func Use(ctx context.Context, w interface {",
+			"  WaitValueChange(context.Context, Snapshot, <-chan error) (Snapshot, error)",
+			"}, old Snapshot) (Snapshot, error) {",
+			"  return w.WaitValueChange(ctx, old, nil)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "instantiatedasynciface", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(ctx: context.Context | null, w: any, old: Snapshot): globalThis.Promise<[Snapshot, $.GoError]>",
+		"return await $.pointerValue<any>(w).WaitValueChange(ctx, old, null)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesDoesNotAwaitUnmarkedAnonymousInterfaceMethod(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/anonymousifaceawait\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package anonymousifaceawait",
+			"import \"context\"",
+			"type Snapshot int",
+			"func Use(ctx context.Context, w interface {",
+			"  WaitValueChange(context.Context, Snapshot, <-chan error) (Snapshot, error)",
+			"}, ch <-chan struct{}, old Snapshot) (Snapshot, error) {",
+			"  select {",
+			"  case <-ch:",
+			"  default:",
+			"  }",
+			"  return w.WaitValueChange(ctx, old, nil)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "anonymousifaceawait", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "return await $.pointerValue<any>(w).WaitValueChange(ctx, old, null)") {
+		t.Fatalf("anonymous interface method call without an async implementation was awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesDoesNotInheritAsyncIntoSyncFunctionLiteral(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/syncfunclit\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package syncfunclit",
+			"type Directive interface{ GetDirective() any }",
+			"type Bridge struct{ keep func(Directive) (bool, error) }",
+			"func NewBridge(keep func(Directive) (bool, error)) *Bridge { return &Bridge{keep: keep} }",
+			"func Execute(ch <-chan struct{}) error {",
+			"  select {",
+			"  case <-ch:",
+			"  default:",
+			"  }",
+			"  _ = NewBridge(func(di Directive) (bool, error) {",
+			"    switch di.GetDirective().(type) {",
+			"    default:",
+			"      return true, nil",
+			"    }",
+			"  })",
+			"  return nil",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "syncfunclit", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "await $.pointerValue<Exclude<Directive, null>>(di).GetDirective()") {
+		t.Fatalf("sync function literal inherited async await:\n%s", text)
+	}
+}
+
+func TestCompilePackagesMarksRangeFuncAsyncWhenBodyAwaits(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/rangefuncawaitbody\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package rangefuncawaitbody",
+			"type Item struct{}",
+			"func (i *Item) Release(ch <-chan struct{}) {",
+			"  select {",
+			"  case <-ch:",
+			"  default:",
+			"  }",
+			"}",
+			"func Back(items []Item) func(func(int, Item) bool) {",
+			"  return func(yield func(int, Item) bool) {",
+			"    for i := len(items)-1; i >= 0; i-- {",
+			"      if !yield(i, items[i]) { return }",
+			"    }",
+			"  }",
+			"}",
+			"func Use(ch <-chan struct{}, items []Item) {",
+			"  defer func() {",
+			"    for _, v := range Back(items) {",
+			"      v.Release(ch)",
+			"    }",
+			"  }()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "rangefuncawaitbody", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		";await (async () => {",
+		"await v.value.Release(ch)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesPropagatesImportedAsyncGenericInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/importedgenericasynciface\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"import \"context\"",
+			"type Watchable[T comparable] interface {",
+			"  Get() T",
+			"  Wait(ctx context.Context, old T) T",
+			"}",
+			"type Box[T comparable] struct { ch chan T; val T }",
+			"func (b *Box[T]) Get() T { return b.val }",
+			"func (b *Box[T]) Wait(ctx context.Context, old T) T {",
+			"  select {",
+			"  case v := <-b.ch:",
+			"    return v",
+			"  case <-ctx.Done():",
+			"    return old",
+			"  }",
+			"}",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package importedgenericasynciface",
+			"import (",
+			"  \"context\"",
+			"  \"example.test/importedgenericasynciface/dep\"",
+			")",
+			"func Use(ctx context.Context, w dep.Watchable[int], old int) int {",
+			"  return w.Wait(ctx, old)",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	service := NewCompileService()
+	_, err := service.Compile(context.Background(), &CompileRequest{
+		Patterns:            []string{".", "./dep"},
+		Dir:                 moduleDir,
+		OutputPath:          outputDir,
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	depOutputFile := filepath.Join(outputDir, "@goscript", "example.test", "importedgenericasynciface", "dep", "dep.gs.ts")
+	depContent, err := os.ReadFile(depOutputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	depText := string(depContent)
+	for _, want := range []string{
+		"Wait(ctx: context.Context | null, old: any): any | globalThis.Promise<any>",
+		"public async Wait(ctx: context.Context | null, old: any): globalThis.Promise<any>",
+	} {
+		if !strings.Contains(depText, want) {
+			t.Fatalf("missing %q in generated dep output:\n%s", want, depText)
+		}
+	}
+
+	mainOutputFile := filepath.Join(outputDir, "@goscript", "example.test", "importedgenericasynciface", "main.gs.ts")
+	mainContent, err := os.ReadFile(mainOutputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	mainText := string(mainContent)
+	if want := "return (await $.pointerValue<Exclude<dep.Watchable, null>>(w).Wait(ctx, old) as number)"; !strings.Contains(mainText, want) {
+		t.Fatalf("missing %q in generated main output:\n%s", want, mainText)
+	}
+}
+
+func TestCompilePackagesPropagatesAsyncInterfaceMethodsFromTestImports(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/testimportasynciface\n\ngo 1.25.3\n",
+		"iface/provider.go": strings.Join([]string{
+			"package iface",
+			"import \"context\"",
+			"type Provider interface {",
+			"  Create(context.Context) (string, error)",
+			"}",
+			"",
+		}, "\n"),
+		"impl/provider.go": strings.Join([]string{
+			"package impl",
+			"import (",
+			"  \"context\"",
+			"  \"example.test/testimportasynciface/iface\"",
+			")",
+			"type Provider struct { ch chan string }",
+			"func NewProvider() iface.Provider {",
+			"  return &Provider{ch: make(chan string, 1)}",
+			"}",
+			"func (p *Provider) Create(ctx context.Context) (string, error) {",
+			"  select {",
+			"  case p.ch <- \"ok\":",
+			"  case <-ctx.Done():",
+			"    return \"\", ctx.Err()",
+			"  }",
+			"  return <-p.ch, nil",
+			"}",
+			"",
+		}, "\n"),
+		"use.go": strings.Join([]string{
+			"package testimportasynciface",
+			"import (",
+			"  \"context\"",
+			"  \"example.test/testimportasynciface/iface\"",
+			")",
+			"func Use(ctx context.Context, p iface.Provider) (string, error) {",
+			"  return p.Create(ctx)",
+			"}",
+			"",
+		}, "\n"),
+		"use_test.go": strings.Join([]string{
+			"package testimportasynciface",
+			"import (",
+			"  \"context\"",
+			"  \"testing\"",
+			"  \"example.test/testimportasynciface/impl\"",
+			")",
+			"func TestUse(t *testing.T) {",
+			"  p := impl.NewProvider()",
+			"  got, err := p.Create(context.Background())",
+			"  if err != nil || got != \"ok\" {",
+			"    t.Fatal(got, err)",
+			"  }",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	service := NewCompileService()
+	_, err := service.Compile(context.Background(), &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          outputDir,
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+		Tests:               true,
+		AllDependencies:     true,
+	})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	ifaceOutputFile := filepath.Join(outputDir, "@goscript", "example.test", "testimportasynciface", "iface", "provider.gs.ts")
+	ifaceContent, err := os.ReadFile(ifaceOutputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	ifaceText := string(ifaceContent)
+	if want := "Create(_p0: context.Context | null): [string, $.GoError] | globalThis.Promise<[string, $.GoError]>"; !strings.Contains(ifaceText, want) {
+		t.Fatalf("test-import implementation did not color interface method async:\n%s", ifaceText)
+	}
+
+	testOutputFile := filepath.Join(outputDir, "@goscript", "example.test", "testimportasynciface", "use_test.gs.ts")
+	testContent, err := os.ReadFile(testOutputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	testText := string(testContent)
+	if want := "let [got, err] = await $.pointerValue<Exclude<iface.Provider, null>>(p).Create(context.Background())"; !strings.Contains(testText, want) {
+		t.Fatalf("test package call was not awaited:\n%s", testText)
+	}
+}
+
 func TestCompilePackagesMarksSelectReturningIfElseCasesUnreachable(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/select-if-else\n\ngo 1.25.3\n",
@@ -2602,6 +3868,91 @@ func TestCompilePackagesMarksSelectReturningIfElseCasesUnreachable(t *testing.T)
 	}
 }
 
+func TestCompilePackagesAddsUnreachableReturnFallback(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/select-named\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"context\"",
+			"func wait(ctx context.Context, ch <-chan error) (rerr error) {",
+			"  select {",
+			"  case <-ctx.Done():",
+			"    return context.Canceled",
+			"  case err := <-ch:",
+			"    return err",
+			"  }",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "select-named", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function wait(ctx: context.Context | null, ch: $.Channel<$.GoError> | null): globalThis.Promise<$.GoError>",
+		"let rerr: $.GoError = null as $.GoError",
+		"throw new globalThis.Error(\"goscript: unreachable return\")",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAnnotatesShortDeclInterfaceValues(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/interface-short-decl\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Reader interface { Read() int }",
+			"type impl struct{ value int }",
+			"func (i *impl) Read() int { return i.value }",
+			"func replacement() Reader { return &impl{value: 2} }",
+			"func use(r Reader, swap bool) int {",
+			"  if r == nil {",
+			"    return 0",
+			"  }",
+			"  current := r",
+			"  if swap {",
+			"    current = replacement()",
+			"  }",
+			"  return current.Read()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "interface-short-decl", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "let current: Reader | null = r") {
+		t.Fatalf("missing interface short declaration annotation:\n%s", text)
+	}
+}
+
 func TestCompilePackagesPropagatesImmediateFuncLitAsync(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/immediate-func-lit-async\n\ngo 1.25.3\n",
@@ -2972,7 +4323,7 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"mask = mask & ~(3)",
+		"mask = mask & ~((3))",
 		"$.println(~value, value & ~(3), mask, 0o700)",
 	} {
 		if !strings.Contains(text, want) {
@@ -3098,6 +4449,41 @@ func TestCompilePackagesUnwrapsImportedVarRefValueMethodReceiver(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesUnwrapsOverridePointerMethodReceiver(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/override-pointer-receiver\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync/atomic\"",
+			"func Read(active *atomic.Int32) int32 {",
+			"  return active.Load()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "override-pointer-receiver", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "atomic.Int32.prototype.Load.call($.pointerValue<atomic.Int32>(active))") {
+		t.Fatalf("override pointer receiver was not unwrapped:\n%s", text)
+	}
+	if strings.Contains(text, "atomic.Int32.prototype.Load.call(active)") {
+		t.Fatalf("override pointer receiver stayed wrapped:\n%s", text)
+	}
+}
+
 func TestCompilePackagesUnwrapsImportedArrayPackageVarReads(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/imported-array-var\n\ngo 1.25.3\n",