goscript 0.1.1 → 0.1.2

package/compiler/skeleton_test.go

@@ -235,6 +235,44 @@ func TestCompilePackagesLazilyInitializesCrossFilePackageVars(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLazilyInitializesSameFileLaterPackageVars(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/lazylatervars\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type detail struct { n int }",
+			"var table = []detail{{n: later.n}}",
+			"var later = detail{n: 7}",
+			"func main() { println(table[0].n) }",
+			"",
+		}, "\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", "lazylatervars", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export let table: $.Slice<detail> = undefined as unknown as $.Slice<detail>",
+		"export function __goscript_get_table(): $.Slice<detail>",
+		"export let later: detail = $.markAsStructValue(new detail({n: 7}))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/lazybodyvars\n\ngo 1.25.3\n",
@@ -278,17 +316,22 @@ func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *t
 	}
 }
 
-func TestCompilePackagesEmitsShadowedBuiltinCalls(t *testing.T) {
+func TestCompilePackagesInitializesLazyAsyncPackageVarsBeforeInit(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/shadowbuiltin\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/lazyasyncvars\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
-			"package shadowbuiltin",
-			"type Value struct {",
-			"  N int",
-			"}",
-			"func Build(new func() (*Value, error)) (*Value, error) {",
-			"  return new()",
+			"package main",
+			"import \"sync\"",
+			"var lock sync.Mutex",
+			"var first = makeFirst()",
+			"func makeFirst() int {",
+			"  lock.Lock()",
+			"  defer lock.Unlock()",
+			"  return later",
 			"}",
+			"var later = 7",
+			"func init() { println(first) }",
+			"func main() {}",
 			"",
 		}, "\n"),
 	})
@@ -301,25 +344,36 @@ func TestCompilePackagesEmitsShadowedBuiltinCalls(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "shadowbuiltin", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "lazyasyncvars", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "return await _new!()") {
-		t.Fatalf("shadowed builtin call was not emitted as a callable value:\n%s", text)
+	for _, want := range []string{
+		"async function __goscript_init_first(): globalThis.Promise<void>",
+		"first = await makeFirst()",
+		"export function __goscript_get_first(): number",
+		"await __goscript_init_first()",
+		"__goscriptInit0()",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
 	}
 }
 
-func TestCompilePackagesQuotesRawStringLiterals(t *testing.T) {
+func TestCompilePackagesAssignsLazyPackageVarsDirectly(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/rawstrings\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/lazyassign\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
-			"package rawstrings",
-			"func Values() (string, string) {",
-			"  return `\\u00`, `invalid escape char after \\`",
+			"package main",
+			"var table = []int{later}",
+			"var later = 1",
+			"func init() {",
+			"  table = append(table, 2)",
 			"}",
+			"func main() { println(len(table)) }",
 			"",
 		}, "\n"),
 	})
@@ -332,174 +386,163 @@ func TestCompilePackagesQuotesRawStringLiterals(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "rawstrings", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "lazyassign", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, `return ["\\u00", "invalid escape char after \\"]`) {
-		t.Fatalf("raw string literals were not quoted for TypeScript:\n%s", text)
+	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_get_table() =") {
+		t.Fatalf("lazy getter used as assignment target:\n%s", text)
 	}
 }
 
-func TestCompilePackagesUsesEmbedOverride(t *testing.T) {
+func TestCompilePackagesAssignsImportedPackageVarsThroughSetters(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod":       "module example.test/embedblank\n\ngo 1.25.3\n",
-		"version.txt":  "1.2.3\n",
-		"version..txt": "4.5.6\n",
-		"binary.bin":   string([]byte{0x00, 0xff, 0x80, 0x41}),
+		"go.mod": "module example.test/pkgvarassign\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"var Count int",
+			"",
+		}, "\n"),
 		"main.go": strings.Join([]string{
-			"package embedblank",
-			"import _ \"embed\"",
-			"//go:embed version.txt",
-			"var Version string",
-			"//go:embed version..txt",
-			"var Dotted string",
-			"//go:embed binary.bin",
-			"var Binary []byte",
-			"func GetVersion() string {",
-			"  return Version",
+			"package main",
+			"import \"example.test/pkgvarassign/dep\"",
+			"func bump() {",
+			"  dep.Count = 1",
+			"  dep.Count += 16",
+			"  dep.Count++",
 			"}",
 			"",
 		}, "\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())
 	}
 
-	result, err := comp.CompilePackages(context.Background(), ".")
-	if err != nil {
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	if !slices.Contains(result.CopiedPackages, "embed") {
-		t.Fatalf("embed override was not copied: %#v", result.CopiedPackages)
-	}
-	if _, err := os.Stat(filepath.Join(outputDir, "@goscript", "embed", "index.ts")); err != nil {
-		t.Fatalf("embed override missing from output: %v", err)
-	}
-	if _, err := os.Stat(filepath.Join(outputDir, "@goscript", "embed", "embed.gs.ts")); !os.IsNotExist(err) {
-		t.Fatalf("stdlib embed was emitted instead of override: %v", err)
-	}
-	content, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "embedblank", "main.gs.ts"))
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "pkgvarassign", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	if !strings.Contains(string(content), "export let Version: string = \"1.2.3\\n\"") {
-		t.Fatalf("embedded string content was not emitted:\n%s", string(content))
-	}
-	if !strings.Contains(string(content), "export let Dotted: string = \"4.5.6\\n\"") {
-		t.Fatalf("embedded dotted filename content was not emitted:\n%s", string(content))
+	text := string(content)
+	for _, want := range []string{
+		"dep.__goscript_set_Count(1)",
+		"dep.__goscript_set_Count(dep.Count + 16)",
+		"dep.__goscript_set_Count(dep.Count + 1)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing imported package var setter assignment %q:\n%s", want, text)
+		}
 	}
-	if !strings.Contains(string(content), "export let Binary: $.Slice<number> = new Uint8Array([0, 255, 128, 65])") {
-		t.Fatalf("embedded binary content was not emitted as byte values:\n%s", string(content))
+	if strings.Contains(text, "dep.Count +=") || strings.Contains(text, "dep.Count++") {
+		t.Fatalf("imported package var assigned directly:\n%s", text)
 	}
 }
 
-func TestCompilePackagesEmitsPackageLocalImport(t *testing.T) {
+func TestCompilePackagesAliasesForInitShortDeclShadow(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/imports\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/forinitshadow\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
-			"import \"example.test/imports/subpkg\"",
-			"func main() {",
-			"  var b subpkg.Builder",
-			"  b.Set(\"built\")",
-			"  println(b.Value)",
-			"  println(subpkg.Greet(\"world\"))",
-			"  println(localMessage())",
-			"}",
-			"",
-		}, "\n"),
-		"helper.go": strings.Join([]string{
-			"package main",
-			"func localMessage() string {",
-			"  return \"from helper\"",
-			"}",
-			"",
-		}, "\n"),
-		"subpkg/subpkg.go": strings.Join([]string{
-			"package subpkg",
-			"type Builder struct {",
-			"  Value string",
-			"}",
-			"func (b *Builder) Set(value string) {",
-			"  b.Value = value",
-			"}",
-			"func Greet(name string) string {",
-			"  return \"Hello, \" + name",
+			"func checksum(n int) int {",
+			"  total := 0",
+			"  for n := n - 4; total <= n; total++ {",
+			"    total += n",
+			"  }",
+			"  return total + n",
 			"}",
 			"",
 		}, "\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())
 	}
 
-	result, err := comp.CompilePackages(context.Background(), ".")
-	if err != nil {
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	if result == nil || len(result.CompiledPackages) != 2 {
-		t.Fatalf("unexpected result: %#v", result)
-	}
-	mainFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "main.gs.ts")
-	mainContent, err := os.ReadFile(mainFile)
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "forinitshadow", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	if !strings.Contains(string(mainContent), "import * as subpkg from \"@goscript/example.test/imports/subpkg/index.js\"") {
-		t.Fatalf("missing package-local import:\n%s", string(mainContent))
+	text := string(content)
+	if strings.Contains(text, "for (let n = n - 4") {
+		t.Fatalf("for init short declaration references itself:\n%s", text)
 	}
-	if !strings.Contains(string(mainContent), "let b: $.VarRef<subpkg.Builder> = $.varRef($.markAsStructValue(new subpkg.Builder()))") {
-		t.Fatalf("missing imported struct zero value qualification:\n%s", string(mainContent))
+	if !regexp.MustCompile(`let __goscriptShadow\d+ = n\s+for \(let __goscriptShadow\d+ = __goscriptShadow\d+ - 4; total <= __goscriptShadow\d+; total\+\+\)`).MatchString(text) {
+		t.Fatalf("missing aliased for init shadow declaration:\n%s", text)
 	}
-	if !strings.Contains(string(mainContent), "import * as __goscript_helper from \"./helper.gs.ts\"") ||
-		!strings.Contains(string(mainContent), "$.println(__goscript_helper.localMessage())") {
-		t.Fatalf("missing same-package helper import:\n%s", string(mainContent))
+	if !strings.Contains(text, "return total + n") {
+		t.Fatalf("outer n was not preserved after the loop:\n%s", text)
 	}
-	indexFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "subpkg", "index.ts")
-	indexContent, err := os.ReadFile(indexFile)
+}
+
+func TestCompilePackagesReadsShadowedVarRefStructFieldsOnce(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/shadowvarreffield\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type key struct { pad []byte }",
+			"func fill(k *key) error { return nil }",
+			"func size() int {",
+			"  var key key",
+			"  if err := fill(&key); err != nil {",
+			"    return 0",
+			"  }",
+			"  return len(key.pad)",
+			"}",
+			"func main() { println(size()) }",
+			"",
+		}, "\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 string(indexContent) != "export { Builder, Greet } from \"./subpkg.gs.ts\"\n" {
-		t.Fatalf("unexpected subpkg index:\n%s", string(indexContent))
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
 	}
-	mainIndexFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "index.ts")
-	mainIndexContent, err := os.ReadFile(mainIndexFile)
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "shadowvarreffield", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	if strings.Contains(string(mainIndexContent), "localMessage") {
-		t.Fatalf("unexported helper leaked into package index:\n%s", string(mainIndexContent))
+	text := string(content)
+	if !strings.Contains(text, "$.len(__goscriptShadow0.value.pad)") {
+		t.Fatalf("missing single dereference field read:\n%s", text)
+	}
+	if strings.Contains(text, ".value.value.pad") {
+		t.Fatalf("shadowed VarRef struct field was dereferenced twice:\n%s", text)
 	}
 }
 
-func TestCompilePackagesEmitsIndexAddressRefs(t *testing.T) {
+func TestCompilePackagesWrapsChannelSendInterfaceValues(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/indexaddr\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/chansendiface\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
-			"type Item struct { N int }",
-			"func set(ptr *int, value int) {",
-			"  *ptr = value",
-			"}",
-			"func Use(values []int, i int) int {",
-			"  set(&values[i], 9)",
-			"  return values[i]",
-			"}",
-			"func Items() []*Item {",
-			"  return []*Item{{N: 1}}",
+			"type item interface { Name() string }",
+			"type concrete struct{}",
+			"func (*concrete) Name() string { return \"ok\" }",
+			"func send(ch chan item) {",
+			"  v := &concrete{}",
+			"  ch <- v",
 			"}",
+			"func main() {}",
 			"",
 		}, "\n"),
 	})
@@ -509,53 +552,33 @@ func TestCompilePackagesEmitsIndexAddressRefs(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 
-	_, err = comp.CompilePackages(context.Background(), ".")
-	if err != nil {
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "indexaddr", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "chansendiface", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "set($.indexRef(values!, i), 9)") {
-		t.Fatalf("missing index address reference:\n%s", text)
-	}
-	if !strings.Contains(text, "new Item({N: 1})") {
-		t.Fatalf("missing elided pointer composite literal:\n%s", text)
+	if !strings.Contains(text, "$.chanSend(ch, $.interfaceValue<item | null>(v, \"*main.concrete\"))") {
+		t.Fatalf("missing interface wrapper for channel send:\n%s", text)
 	}
 }
 
-func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
+func TestCompilePackagesBindsFuncLiteralVarRefParams(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/structs\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/funclitvarref\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
-			"type Counter struct {",
-			"  // Value counts reads.",
-			"  Value int `json:\"value\"`",
-			"}",
-			"func (c Counter) Read() int {",
-			"  return c.Value",
-			"}",
-			"func (c *Counter) Set(v int) {",
-			"  c.Value = v",
-			"}",
-			"func NewCounter() *Counter {",
-			"  return &Counter{Value: 3}",
-			"}",
+			"type words []int",
+			"func (w *words) Add(v int) { *w = append(*w, v) }",
 			"func main() {",
-			"  original := Counter{Value: 1}",
-			"",
-			"  // Copy should stay readable in generated output.",
-			"  copy := original",
-			"  pointer := &original",
-			"  pointer.Set(2)",
-			"  NewCounter().Set(5)",
-			"  var iface any = pointer",
-			"  _, ok := iface.(*Counter)",
-			"  println(copy.Read(), original.Read(), ok)",
+			"  addLen := func(w words) int {",
+			"    w.Add(7)",
+			"    return len(w)",
+			"  }",
+			"  println(addLen(nil))",
 			"}",
 			"",
 		}, "\n"),
@@ -569,26 +592,16 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "structs", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "funclitvarref", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export class Counter",
-		"// Value counts reads.\n\tpublic get Value(): number",
-		"public clone(): Counter",
-		"public Read(): number",
-		"public Set(v: number): void",
-		"let original = $.varRef($.markAsStructValue(new Counter({Value: 1})))",
-		"let original = $.varRef($.markAsStructValue(new Counter({Value: 1})))\n\n\t// Copy should stay readable in generated output.\n\tlet copy",
-		"let copy = $.markAsStructValue($.cloneStructValue(original.value))",
-		"let pointer: Counter | $.VarRef<Counter> | null = original",
-		"$.pointerValue<Counter>(pointer).Set(2)",
-		"$.pointerValue<Counter>(NewCounter()).Set(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\\\"\" }",
+		"(__goscriptParam0: words): number => {",
+		"let w: $.VarRef<words> = $.varRef(__goscriptParam0)",
+		"words_Add(w, 7)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -596,18 +609,19 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	}
 }
 
-func TestCompilePackagesEmitsNestedPointerStorageAssertions(t *testing.T) {
+func TestCompilePackagesAnnotatesNewPointerShortDecls(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/pointers\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/newptrdecl\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
+			"type OID []int",
+			"func use(*OID) {}",
 			"func main() {",
-			"  var x int = 10",
-			"  p1 := &x",
-			"  p2 := &p1",
-			"  p3 := &p2",
-			"  ***p3 = 12",
-			"  println(x)",
+			"  oid := new(OID)",
+			"  if len(*oid) == 0 {",
+			"    oid = nil",
+			"  }",
+			"  use(oid)",
 			"}",
 			"",
 		}, "\n"),
@@ -621,18 +635,591 @@ func TestCompilePackagesEmitsNestedPointerStorageAssertions(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "pointers", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "newptrdecl", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"let x: $.VarRef<number> = $.varRef(10)",
-		"let p1 = $.varRef(x)",
-		"let p2 = $.varRef(p1)",
-		"let p3 = p2",
-		"$.pointerValue<$.VarRef<number> | null>($.pointerValue<$.VarRef<$.VarRef<number> | null> | null>(p3))!.value = 12",
+		"let oid: $.VarRef<OID> | null = $.varRef<OID>(null as OID)",
+		"oid = null",
+		"use(oid)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesEmitsShadowedBuiltinCalls(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/shadowbuiltin\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package shadowbuiltin",
+			"type Value struct {",
+			"  N int",
+			"}",
+			"func Build(new func() (*Value, error)) (*Value, error) {",
+			"  return new()",
+			"}",
+			"",
+		}, "\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", "shadowbuiltin", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "return await _new!()") {
+		t.Fatalf("shadowed builtin call was not emitted as a callable value:\n%s", text)
+	}
+}
+
+func TestCompilePackagesQuotesRawStringLiterals(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/rawstrings\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package rawstrings",
+			"func Values() (string, string) {",
+			"  return `\\u00`, `invalid escape char after \\`",
+			"}",
+			"",
+		}, "\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", "rawstrings", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, `return ["\\u00", "invalid escape char after \\"]`) {
+		t.Fatalf("raw string literals were not quoted for TypeScript:\n%s", text)
+	}
+}
+
+func TestCompilePackagesEmitsBinaryStringLiterals(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/binarystrings\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package binarystrings",
+			"const DecodeMap = \"\\xff\\x80A\"",
+			"func Value() string {",
+			"  return DecodeMap",
+			"}",
+			"",
+		}, "\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", "binarystrings", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), "$.bytesToString(new Uint8Array([255, 128, 65]))") {
+		t.Fatalf("binary string literal was not emitted as byte-backed string:\n%s", string(content))
+	}
+}
+
+func TestCompilePackagesUsesEmbedOverride(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":       "module example.test/embedblank\n\ngo 1.25.3\n",
+		"version.txt":  "1.2.3\n",
+		"version..txt": "4.5.6\n",
+		"binary.bin":   string([]byte{0x00, 0xff, 0x80, 0x41}),
+		"main.go": strings.Join([]string{
+			"package embedblank",
+			"import _ \"embed\"",
+			"//go:embed version.txt",
+			"var Version string",
+			"//go:embed version..txt",
+			"var Dotted string",
+			"//go:embed binary.bin",
+			"var Binary []byte",
+			"func GetVersion() string {",
+			"  return Version",
+			"}",
+			"",
+		}, "\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())
+	}
+
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !slices.Contains(result.CopiedPackages, "embed") {
+		t.Fatalf("embed override was not copied: %#v", result.CopiedPackages)
+	}
+	if _, err := os.Stat(filepath.Join(outputDir, "@goscript", "embed", "index.ts")); err != nil {
+		t.Fatalf("embed override missing from output: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(outputDir, "@goscript", "embed", "embed.gs.ts")); !os.IsNotExist(err) {
+		t.Fatalf("stdlib embed was emitted instead of override: %v", err)
+	}
+	content, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "embedblank", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), "export let Version: string = \"1.2.3\\n\"") {
+		t.Fatalf("embedded string content was not emitted:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), "export let Dotted: string = \"4.5.6\\n\"") {
+		t.Fatalf("embedded dotted filename content was not emitted:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), "export let Binary: $.Slice<number> = new Uint8Array([0, 255, 128, 65])") {
+		t.Fatalf("embedded binary content was not emitted as byte values:\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",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/imports/subpkg\"",
+			"func main() {",
+			"  var b subpkg.Builder",
+			"  b.Set(\"built\")",
+			"  println(b.Value)",
+			"  println(subpkg.Greet(\"world\"))",
+			"  println(localMessage())",
+			"}",
+			"",
+		}, "\n"),
+		"helper.go": strings.Join([]string{
+			"package main",
+			"func localMessage() string {",
+			"  return \"from helper\"",
+			"}",
+			"",
+		}, "\n"),
+		"subpkg/subpkg.go": strings.Join([]string{
+			"package subpkg",
+			"type Builder struct {",
+			"  Value string",
+			"}",
+			"func (b *Builder) Set(value string) {",
+			"  b.Value = value",
+			"}",
+			"func Greet(name string) string {",
+			"  return \"Hello, \" + name",
+			"}",
+			"",
+		}, "\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())
+	}
+
+	result, err := comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if result == nil || len(result.CompiledPackages) != 2 {
+		t.Fatalf("unexpected result: %#v", result)
+	}
+	mainFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "main.gs.ts")
+	mainContent, err := os.ReadFile(mainFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(mainContent), "import * as subpkg from \"@goscript/example.test/imports/subpkg/index.js\"") {
+		t.Fatalf("missing package-local import:\n%s", string(mainContent))
+	}
+	if !strings.Contains(string(mainContent), "let b: $.VarRef<subpkg.Builder> = $.varRef($.markAsStructValue(new subpkg.Builder()))") {
+		t.Fatalf("missing imported struct zero value qualification:\n%s", string(mainContent))
+	}
+	if !strings.Contains(string(mainContent), "import * as __goscript_helper from \"./helper.gs.ts\"") ||
+		!strings.Contains(string(mainContent), "$.println(__goscript_helper.localMessage())") {
+		t.Fatalf("missing same-package helper import:\n%s", string(mainContent))
+	}
+	indexFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "subpkg", "index.ts")
+	indexContent, err := os.ReadFile(indexFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if string(indexContent) != "export { Builder, Greet } from \"./subpkg.gs.ts\"\n" {
+		t.Fatalf("unexpected subpkg index:\n%s", string(indexContent))
+	}
+	mainIndexFile := filepath.Join(outputDir, "@goscript", "example.test", "imports", "index.ts")
+	mainIndexContent, err := os.ReadFile(mainIndexFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if strings.Contains(string(mainIndexContent), "localMessage") {
+		t.Fatalf("unexported helper leaked into package index:\n%s", string(mainIndexContent))
+	}
+}
+
+func TestCompilePackagesPreservesSourceImportAliasesForAssociatedMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/sourcealiases\n\ngo 1.25.3\n",
+		"dep/block/errors.go": strings.Join([]string{
+			"package block",
+			"import \"errors\"",
+			"var ErrUnexpectedType = errors.New(\"unexpected object type\")",
+			"",
+		}, "\n"),
+		"dep/kvtx/block/store.go": strings.Join([]string{
+			"package kvtx_block",
+			"type KeyValueStore struct{}",
+			"",
+		}, "\n"),
+		"world/world.go": strings.Join([]string{
+			"package world",
+			"import block \"example.test/sourcealiases/dep/kvtx/block\"",
+			"type World struct {",
+			"  Object *block.KeyValueStore",
+			"}",
+			"",
+		}, "\n"),
+		"world/block-world.go": strings.Join([]string{
+			"package world",
+			"import (",
+			"  block \"example.test/sourcealiases/dep/block\"",
+			"  block_kvtx \"example.test/sourcealiases/dep/kvtx/block\"",
+			")",
+			"func (w *World) Apply(next any) error {",
+			"  if _, ok := next.(*block_kvtx.KeyValueStore); !ok {",
+			"    return block.ErrUnexpectedType",
+			"  }",
+			"  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(), "./world"); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "sourcealiases", "world", "world.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	matches := regexp.MustCompile(`import \* as (\w+) from "@goscript/example\.test/sourcealiases/dep/block/index\.js"`).FindStringSubmatch(text)
+	if len(matches) != 2 {
+		t.Fatalf("missing dep/block import in generated output:\n%s", text)
+	}
+	if !strings.Contains(text, "return "+matches[1]+".ErrUnexpectedType") {
+		t.Fatalf("selector did not use the alias for its source package %q:\n%s", matches[1], text)
+	}
+}
+
+func TestCompilePackagesEmitsSideEffectImportsForInterfaceRegistry(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/interface-registry\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/interface-registry/dep\"",
+			"type localImpl struct{}",
+			"func (*localImpl) Ping() string { return \"pong\" }",
+			"func matchLocal(v any) bool {",
+			"  switch v.(type) {",
+			"  case Local:",
+			"    return true",
+			"  }",
+			"  return false",
+			"}",
+			"func matchDep(v any) bool {",
+			"  _, ok := v.(dep.Remote)",
+			"  return ok",
+			"}",
+			"func main() { println(matchLocal(&localImpl{}), matchDep(nil)) }",
+			"",
+		}, "\n"),
+		"local.go": strings.Join([]string{
+			"package main",
+			"type Local interface { Ping() string }",
+			"",
+		}, "\n"),
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type Remote interface { Remote() string }",
+			"",
+		}, "\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())
+	}
+	mainContent, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "interface-registry", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	mainText := string(mainContent)
+	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\"",
+		"case $.typeAssert<Exclude<__goscript_local.Local, null>>(__goscriptTypeSwitchValue, \"main.Local\").ok",
+		"$.typeAssertTuple<dep.Remote | null>(v, \"dep.Remote\")",
+	} {
+		if !strings.Contains(mainText, want) {
+			t.Fatalf("missing %q in main output:\n%s", want, mainText)
+		}
+	}
+
+	depIndexContent, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "interface-registry", "dep", "index.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(depIndexContent), "import \"./dep.gs.ts\"") {
+		t.Fatalf("missing interface side-effect import in dep index:\n%s", string(depIndexContent))
+	}
+}
+
+func TestCompilePackagesEmitsIndexAddressRefs(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/indexaddr\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Item struct { N int }",
+			"func set(ptr *int, value int) {",
+			"  *ptr = value",
+			"}",
+			"func Use(values []int, i int) int {",
+			"  set(&values[i], 9)",
+			"  return values[i]",
+			"}",
+			"func Items() []*Item {",
+			"  return []*Item{{N: 1}}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	_, err = comp.CompilePackages(context.Background(), ".")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "indexaddr", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "set($.indexRef(values!, i), 9)") {
+		t.Fatalf("missing index address reference:\n%s", text)
+	}
+	if !strings.Contains(text, "new Item({N: 1})") {
+		t.Fatalf("missing elided pointer composite literal:\n%s", text)
+	}
+}
+
+func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/structs\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Counter struct {",
+			"  // Value counts reads.",
+			"  Value int `json:\"value\"`",
+			"  ID ObjectID",
+			"}",
+			"type ObjectID int32",
+			"func (c Counter) Read() int {",
+			"  return c.Value",
+			"}",
+			"func (c *Counter) Set(v int) {",
+			"  c.Value = v",
+			"}",
+			"func NewCounter() *Counter {",
+			"  return &Counter{Value: 3}",
+			"}",
+			"func main() {",
+			"  original := Counter{Value: 1}",
+			"",
+			"  // Copy should stay readable in generated output.",
+			"  copy := original",
+			"  pointer := &original",
+			"  pointer.Set(2)",
+			"  NewCounter().Set(5)",
+			"  var iface any = pointer",
+			"  _, ok := iface.(*Counter)",
+			"  println(copy.Read(), original.Read(), ok)",
+			"}",
+			"",
+		}, "\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", "structs", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export class Counter",
+		"// Value counts reads.\n\tpublic get Value(): number",
+		"public clone(): Counter",
+		"public Read(): number",
+		"public Set(v: number): void",
+		"let original = $.varRef($.markAsStructValue(new Counter({Value: 1})))",
+		"let original = $.varRef($.markAsStructValue(new Counter({Value: 1})))\n\n\t// Copy should stay readable in generated output.\n\tlet copy",
+		"let copy = $.markAsStructValue($.cloneStructValue(original.value))",
+		"let pointer: Counter | $.VarRef<Counter> | null = original",
+		"Counter.prototype.Set.call(pointer, 2)",
+		"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\" }",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, 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{
+			"package main",
+			"type Box struct { Value int }",
+			"func (b *Box) clone() (*Box, error) {",
+			"  return &Box{Value: b.Value + 1}, nil",
+			"}",
+			"type Holder struct { Box Box }",
+			"func copyHolder(h Holder) Holder { return h }",
+			"func main() {",
+			"  _ = copyHolder(Holder{Box: Box{Value: 1}})",
+			"}",
+			"",
+		}, "\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", "nestedclone", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"public __goscriptClone(): Box",
+		"Box: $.varRef(init?.Box ? $.markAsStructValue($.cloneStructValue(init.Box)) : $.markAsStructValue(new Box()))",
+		"Box: $.varRef($.markAsStructValue($.cloneStructValue(this._fields.Box.value)))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "init.Box.clone()") || strings.Contains(text, "this._fields.Box.value.clone()") {
+		t.Fatalf("nested struct-field clone bypassed cloneStructValue:\n%s", text)
+	}
+}
+
+func TestCompilePackagesEmitsNestedPointerStorageAssertions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/pointers\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func main() {",
+			"  var x int = 10",
+			"  p1 := &x",
+			"  p2 := &p1",
+			"  p3 := &p2",
+			"  ***p3 = 12",
+			"  println(x)",
+			"}",
+			"",
+		}, "\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", "pointers", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"let x: $.VarRef<number> = $.varRef(10)",
+		"let p1 = $.varRef(x)",
+		"let p2 = $.varRef(p1)",
+		"let p3 = p2",
+		"$.pointerValue<$.VarRef<number> | null>($.pointerValue<$.VarRef<$.VarRef<number> | null> | null>(p3))!.value = 12",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -642,28 +1229,127 @@ func TestCompilePackagesEmitsNestedPointerStorageAssertions(t *testing.T) {
 
 func TestCompilePackagesEmitsArraySliceMapStringAndNamedMethods(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/collections\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/collections\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type MyInt int",
+			"func (m MyInt) Double() int { return int(m) * 2 }",
+			"type MySlice []int",
+			"func (s *MySlice) Add(v int) { *s = append(*s, v) }",
+			"func main() {",
+			"  arr := [3]int{1: 10}",
+			"  slice := make([]int, 0, 2)",
+			"  empty := []rune{}",
+			"  literal := []int{1, 2}",
+			"  literal = append(literal, 3)",
+			"  slice = append(slice, 5)",
+			"  slice[0] = arr[1]",
+			"  m := make(map[string]int)",
+			"  m[\"one\"] = 1",
+			"  value, ok := m[\"missing\"]",
+			"  text := \"hé\"",
+			"  var list MySlice",
+			"  list.Add(7)",
+			"  println(arr[1], slice[0], literal[2], len(slice), cap(slice), len(empty), value, ok, text[0], text[1], MyInt(5).Double(), len(list))",
+			"}",
+			"",
+		}, "\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", "collections", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export type MyInt = number",
+		"export function MyInt_Double(m: MyInt): number",
+		"export type MySlice = $.Slice<number>",
+		"export function MySlice_Add(s: $.VarRef<MySlice> | null, v: number): void",
+		"let arr = [0, 10, 0]",
+		"let slice: $.Slice<number> = $.makeSlice<number>(0, 2, \"number\")",
+		"let empty: $.Slice<number> = $.arrayToSlice<number>([])",
+		"let literal: $.Slice<number> = $.arrayToSlice<number>([1, 2])",
+		"literal = $.append(literal, 3)",
+		"slice![0] = arr[1]",
+		"let m: Map<string, number> | null = $.makeMap<string, number>()",
+		"$.mapSet(m, \"one\", 1)",
+		"let [value, ok] = $.mapGet(m, \"missing\", 0)",
+		"slice![0]",
+		"literal![2]",
+		"let list: $.VarRef<MySlice> = $.varRef(null as MySlice)",
+		"MySlice_Add(list, 7)",
+		"$.indexStringOrBytes(text, 0)",
+		"MyInt_Double(5)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesWrapsAddressedMapRangeValue(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/maprange\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Item struct { Values []string }",
+			"func (i *Item) add(v string) { i.Values = append(i.Values, v) }",
+			"func Apply(m map[int]Item, values []string) {",
+			"  for k, item := range m {",
+			"    for _, v := range values {",
+			"      item.add(v)",
+			"    }",
+			"    m[k] = item",
+			"  }",
+			"}",
+			"",
+		}, "\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", "maprange", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"let item: $.VarRef<Item> = $.varRef($.markAsStructValue($.cloneStructValue(__goscriptRangeValue",
+		"item.value.add(v)",
+		"$.mapSet(m, k, $.markAsStructValue($.cloneStructValue(item.value)))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesLowersPromotedNamedPrimitiveMethod(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/promotedprimitive\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
-			"type MyInt int",
-			"func (m MyInt) Double() int { return int(m) * 2 }",
-			"type MySlice []int",
-			"func (s *MySlice) Add(v int) { *s = append(*s, v) }",
-			"func main() {",
-			"  arr := [3]int{1: 10}",
-			"  slice := make([]int, 0, 2)",
-			"  empty := []rune{}",
-			"  literal := []int{1, 2}",
-			"  literal = append(literal, 3)",
-			"  slice = append(slice, 5)",
-			"  slice[0] = arr[1]",
-			"  m := make(map[string]int)",
-			"  m[\"one\"] = 1",
-			"  value, ok := m[\"missing\"]",
-			"  text := \"hé\"",
-			"  var list MySlice",
-			"  list.Add(7)",
-			"  println(arr[1], slice[0], literal[2], len(slice), cap(slice), len(empty), value, ok, text[0], text[1], MyInt(5).Double(), len(list))",
+			"import \"time\"",
+			"type Lifetime struct { time.Duration }",
+			"func Seconds(l Lifetime) float64 {",
+			"  return l.Seconds()",
 			"}",
 			"",
 		}, "\n"),
@@ -677,32 +1363,309 @@ func TestCompilePackagesEmitsArraySliceMapStringAndNamedMethods(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "collections", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "promotedprimitive", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "return time.Duration_Seconds(l.Duration)") {
+		t.Fatalf("promoted named primitive method was not lowered through the owner function:\n%s", text)
+	}
+	if strings.Contains(text, ".Seconds()") {
+		t.Fatalf("promoted named primitive method still used a JavaScript member call:\n%s", text)
+	}
+}
+
+func TestCompilePackagesMarksPackageFunctionVariablesAsync(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/packagefuncvar\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"func parse(raw string) (int, error) { return len(raw), nil }",
+			"var Parse = parse",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/packagefuncvar/dep\"",
+			"func parse() (int, error) {",
+			"  return dep.Parse(\"turn\")",
+			"}",
+			"",
+		}, "\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", "packagefuncvar", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function parse(): globalThis.Promise<[number, $.GoError]>") {
+		t.Fatalf("package function variable caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await dep.Parse!(\"turn\")") {
+		t.Fatalf("package function variable call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAwaitsImportedAsyncMethodsAndFunctions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/importedasync\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type Host struct{ ch chan struct{} }",
+			"func (h *Host) Snapshot() (int, error) { <-h.ch; return 1, nil }",
+			"func Read(h *Host) (int, error) { return h.Snapshot() }",
+			"",
+		}, "\n"),
+		"dep/dep_test.go": strings.Join([]string{
+			"package dep",
+			"import \"testing\"",
+			"func TestHost(t *testing.T) {}",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/importedasync/dep\"",
+			"func UseMethod(h *dep.Host) (int, error) {",
+			"  return h.Snapshot()",
+			"}",
+			"func UseFunction(h *dep.Host) (int, error) {",
+			"  return dep.Read(h)",
+			"}",
+			"",
+		}, "\n"),
+		"main_test.go": strings.Join([]string{
+			"package main",
+			"import \"testing\"",
+			"func TestUse(t *testing.T) {}",
+			"",
+		}, "\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,
+		Tests:               true,
+		AllDependencies:     true,
+	})
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "importedasync", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "export async function UseMethod") {
+		t.Fatalf("imported async method caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await dep.Host.prototype.Snapshot.call(h)") {
+		t.Fatalf("imported async method call was not awaited:\n%s", text)
+	}
+	if !strings.Contains(text, "export async function UseFunction") {
+		t.Fatalf("imported async function caller was not marked async:\n%s", text)
+	}
+	if !strings.Contains(text, "return await dep.Read(h)") {
+		t.Fatalf("imported async function call was not awaited:\n%s", text)
+	}
+}
+
+func TestCompilePackagesCastsConvertedTupleCallSpreads(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/tuplecallspread\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Resolver interface { Resolve() }",
+			"type relay struct{}",
+			"func (*relay) Resolve() {}",
+			"func NewRelay() (*relay, error) { return &relay{}, nil }",
+			"func R(res Resolver, err error) ([]Resolver, error) {",
+			"  if err != nil { return nil, err }",
+			"  return []Resolver{res}, nil",
+			"}",
+			"func Use() ([]Resolver, error) {",
+			"  return R(NewRelay())",
+			"}",
+			"",
+		}, "\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", "tuplecallspread", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "return R(...(() => {") ||
+		!strings.Contains(text, "] as [Resolver | null, $.GoError]") {
+		t.Fatalf("converted tuple call spread was not cast as a TypeScript tuple:\n%s", text)
+	}
+}
+
+func TestCompilePackagesPreservesBlankNamedResultSlots(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/blankresult\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func values() (first, second bool, _ error) {",
+			"  first = true",
+			"  return",
+			"}",
+			"",
+		}, "\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", "blankresult", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "return [first, second, null as $.GoError]") {
+		t.Fatalf("blank named result slot was not preserved in naked return:\n%s", text)
+	}
+}
+
+func TestCompilePackagesCastsGenericMethodResultAssignments(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/genericmethodresult\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"errors\"",
+			"  \"sync/atomic\"",
+			")",
+			"func load() error {",
+			"  var ptr atomic.Pointer[error]",
+			"  err := errors.New(\"boom\")",
+			"  ptr.Store(&err)",
+			"  if errp := ptr.Load(); errp != nil {",
+			"    return *errp",
+			"  }",
+			"  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", "genericmethodresult", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "(ptr.value.Load() as $.VarRef<$.GoError> | null)") {
+		t.Fatalf("generic method result assignment was not cast to the target type:\n%s", text)
+	}
+}
+
+func TestCompilePackagesPreservesFloatConversionLiterals(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/floatconv\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"math\"",
+			"func value() float64 {",
+			"  return math.Pow(float64(0.69314718056), 2)",
+			"}",
+			"",
+		}, "\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", "floatconv", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "$.int(0.69314718056)") {
+		t.Fatalf("float64 literal conversion was truncated through $.int:\n%s", text)
+	}
+	if !strings.Contains(text, "math.Pow(0.69314718056, 2)") {
+		t.Fatalf("missing direct float literal conversion:\n%s", text)
+	}
+}
+
+func TestCompilePackagesLowersStringOrderingThroughRuntime(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/stringorder\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func less(left, right []byte) bool {",
+			"  return string(left) < string(right)",
+			"}",
+			"func ordered(left, right string) bool {",
+			"  return left <= right",
+			"}",
+			"",
+		}, "\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", "stringorder", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type MyInt = number",
-		"export function MyInt_Double(m: MyInt): number",
-		"export type MySlice = $.Slice<number>",
-		"export function MySlice_Add(s: $.VarRef<MySlice> | null, v: number): void",
-		"let arr = [0, 10, 0]",
-		"let slice = $.makeSlice<number>(0, 2, \"number\")",
-		"let empty = $.arrayToSlice<number>([])",
-		"let literal = $.arrayToSlice<number>([1, 2])",
-		"literal = $.append(literal, 3)",
-		"slice![0] = arr[1]",
-		"let m: Map<string, number> | null = $.makeMap<string, number>()",
-		"$.mapSet(m, \"one\", 1)",
-		"let [value, ok] = $.mapGet(m, \"missing\", 0)",
-		"slice![0]",
-		"literal![2]",
-		"let list: $.VarRef<MySlice> = $.varRef(null as MySlice)",
-		"MySlice_Add(list, 7)",
-		"$.indexStringOrBytes(text, 0)",
-		"MyInt_Double(5)",
+		"$.stringCompare(left, right) < 0",
+		"$.stringCompare(left, right) <= 0",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -759,18 +1722,18 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 	text := string(content)
 	for _, want := range []string{
 		"export type Greeter = ((name: string) => string | globalThis.Promise<string>) | null",
-		"export type ReadCloser = null | {",
+		"export type ReadCloser = {",
 		"Read(): string",
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
 		"((__receiver) => () => __receiver.Inc())($.pointerValue<Counter>(counter))",
 		"$.namedFunction(greet, \"main.Greeter\")",
-		"$.typedNil(\"*struct{Name string}\")",
+		"$.interfaceValue<any>(null, \"*struct{Name string}\")",
 		"elemType: { kind: $.TypeKind.Struct, methods: [], fields: {\"Name\": { kind: $.TypeKind.Basic, name: \"string\" }} }",
 		"let fn = __goscriptTuple",
 		"switch (true)",
-		"case $.typeAssert<ReadCloser | null>(__goscriptTypeSwitchValue, \"main.ReadCloser\").ok",
-		"let v: ReadCloser | null = $.typeAssert<ReadCloser | null>(__goscriptTypeSwitchValue, \"main.ReadCloser\").value",
+		"case $.typeAssert<Exclude<ReadCloser, null>>(__goscriptTypeSwitchValue, \"main.ReadCloser\").ok",
+		"let v: Exclude<ReadCloser, null> = $.typeAssert<Exclude<ReadCloser, null>>(__goscriptTypeSwitchValue, \"main.ReadCloser\").value",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -805,15 +1768,67 @@ func TestCompilePackagesAssertsInterfaceMethodReceivers(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "interface-receivers", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "interface-receivers", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export type FileInfo = {",
+		"$.println($.pointerValue<Exclude<FileInfo, null>>(info).Name())",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesUsesNonNilInterfaceTypeSwitchCaseVarRefs(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/interface-switch-varref\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type rawConn interface { Control() error }",
+			"type tcpConn interface {",
+			"  SyscallConn() (rawConn, error)",
+			"  SetLinger(int) error",
+			"}",
+			"type Conn struct { c rawConn }",
+			"func keep(*tcpConn) {}",
+			"func NewConn(c any) (*Conn, error) {",
+			"  cc := &Conn{}",
+			"  var err error",
+			"  switch c := c.(type) {",
+			"  case tcpConn:",
+			"    keep(&c)",
+			"    cc.c, err = c.SyscallConn()",
+			"  }",
+			"  return cc, 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", "interface-switch-varref", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type FileInfo = null | {",
-		"$.println($.pointerValue<Exclude<FileInfo, null>>(info).Name())",
+		"export type tcpConn = {",
+		"case $.typeAssert<Exclude<tcpConn, null>>(__goscriptTypeSwitchValue, \"main.tcpConn\").ok",
+		"let c: $.VarRef<Exclude<tcpConn, null>> = $.varRef($.typeAssert<Exclude<tcpConn, null>>(__goscriptTypeSwitchValue, \"main.tcpConn\").value)",
+		"$.pointerValue<Exclude<tcpConn, null>>(c.value).SyscallConn()",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -893,6 +1908,9 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 			"  var zero T",
 			"  return zero",
 			"}",
+			"func Copy[T any](vals ...T) []T {",
+			"  return append([]T{}, vals...)",
+			"}",
 			"func main() {",
 			"  box := NewBox(7)",
 			"  println(box.Get())",
@@ -924,13 +1942,18 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 	for _, want := range []string{
 		"public Get(): any",
 		"export function NewBox(__typeArgs: $.GenericTypeArgs | undefined, value: any): Box",
+		"export function ZeroValue(__typeArgs: $.GenericTypeArgs | undefined): any",
+		"export function CallString(__typeArgs: $.GenericTypeArgs | undefined, v: any): string",
+		"export function Sum<T>(__typeArgs: $.GenericTypeArgs | undefined, vals: $.Slice<T>): any",
+		"export function Copy<T>(__typeArgs: $.GenericTypeArgs | undefined, vals: $.Slice<T>): $.Slice<T>",
+		"return $.append($.arrayToSlice<T>([]), ...(vals ?? []))",
 		"let seen: Set = $.makeMap<number, {}>()",
 		"$.mapSet(seen, 1, {})",
 		"$.genericZero(__typeArgs, \"T\", null)",
 		"$.callGenericMethod(__typeArgs, \"T\", \"String\", v)",
-		"ZeroValue({T: { type: \"main.MyInt\", zero: () => 0, methods: {String: MyInt_String} }})",
-		"CallString({T: { type: \"main.MyInt\", zero: () => 0, methods: {String: MyInt_String} }}, zero)",
-		"Sum({T: { type: \"main.MyInt\", zero: () => 0, methods: {String: MyInt_String} }}, null)",
+		"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)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -1015,8 +2038,8 @@ func TestCompilePackagesEmitsRecursiveFunctionTypeInfo(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type Handler = ((_p0: ((_p0: Handler) => Handler | globalThis.Promise<Handler>) | null) => Handler | globalThis.Promise<Handler>) | null",
-		"\"Next\": { kind: $.TypeKind.Function, name: \"main.Handler\"",
+		"export type Handler = ((_p0: ((_p0: Handler | null) => Handler | null | globalThis.Promise<Handler | null>) | null) => Handler | null | globalThis.Promise<Handler | null>) | null",
+		"\"Next\": ({ kind: $.TypeKind.Function, name: \"main.Handler\"",
 		"params: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
 		"results: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
 	} {
@@ -1082,7 +2105,7 @@ func TestCompilePackagesPacksVariadicCalls(t *testing.T) {
 		"export type Collector = ((label: string, parts: $.Slice<string>) => string | globalThis.Promise<string>) | null",
 		"Join(parts: $.Slice<string>): string",
 		"export function collect(label: string, parts: $.Slice<string>): string",
-		"let part = parts![__rangeIndex]",
+		"let part = __goscriptRangeTarget0![__rangeIndex]",
 		"export function maybeErr(parts: $.Slice<string>): $.GoError",
 		"public Join(parts: $.Slice<string>): string",
 		"collect(\"none\", null)",
@@ -1130,7 +2153,7 @@ func TestCompilePackagesPacksVariadicCallsInGeneratedSubpackage(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	want := "$.pointerValue<State>(s).SetErrorf(\"bad %q\", $.arrayToSlice<any>([key]))"
+	want := "State.prototype.SetErrorf.call(s, \"bad %q\", $.arrayToSlice<any>([key]))"
 	if !strings.Contains(text, want) {
 		t.Fatalf("missing %q in generated output:\n%s", want, text)
 	}
@@ -1139,6 +2162,112 @@ func TestCompilePackagesPacksVariadicCallsInGeneratedSubpackage(t *testing.T) {
 	}
 }
 
+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",
+			"}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/override-field-type/api/index.ts", strings.Join([]string{
+		"export class Request {",
+		"  public URL: any = null",
+		"}",
+		"",
+	}, "\n"))
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      outputDir,
+		AllDependencies: true,
+		OverrideDirs:    []string{overrideDir},
+	}, 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-field-type", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.pointerValue<any>($.pointerValue<api.Request>(r).URL).Path") {
+		t.Fatalf("missing erased override field type in generated output:\n%s", text)
+	}
+	if strings.Contains(text, "dep.URL") || strings.Contains(text, "pointerValue<URL>") {
+		t.Fatalf("generated output referenced unavailable dependency type:\n%s", text)
+	}
+}
+
 func TestCompilePackagesLowersRangeOverFunctionIterators(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/iterators\n\ngo 1.25.3\n",
@@ -1216,6 +2345,49 @@ func TestCompilePackagesLowersRangeOverFunctionIterators(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesPreservesNamedFunctionResultTypes(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/namedfuncresult\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Seq func(func(int) bool)",
+			"func values() Seq {",
+			"  return nil",
+			"}",
+			"func main() {",
+			"  if values() == nil {",
+			"    println(\"empty\")",
+			"  }",
+			"}",
+			"",
+		}, "\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", "namedfuncresult", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export type Seq = ((_p0: ((_p0: number) => boolean | globalThis.Promise<boolean>) | null) => void) | null",
+		"export function values(): Seq | null",
+		"return (null as Seq | null)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesLowersFunctionIteratorControlFlow(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/iterator-control\n\ngo 1.25.3\n",
@@ -1258,17 +2430,203 @@ func TestCompilePackagesLowersFunctionIteratorControlFlow(t *testing.T) {
 			"  }",
 			"  return -1",
 			"}",
-			"func nestedReturn(limit int) int {",
-			"  for v := range values {",
-			"    for i := range values {",
-			"      if i == limit {",
-			"        return v + i",
-			"      }",
-			"    }",
+			"func nestedReturn(limit int) int {",
+			"  for v := range values {",
+			"    for i := range values {",
+			"      if i == limit {",
+			"        return v + i",
+			"      }",
+			"    }",
+			"  }",
+			"  return -1",
+			"}",
+			"func main() { println(first(3), nestedReturn(2)) }",
+			"",
+		}, "\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", "iterator-control", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"let __goscriptRangeReturn",
+		"let __goscriptRangeReturnValue",
+		"return true",
+		"return false",
+		"__goscriptRangeReturnValue",
+		"if (__goscriptRangeReturn",
+		"return __goscriptRangeReturnValue",
+		"for (let i = 0; i < j; [i, j] = [i + 1, j - 1])",
+		"for (let i = 0; i < 2; i++)",
+		"switch (v)",
+		"const __goscriptTypeSwitchValue",
+		"switch (true)",
+		"case $.typeAssert<number>(__goscriptTypeSwitchValue, { kind: $.TypeKind.Basic, name: \"int\" }).ok",
+		"break",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	nestedReturn := regexp.MustCompile(`if \(__goscriptRangeReturn\d+\) \{\n\t+__goscriptRangeReturn\d+ = true\n\t+__goscriptRangeReturnValue\d+ = __goscriptRangeReturnValue\d+!\n\t+return false\n\t+\}`)
+	if !nestedReturn.MatchString(text) {
+		t.Fatalf("missing nested range return propagation:\n%s", text)
+	}
+}
+
+func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/async\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Processor interface { Process(v int) int }",
+			"type Worker struct { ch chan int }",
+			"func (w *Worker) Process(v int) int {",
+			"  w.ch <- v",
+			"  return <-w.ch",
+			"}",
+			"func call(p Processor) int { return p.Process(2) }",
+			"func stopLoop(stop chan struct{}, done chan struct{}) {",
+			"  for {",
+			"    select {",
+			"    case <-stop:",
+			"      done <- struct{}{}",
+			"      return",
+			"    }",
+			"  }",
+			"}",
+			"func main() {",
+			"  ch := make(chan int, 1)",
+			"  defer func() { <-ch }()",
+			"  go func() { ch <- 1 }()",
+			"  select {",
+			"  case v := <-ch:",
+			"    println(v)",
+			"  default:",
+			"    println(\"default\")",
+			"  }",
+			"  _ = call(&Worker{ch: make(chan int, 1)})",
+			"}",
+			"",
+		}, "\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", "async", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"Process(v: number): number | globalThis.Promise<number>",
+		"public async Process(v: number): globalThis.Promise<number>",
+		"let ch = $.makeChannel<number>(1, 0, \"both\")",
+		"await $.chanSend($.pointerValue<Worker>(w).ch, v)",
+		"return await $.chanRecv($.pointerValue<Worker>(w).ch)",
+		"await using __defer = new $.AsyncDisposableStack()",
+		"queueMicrotask(async () => { await ($.functionValue(async (): globalThis.Promise<void> => {",
+		"$.selectStatement<any, void>([",
+		"let v = __goscriptSelect1Result.value",
+		"return $.selectVoidReturn()",
+		"await call($.interfaceValue<Processor | null>(new Worker({ch: $.makeChannel<number>(1, 0, \"both\")}), \"*main.Worker\"))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+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",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"context\"",
+			"func finish(ctx context.Context, ch <-chan int, client bool) (int, error) {",
+			"  select {",
+			"  case <-ch:",
+			"    if client {",
+			"      return 1, nil",
+			"    } else {",
+			"      return 2, nil",
+			"    }",
+			"  case <-ctx.Done():",
+			"    return 3, ctx.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-if-else", "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 finish(ctx: context.Context | null, ch: $.Channel<number> | null, client: boolean): globalThis.Promise<[number, $.GoError]>",
+		"if (__goscriptSelect0HasReturn) {",
+		"throw new Error(\"unreachable select\")",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, 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",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync\"",
+			"type resolver struct {",
+			"  parent *resolver",
+			"  mutex sync.Mutex",
+			"}",
+			"func (r *resolver) lookup() (int, error) {",
+			"  value := func() int {",
+			"    r.mutex.Lock()",
+			"    defer r.mutex.Unlock()",
+			"    return 7",
+			"  }()",
+			"  if r.parent != nil {",
+			"    return r.parent.lookup()",
 			"  }",
-			"  return -1",
+			"  return value, nil",
 			"}",
-			"func main() { println(first(3), nestedReturn(2)) }",
+			"func use(r *resolver) (int, error) {",
+			"  return r.lookup()",
+			"}",
+			"func main() {}",
 			"",
 		}, "\n"),
 	})
@@ -1281,61 +2639,44 @@ func TestCompilePackagesLowersFunctionIteratorControlFlow(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "iterator-control", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "immediate-func-lit-async", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
 	for _, want := range []string{
-		"let __goscriptRangeReturn",
-		"let __goscriptRangeReturnValue",
-		"return true",
-		"return false",
-		"__goscriptRangeReturnValue",
-		"if (__goscriptRangeReturn",
-		"return __goscriptRangeReturnValue",
-		"for (let i = 0; i < j; [i, j] = [i + 1, j - 1])",
-		"for (let i = 0; i < 2; i++)",
-		"switch (v)",
-		"const __goscriptTypeSwitchValue",
-		"switch (true)",
-		"case $.typeAssert<number>(__goscriptTypeSwitchValue, { kind: $.TypeKind.Basic, name: \"int\" }).ok",
-		"break",
+		"public async lookup(): globalThis.Promise<[number, $.GoError]>",
+		"return await resolver.prototype.lookup.call($.pointerValue<resolver>(r).parent)",
+		"export async function use(r: resolver | $.VarRef<resolver> | null): globalThis.Promise<[number, $.GoError]>",
+		"return await resolver.prototype.lookup.call(r)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
 		}
 	}
-	nestedReturn := regexp.MustCompile(`if \(__goscriptRangeReturn\d+\) \{\n\t+__goscriptRangeReturn\d+ = true\n\t+__goscriptRangeReturnValue\d+ = __goscriptRangeReturnValue\d+!\n\t+return false\n\t+\}`)
-	if !nestedReturn.MatchString(text) {
-		t.Fatalf("missing nested range return propagation:\n%s", text)
+	if strings.Contains(text, "const __goscriptReturn0 = resolver.prototype.lookup.call") {
+		t.Fatalf("immediate func-literal async method call was not awaited:\n%s", text)
 	}
 }
 
-func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
+func TestCompilePackagesParenthesizesAsyncFieldReceivers(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/async\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/asyncfield\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
-			"type Processor interface { Process(v int) int }",
-			"type Worker struct { ch chan int }",
-			"func (w *Worker) Process(v int) int {",
-			"  w.ch <- v",
-			"  return <-w.ch",
+			"type Result struct { ok bool }",
+			"type Box struct { ch chan int }",
+			"func (b *Box) next() Result {",
+			"  b.ch <- 1",
+			"  return Result{ok: true}",
+			"}",
+			"func (b *Box) OK() bool {",
+			"  return b.next().ok",
 			"}",
-			"func call(p Processor) int { return p.Process(2) }",
 			"func main() {",
-			"  ch := make(chan int, 1)",
-			"  defer func() { <-ch }()",
-			"  go func() { ch <- 1 }()",
-			"  select {",
-			"  case v := <-ch:",
-			"    println(v)",
-			"  default:",
-			"    println(\"default\")",
-			"  }",
-			"  _ = call(&Worker{ch: make(chan int, 1)})",
+			"  box := &Box{ch: make(chan int, 1)}",
+			"  println(box.OK())",
 			"}",
 			"",
 		}, "\n"),
@@ -1349,27 +2690,17 @@ func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
 	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
 		t.Fatal(err.Error())
 	}
-	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "async", "main.gs.ts")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "asyncfield", "main.gs.ts")
 	content, err := os.ReadFile(outputFile)
 	if err != nil {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	for _, want := range []string{
-		"Process(v: number): globalThis.Promise<number>",
-		"public async Process(v: number): globalThis.Promise<number>",
-		"let ch = $.makeChannel<number>(1, 0, \"both\")",
-		"await $.chanSend($.pointerValue<Worker>(w).ch, v)",
-		"return await $.chanRecv($.pointerValue<Worker>(w).ch)",
-		"await using __defer = new $.AsyncDisposableStack()",
-		"queueMicrotask(async () => { await ($.functionValue(async (): globalThis.Promise<void> => {",
-		"$.selectStatement<any, void>([",
-		"let v = result.value",
-		"await call($.interfaceValue<Processor | null>(new Worker({ch: $.makeChannel<number>(1, 0, \"both\")}), \"*main.Worker\"))",
-	} {
-		if !strings.Contains(text, want) {
-			t.Fatalf("missing %q in generated output:\n%s", want, text)
-		}
+	if !strings.Contains(text, "return (await Box.prototype.next.call(b)).ok") {
+		t.Fatalf("async field receiver was not parenthesized:\n%s", text)
+	}
+	if strings.Contains(text, "return await Box.prototype.next.call(b).ok") {
+		t.Fatalf("async field receiver selected the promise before await:\n%s", text)
 	}
 }
 
@@ -1650,6 +2981,298 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesParenthesizesRepeatedUnarySigns(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/unary-signs\n\ngo 1.25.3\n",
+		"constants.go": strings.Join([]string{
+			"package main",
+			"const extOffset = -0x1000",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Extension int32",
+			"type LoadExtension struct { Num Extension }",
+			"func Decode(k int32) LoadExtension {",
+			"  return LoadExtension{Num: Extension(-extOffset + k)}",
+			"}",
+			"",
+		}, "\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", "unary-signs", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "--4096") {
+		t.Fatalf("generated invalid decrement token:\n%s", text)
+	}
+	if !strings.Contains(text, "-(-4096) + k") {
+		t.Fatalf("missing parenthesized negative constant:\n%s", text)
+	}
+}
+
+func TestCompilePackagesNormalizesWideIntegerReturnTargets(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/wide-return\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"hash\"",
+			"func Read(h hash.Hash64) uint64 {",
+			"  return h.Sum64()",
+			"}",
+			"",
+		}, "\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", "wide-return", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "return $.uint($.pointerValue<Exclude<hash.Hash64, null>>(h).Sum64(), 64)") {
+		t.Fatalf("missing uint64 return normalization:\n%s", text)
+	}
+}
+
+func TestCompilePackagesUnwrapsImportedVarRefValueMethodReceiver(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/imported-varref-receiver\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type Info struct { Count int }",
+			"func (i Info) Enabled() bool { return i.Count > 0 }",
+			"func addInfo(i *Info) { i.Count = 1 }",
+			"var CPU Info",
+			"func init() { addInfo(&CPU) }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/imported-varref-receiver/dep\"",
+			"func Enabled() bool {",
+			"  return dep.CPU.Enabled()",
+			"}",
+			"",
+		}, "\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", "imported-varref-receiver", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.cloneStructValue($.pointerValue<dep.Info>(dep.CPU))") {
+		t.Fatalf("missing imported VarRef receiver unwrap:\n%s", text)
+	}
+	if strings.Contains(text, "$.cloneStructValue(dep.CPU))") {
+		t.Fatalf("imported VarRef 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",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"var Table = [2]int{3, 5}",
+			"func touch(v *[2]int) { v[0]++ }",
+			"func init() { touch(&Table) }",
+			"func Sum(v [2]int) int { return v[0] + v[1] }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/imported-array-var/dep\"",
+			"func Read() int {",
+			"  return dep.Table[1] + dep.Sum(dep.Table)",
+			"}",
+			"",
+		}, "\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", "imported-array-var", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"$.pointerValue<number[]>(dep.Table)[1]",
+		"dep.Sum($.pointerValue<number[]>(dep.Table))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing imported array package var read %q:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAddressesImportedArrayPackageVarsAsRefs(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/imported-array-var-address\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"var Table = [2]int{3, 5}",
+			"func touch(v *[2]int) { v[0]++ }",
+			"func init() { touch(&Table) }",
+			"func SumPtr(v *[2]int) int { return v[0] + v[1] }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/imported-array-var-address/dep\"",
+			"func Read() int {",
+			"  return dep.SumPtr(&dep.Table)",
+			"}",
+			"",
+		}, "\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", "imported-array-var-address", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "dep.SumPtr(dep.Table)") {
+		t.Fatalf("missing imported array package var address:\n%s", text)
+	}
+	if strings.Contains(text, "dep.SumPtr($.pointerValue<number[]>(dep.Table))") ||
+		strings.Contains(text, "dep._fields.Table") {
+		t.Fatalf("imported array package var address was lowered as a read or field:\n%s", text)
+	}
+}
+
+func TestCompilePackagesUnwrapsAliasedArrayPackageVarReads(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/aliased-array-var\n\ngo 1.25.3\n",
+		"table.go": strings.Join([]string{
+			"package main",
+			"var Table = [2]int{3, 5}",
+			"func touch(v *[2]int) { v[0]++ }",
+			"func init() { touch(&Table) }",
+			"func Sum(v [2]int) int { return v[0] + v[1] }",
+			"",
+		}, "\n"),
+		"read.go": strings.Join([]string{
+			"package main",
+			"func Read() int {",
+			"  return Table[1] + Sum(Table)",
+			"}",
+			"",
+		}, "\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", "aliased-array-var", "read.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"$.pointerValue<number[]>(__goscript_table.Table)[1]",
+		"Sum($.pointerValue<number[]>(__goscript_table.Table))",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing aliased array package var read %q:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAddressesAliasedArrayPackageVarsAsRefs(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/aliased-array-var-address\n\ngo 1.25.3\n",
+		"table.go": strings.Join([]string{
+			"package main",
+			"var Table = [2]int{3, 5}",
+			"func touch(v *[2]int) { v[0]++ }",
+			"func init() { touch(&Table) }",
+			"func SumPtr(v *[2]int) int { return v[0] + v[1] }",
+			"",
+		}, "\n"),
+		"read.go": strings.Join([]string{
+			"package main",
+			"func Read() int {",
+			"  return SumPtr(&Table)",
+			"}",
+			"",
+		}, "\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", "aliased-array-var-address", "read.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "SumPtr(__goscript_table.Table)") {
+		t.Fatalf("missing aliased array package var address:\n%s", text)
+	}
+	if strings.Contains(text, "SumPtr($.pointerValue<number[]>(__goscript_table.Table))") {
+		t.Fatalf("aliased array package var address was lowered as a read:\n%s", text)
+	}
+}
+
 func TestCompileSourceToTypeScriptCompilesSingleFile(t *testing.T) {
 	output, err := CompileSourceToTypeScript("package main\nfunc main() { println(\"hi\") }\n", "main")
 	if err != nil {