goscript 0.1.2 → 0.1.3

package/compiler/override-registry_test.go

@@ -341,6 +341,49 @@ func TestCompilePackagesPropagatesOverrideAsyncInterfaceMethods(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesAwaitsOverrideAsyncInterfaceMethodCalls(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasyncinterfacemethod\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync\"",
+			"func Use(l sync.Locker) {",
+			"  l.Lock()",
+			"  l.Unlock()",
+			"}",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "overrideasyncinterfacemethod", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function Use(l: sync.Locker | null): globalThis.Promise<void>",
+		"await $.pointerValue<Exclude<sync.Locker, null>>(l).Lock()",
+		"$.pointerValue<Exclude<sync.Locker, null>>(l).Unlock()",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",

package/compiler/skeleton_test.go

@@ -215,11 +215,11 @@ func TestCompilePackagesLazilyInitializesCrossFilePackageVars(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let two: holder = undefined as unknown as holder",
+		"export var two: holder = undefined as unknown as holder",
 		"export function __goscript_get_two(): holder",
-		"export let remoteZero: __goscript_a.remote = undefined as unknown as __goscript_a.remote",
+		"export var remoteZero: __goscript_a.remote = undefined as unknown as __goscript_a.remote",
 		"export function __goscript_get_remoteZero(): __goscript_a.remote",
-		"__goscript_a.one",
+		"__goscript_a.__goscript_get_one()",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -263,7 +263,7 @@ func TestCompilePackagesLazilyInitializesSameFileLaterPackageVars(t *testing.T)
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let table: $.Slice<detail> = undefined as unknown as $.Slice<detail>",
+		"export var table: $.Slice<detail> = undefined as unknown as $.Slice<detail>",
 		"export function __goscript_get_table(): $.Slice<detail>",
 		"export let later: detail = $.markAsStructValue(new detail({n: 7}))",
 	} {
@@ -305,7 +305,7 @@ func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *t
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export let first: Point | $.VarRef<Point> | null = undefined as unknown as Point | $.VarRef<Point> | null",
+		"export var first: Point | $.VarRef<Point> | null = undefined as unknown as Point | $.VarRef<Point> | null",
 		"export function __goscript_get_first(): Point | $.VarRef<Point> | null",
 		"function __goscript_get___goscriptTuple",
 		"export let later: number = 7",
@@ -316,6 +316,67 @@ func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *t
 	}
 }
 
+func TestCompilePackagesLazilyInitializesEffectFreeTypeForFromCrossFileInit(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/lazytypefor\n\ngo 1.25.3\n",
+		"a.go": strings.Join([]string{
+			"package main",
+			"import \"reflect\"",
+			"var stringType = reflect.TypeFor[string]()",
+			"var _ = marker",
+			"",
+		}, "\n"),
+		"b.go": strings.Join([]string{
+			"package main",
+			"func readStringType() { println(stringType != nil) }",
+			"func main() {}",
+			"",
+		}, "\n"),
+		"c.go": strings.Join([]string{
+			"package main",
+			"var marker = 1",
+			"func init() { readStringType() }",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	aFile := filepath.Join(outputDir, "@goscript", "example.test", "lazytypefor", "a.gs.ts")
+	aContent, err := os.ReadFile(aFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	aText := string(aContent)
+	for _, want := range []string{
+		"export var stringType: reflect.Type | null = undefined as unknown as reflect.Type | null",
+		"export function __goscript_get_stringType(): reflect.Type | null",
+		"stringType = reflect.TypeFor",
+	} {
+		if !strings.Contains(aText, want) {
+			t.Fatalf("missing %q in generated a.go output:\n%s", want, aText)
+		}
+	}
+	bFile := filepath.Join(outputDir, "@goscript", "example.test", "lazytypefor", "b.gs.ts")
+	bContent, err := os.ReadFile(bFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	bText := string(bContent)
+	if !strings.Contains(bText, "__goscript_a.__goscript_get_stringType() != null") {
+		t.Fatalf("missing lazy TypeFor package var getter use:\n%s", bText)
+	}
+	if strings.Contains(bText, "__goscript_a.stringType != null") {
+		t.Fatalf("cross-file init still reads TypeFor package var directly:\n%s", bText)
+	}
+}
+
 func TestCompilePackagesInitializesLazyAsyncPackageVarsBeforeInit(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/lazyasyncvars\n\ngo 1.25.3\n",
@@ -392,8 +453,8 @@ func TestCompilePackagesAssignsLazyPackageVarsDirectly(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "table = $.append(__goscript_get_table(), 2)") {
-		t.Fatalf("missing direct lazy package var assignment:\n%s", text)
+	if !strings.Contains(text, "__goscript_set_table($.append(__goscript_get_table(), 2))") {
+		t.Fatalf("missing lazy package var assignment through setter:\n%s", text)
 	}
 	if strings.Contains(text, "__goscript_get_table() =") {
 		t.Fatalf("lazy getter used as assignment target:\n%s", text)
@@ -889,6 +950,49 @@ func TestCompilePackagesEmitsPackageLocalImport(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesEmitsTypeOnlyLocalImports(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/typeonlylocal\n\ngo 1.25.3\n",
+		"a.go": strings.Join([]string{
+			"package main",
+			"type Acceptor interface {",
+			"  Accept(Payload)",
+			"}",
+			"",
+		}, "\n"),
+		"payload.go": strings.Join([]string{
+			"package main",
+			"type Payload struct {",
+			"  Value string",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{
+		Dir:        moduleDir,
+		OutputPath: outputDir,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "typeonlylocal", "a.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "import type * as __goscript_payload from \"./payload.gs.ts\"") {
+		t.Fatalf("missing type-only same-package import:\n%s", text)
+	}
+	if strings.Contains(text, "import \"./payload.gs.ts\"") {
+		t.Fatalf("type-only same-package import should not force sibling module execution:\n%s", text)
+	}
+}
+
 func TestCompilePackagesPreservesSourceImportAliasesForAssociatedMethods(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/sourcealiases\n\ngo 1.25.3\n",
@@ -1004,8 +1108,7 @@ func TestCompilePackagesEmitsSideEffectImportsForInterfaceRegistry(t *testing.T)
 	for _, want := range []string{
 		"import * as dep from \"@goscript/example.test/interface-registry/dep/index.js\"",
 		"import \"@goscript/example.test/interface-registry/dep/index.js\"",
-		"import * as __goscript_local from \"./local.gs.ts\"",
-		"import \"./local.gs.ts\"",
+		"import type * as __goscript_local from \"./local.gs.ts\"",
 		"case $.typeAssert<Exclude<__goscript_local.Local, null>>(__goscriptTypeSwitchValue, \"main.Local\").ok",
 		"$.typeAssertTuple<dep.Remote | null>(v, \"dep.Remote\")",
 	} {
@@ -1138,6 +1241,152 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesEscapesReservedTypeNames(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/reservedtypes\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type static struct {",
+			"  Value int",
+			"}",
+			"func newStatic() *static {",
+			"  return &static{Value: 7}",
+			"}",
+			"func (s *static) Read() int {",
+			"  return s.Value",
+			"}",
+			"func main() {",
+			"  println(newStatic().Read())",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "reservedtypes", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export class _static",
+		"new _static({Value: 7})",
+		"public Read(): number",
+		"_static.prototype.Read.call(newStatic())",
+		"\"main.static\"",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "class static") {
+		t.Fatalf("reserved type name was not escaped:\n%s", text)
+	}
+}
+
+func TestCompilePackagesAvoidsPointerMethodTypeNameShadow(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/methodshadow\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type item struct {",
+			"  Value int",
+			"}",
+			"func (i *item) read() int {",
+			"  return i.Value",
+			"}",
+			"func total(items []*item) int {",
+			"  sum := 0",
+			"  for _, item := range items {",
+			"    sum += item.read()",
+			"  }",
+			"  return sum",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "methodshadow", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.pointerValue<item>(item).read()") {
+		t.Fatalf("missing direct pointer method call for shadowed type name:\n%s", text)
+	}
+	if strings.Contains(text, "item.prototype.read.call(item") {
+		t.Fatalf("shadowed local variable used as method class:\n%s", text)
+	}
+}
+
+func TestCompilePackagesErasesUnimportedTransitiveInterfaceField(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/transitivefield\n\ngo 1.25.3\n",
+		"hash/hash.go": strings.Join([]string{
+			"package hash",
+			"type Hash interface {",
+			"  Write([]byte) (int, error)",
+			"}",
+			"",
+		}, "\n"),
+		"holder/holder.go": strings.Join([]string{
+			"package holder",
+			"import \"example.test/transitivefield/hash\"",
+			"type Hasher struct {",
+			"  hash.Hash",
+			"}",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/transitivefield/holder\"",
+			"func write(h holder.Hasher, p []byte) error {",
+			"  _, err := h.Hash.Write(p)",
+			"  return err",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "transitivefield", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.pointerValue<any>(h.Hash).Write(p)") {
+		t.Fatalf("missing erased transitive interface field type:\n%s", text)
+	}
+	if strings.Contains(text, "Exclude<Hash") {
+		t.Fatalf("unimported transitive interface type leaked into output:\n%s", text)
+	}
+}
+
 func TestCompilePackagesClonesNestedStructFieldsWithCloneMethodCollision(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/nestedclone\n\ngo 1.25.3\n",
@@ -1341,6 +1590,47 @@ func TestCompilePackagesWrapsAddressedMapRangeValue(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersTupleAssignmentToMapIndexSet(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/maptupleassign\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func resolve(k string) (int, error) { return 7, nil }",
+			"func Apply(keys []string) (map[string]int, error) {",
+			"  out := make(map[string]int)",
+			"  var err error",
+			"  for _, k := range keys {",
+			"    out[k], err = resolve(k)",
+			"    if err != nil { return nil, err }",
+			"  }",
+			"  return out, nil",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "maptupleassign", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.mapSet(out, k, __goscriptTuple") {
+		t.Fatalf("tuple assignment to map index did not write through mapSet:\n%s", text)
+	}
+	if strings.Contains(text, "$.mapGet(out, k, 0)[0] =") {
+		t.Fatalf("tuple assignment still mutates mapGet tuple instead of map:\n%s", text)
+	}
+}
+
 func TestCompilePackagesLowersPromotedNamedPrimitiveMethod(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/promotedprimitive\n\ngo 1.25.3\n",
@@ -1887,6 +2177,48 @@ func TestCompilePackagesBoxesTypedNilInterfaceValues(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesBoxesAliasPointerInterfacesWithTargetRuntimeType(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/alias-interface-box\n\ngo 1.25.3\n",
+		"dep/dep.go": strings.Join([]string{
+			"package dep",
+			"type CloudError struct{}",
+			"func (*CloudError) Error() string { return \"cloud\" }",
+			"",
+		}, "\n"),
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"example.test/alias-interface-box/dep\"",
+			"type cloudError = dep.CloudError",
+			"func Build() error {",
+			"  return &cloudError{}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "alias-interface-box", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.interfaceValue<$.GoError>(new dep.CloudError(), \"*dep.CloudError\")") {
+		t.Fatalf("alias pointer was not boxed with target runtime type:\n%s", text)
+	}
+	if strings.Contains(text, "*main.cloudError") {
+		t.Fatalf("alias pointer leaked alias runtime type:\n%s", text)
+	}
+}
+
 func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/generics\n\ngo 1.25.3\n",
@@ -1951,9 +2283,9 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 		"$.mapSet(seen, 1, {})",
 		"$.genericZero(__typeArgs, \"T\", null)",
 		"$.callGenericMethod(__typeArgs, \"T\", \"String\", v)",
-		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }})",
-		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }}, zero)",
-		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)($.pointerValue(receiver), ...args)} }}, null)",
+		"ZeroValue({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }})",
+		"CallString({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, zero)",
+		"Sum({T: { type: { kind: $.TypeKind.Basic, name: \"int\", typeName: \"main.MyInt\" }, zero: () => 0, methods: {String: (receiver: any, ...args: any[]) => (MyInt_String as any)(($.isVarRef(receiver) ? receiver.value : receiver), ...args)} }}, null)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -2602,6 +2934,91 @@ func TestCompilePackagesMarksSelectReturningIfElseCasesUnreachable(t *testing.T)
 	}
 }
 
+func TestCompilePackagesAddsUnreachableReturnFallback(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/select-named\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"context\"",
+			"func wait(ctx context.Context, ch <-chan error) (rerr error) {",
+			"  select {",
+			"  case <-ctx.Done():",
+			"    return context.Canceled",
+			"  case err := <-ch:",
+			"    return err",
+			"  }",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "select-named", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export async function wait(ctx: context.Context | null, ch: $.Channel<$.GoError> | null): globalThis.Promise<$.GoError>",
+		"let rerr: $.GoError = null as $.GoError",
+		"throw new globalThis.Error(\"goscript: unreachable return\")",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAnnotatesShortDeclInterfaceValues(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/interface-short-decl\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Reader interface { Read() int }",
+			"type impl struct{ value int }",
+			"func (i *impl) Read() int { return i.value }",
+			"func replacement() Reader { return &impl{value: 2} }",
+			"func use(r Reader, swap bool) int {",
+			"  if r == nil {",
+			"    return 0",
+			"  }",
+			"  current := r",
+			"  if swap {",
+			"    current = replacement()",
+			"  }",
+			"  return current.Read()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "interface-short-decl", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "let current: Reader | null = r") {
+		t.Fatalf("missing interface short declaration annotation:\n%s", text)
+	}
+}
+
 func TestCompilePackagesPropagatesImmediateFuncLitAsync(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/immediate-func-lit-async\n\ngo 1.25.3\n",
@@ -3098,6 +3515,41 @@ func TestCompilePackagesUnwrapsImportedVarRefValueMethodReceiver(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesUnwrapsOverridePointerMethodReceiver(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/override-pointer-receiver\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"sync/atomic\"",
+			"func Read(active *atomic.Int32) int32 {",
+			"  return active.Load()",
+			"}",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "override-pointer-receiver", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "atomic.Int32.prototype.Load.call($.pointerValue<atomic.Int32>(active))") {
+		t.Fatalf("override pointer receiver was not unwrapped:\n%s", text)
+	}
+	if strings.Contains(text, "atomic.Int32.prototype.Load.call(active)") {
+		t.Fatalf("override pointer receiver stayed wrapped:\n%s", text)
+	}
+}
+
 func TestCompilePackagesUnwrapsImportedArrayPackageVarReads(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/imported-array-var\n\ngo 1.25.3\n",

package/compiler/typescript-emitter.go

@@ -126,7 +126,11 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 		if idx != 0 {
 			b.WriteString("\n")
 		}
-		b.WriteString("import * as ")
+		b.WriteString("import ")
+		if imp.typeOnly {
+			b.WriteString("type ")
+		}
+		b.WriteString("* as ")
 		b.WriteString(imp.alias)
 		b.WriteString(" from \"")
 		b.WriteString(imp.source)
@@ -134,7 +138,7 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 	}
 	sideEffectImports := make(map[string]bool)
 	for _, imp := range file.imports {
-		if !imp.sideEffect || sideEffectImports[imp.source] {
+		if imp.typeOnly || !imp.sideEffect || sideEffectImports[imp.source] {
 			continue
 		}
 		sideEffectImports[imp.source] = true
@@ -484,6 +488,7 @@ func renderFunction(b *strings.Builder, fn *loweredFunction) {
 	renderNamedResults(b, fn.namedResults, 1)
 	renderDeferStack(b, fn.deferState, 1)
 	renderStmts(b, fn.body, 1)
+	renderUnreachableReturn(b, fn, 1)
 	b.WriteString("}\n")
 }
 
@@ -527,10 +532,31 @@ func renderMethod(b *strings.Builder, fn *loweredFunction) {
 	renderNamedResults(b, fn.namedResults, 2)
 	renderDeferStack(b, fn.deferState, 2)
 	renderStmts(b, fn.body, 2)
+	renderUnreachableReturn(b, fn, 2)
 	writeIndent(b, 1)
 	b.WriteString("}\n")
 }
 
+func renderUnreachableReturn(b *strings.Builder, fn *loweredFunction, indent int) {
+	if fn.result == "void" || fn.result == "globalThis.Promise<void>" {
+		return
+	}
+	if loweredStmtsEndWithTerminal(fn.body) {
+		return
+	}
+	writeIndent(b, indent)
+	b.WriteString("throw new globalThis.Error(\"goscript: unreachable return\")\n")
+}
+
+func loweredStmtsEndWithTerminal(stmts []loweredStmt) bool {
+	if len(stmts) == 0 {
+		return false
+	}
+	last := stmts[len(stmts)-1]
+	text := strings.TrimSpace(last.text)
+	return strings.HasPrefix(text, "return") || strings.HasPrefix(text, "throw ")
+}
+
 func renderFunctionTypeParams(b *strings.Builder, fn *loweredFunction) {
 	if len(fn.typeParams) == 0 {
 		return