goscript 0.1.3 → 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,9 +215,9 @@ func TestCompilePackagesLazilyInitializesCrossFilePackageVars(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export var two: holder = undefined as unknown as holder",
+		"export var two: holder",
 		"export function __goscript_get_two(): holder",
-		"export var 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.__goscript_get_one()",
 	} {
@@ -263,7 +263,7 @@ func TestCompilePackagesLazilyInitializesSameFileLaterPackageVars(t *testing.T)
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export var 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 var 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",
@@ -355,7 +355,7 @@ func TestCompilePackagesLazilyInitializesEffectFreeTypeForFromCrossFileInit(t *t
 	}
 	aText := string(aContent)
 	for _, want := range []string{
-		"export var stringType: reflect.Type | null = undefined as unknown as reflect.Type | null",
+		"export var stringType: reflect.Type | null",
 		"export function __goscript_get_stringType(): reflect.Type | null",
 		"stringType = reflect.TypeFor",
 	} {
@@ -550,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",
@@ -864,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",
@@ -950,6 +1189,51 @@ 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",
@@ -1233,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)
@@ -1963,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",
@@ -2293,6 +2622,63 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 	}
 }
 
+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)
+		}
+	}
+}
+
 func TestCompilePackagesAttachesFunctionLiteralTypeInfo(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/function-type-info\n\ngo 1.25.3\n",
@@ -2306,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)",
 			"}",
@@ -2332,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\" }]",
@@ -2494,13 +2884,95 @@ 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 }",
-			"",
+		"go.mod": "module example.test/numeric-interface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"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}, 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", "numeric-interface", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"$.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)
+		}
+	}
+}
+
+func TestCompilePackagesAwaitsFmtWriterOverrides(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"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"),
+	})
+	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",
@@ -2887,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",
@@ -3389,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) {