goscript 0.1.0 → 0.1.1

package/compiler/skeleton_test.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"os"
 	"path/filepath"
+	"regexp"
+	"slices"
 	"strings"
 	"testing"
 )
@@ -127,8 +129,8 @@ func TestCompilePackagesEmitsSimplePackage(t *testing.T) {
 		"import * as $ from \"@goscript/builtin/index.js\"",
 		"export const Greeting: string = \"Hello\"",
 		"export function Add(a: number, b: number): number",
-		"export async function main(): Promise<void>",
-		"let size = $.len(Greeting)",
+		"export async function main(): globalThis.Promise<void>",
+		"let size = 5",
 		"$.print(\"total:\", size)",
 		"$.println(Greeting, total)",
 		"$.panic(\"unreachable\")",
@@ -140,6 +142,262 @@ func TestCompilePackagesEmitsSimplePackage(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesSkipsPureTopLevelBlankAssertions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/blankassert\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type named interface { Name() string }",
+			"type item struct{}",
+			"func (*item) Name() string { return \"item\" }",
+			"var defaultItem = &item{}",
+			"var _ named = defaultItem",
+			"func main() { println(defaultItem.Name()) }",
+			"",
+		}, "\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", "blankassert", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if strings.Contains(text, "__goscriptBlank") {
+		t.Fatalf("pure top-level blank assertion emitted runtime binding:\n%s", text)
+	}
+	if !strings.Contains(text, "export let defaultItem") {
+		t.Fatalf("missing real package variable:\n%s", text)
+	}
+}
+
+func TestCompilePackagesLazilyInitializesCrossFilePackageVars(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/lazyvars\n\ngo 1.25.3\n",
+		"a.go": strings.Join([]string{
+			"package main",
+			"type words []int",
+			"type remote struct { n int }",
+			"var one = words{1}",
+			"func useTwo() int { return two.values[0] + remoteZero.n }",
+			"",
+		}, "\n"),
+		"b.go": strings.Join([]string{
+			"package main",
+			"type holder struct { values words }",
+			"var two = holder{one}",
+			"var remoteZero remote",
+			"func main() { println(useTwo(), two.values[0]) }",
+			"",
+		}, "\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", "lazyvars", "b.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export let 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 function __goscript_get_remoteZero(): __goscript_a.remote",
+		"__goscript_a.one",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	aFile := filepath.Join(outputDir, "@goscript", "example.test", "lazyvars", "a.gs.ts")
+	aContent, err := os.ReadFile(aFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(aContent), "__goscript_b.__goscript_get_two()") {
+		t.Fatalf("missing lazy cross-file getter use in a.go output:\n%s", string(aContent))
+	}
+}
+
+func TestCompilePackagesLazilyInitializesFunctionBodyPackageVarDependencies(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/lazybodyvars\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Point struct { n int }",
+			"var first, _ = new(Point).SetBytes()",
+			"func (p *Point) SetBytes() (*Point, error) {",
+			"  p.n = later",
+			"  return p, nil",
+			"}",
+			"var later = 7",
+			"func main() { println(first.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", "lazybodyvars", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"export let 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",
+	} {
+		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 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",
@@ -226,6 +484,49 @@ func TestCompilePackagesEmitsPackageLocalImport(t *testing.T) {
 	}
 }
 
+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",
@@ -241,6 +542,9 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 			"func (c *Counter) Set(v int) {",
 			"  c.Value = v",
 			"}",
+			"func NewCounter() *Counter {",
+			"  return &Counter{Value: 3}",
+			"}",
 			"func main() {",
 			"  original := Counter{Value: 1}",
 			"",
@@ -248,6 +552,7 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 			"  copy := original",
 			"  pointer := &original",
 			"  pointer.Set(2)",
+			"  NewCounter().Set(5)",
 			"  var iface any = pointer",
 			"  _, ok := iface.(*Counter)",
 			"  println(copy.Read(), original.Read(), ok)",
@@ -278,9 +583,10 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 		"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(original.value.clone())",
-		"let pointer = original",
-		"$.pointerValue(pointer).Set(2)",
+		"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\\\"\" }",
 	} {
@@ -326,7 +632,7 @@ func TestCompilePackagesEmitsNestedPointerStorageAssertions(t *testing.T) {
 		"let p1 = $.varRef(x)",
 		"let p2 = $.varRef(p1)",
 		"let p3 = p2",
-		"$.pointerValue($.pointerValue(p3))!.value = 12",
+		"$.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)
@@ -381,19 +687,19 @@ func TestCompilePackagesEmitsArraySliceMapStringAndNamedMethods(t *testing.T) {
 		"export type MyInt = number",
 		"export function MyInt_Double(m: MyInt): number",
 		"export type MySlice = $.Slice<number>",
-		"export function MySlice_Add(s: $.VarRef<MySlice>, v: number): void",
+		"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 = $.makeMap<string, number>()",
+		"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)",
+		"let list: $.VarRef<MySlice> = $.varRef(null as MySlice)",
 		"MySlice_Add(list, 7)",
 		"$.indexStringOrBytes(text, 0)",
 		"MyInt_Double(5)",
@@ -452,18 +758,19 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type Greeter = ((name: string) => string) | null",
+		"export type Greeter = ((name: string) => string | globalThis.Promise<string>) | null",
 		"export type ReadCloser = null | {",
 		"Read(): string",
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
-		"((__receiver) => () => __receiver.Inc())($.pointerValue(counter))",
+		"((__receiver) => () => __receiver.Inc())($.pointerValue<Counter>(counter))",
 		"$.namedFunction(greet, \"main.Greeter\")",
 		"$.typedNil(\"*struct{Name string}\")",
 		"elemType: { kind: $.TypeKind.Struct, methods: [], fields: {\"Name\": { kind: $.TypeKind.Basic, name: \"string\" }} }",
 		"let fn = __goscriptTuple",
-		"$.typeSwitch(",
-		"types: [\"main.ReadCloser\"]",
+		"switch (true)",
+		"case $.typeAssert<ReadCloser | null>(__goscriptTypeSwitchValue, \"main.ReadCloser\").ok",
+		"let v: ReadCloser | null = $.typeAssert<ReadCloser | null>(__goscriptTypeSwitchValue, \"main.ReadCloser\").value",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -506,7 +813,7 @@ func TestCompilePackagesAssertsInterfaceMethodReceivers(t *testing.T) {
 	text := string(content)
 	for _, want := range []string{
 		"export type FileInfo = null | {",
-		"$.println(info!.Name())",
+		"$.println($.pointerValue<Exclude<FileInfo, null>>(info).Name())",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -555,9 +862,9 @@ func TestCompilePackagesBoxesTypedNilInterfaceValues(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"return $.interfaceValue<Animal>(FindDog(), \"*main.Dog\")",
-		"$.println(animal!.Name())",
-		"let a: Animal = $.interfaceValue<Animal>(dog, \"*main.Dog\")",
+		"return $.interfaceValue<Animal | null>(FindDog(), \"*main.Dog\")",
+		"$.println($.pointerValue<Exclude<Animal, null>>(animal).Name())",
+		"let a: Animal | null = $.interfaceValue<Animal | null>(dog, \"*main.Dog\")",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -617,7 +924,7 @@ func TestCompilePackagesEmitsGenericMethodsAliasesAndDictionaries(t *testing.T)
 	for _, want := range []string{
 		"public Get(): any",
 		"export function NewBox(__typeArgs: $.GenericTypeArgs | undefined, value: any): Box",
-		"let seen = $.makeMap<number, Record<string, unknown>>()",
+		"let seen: Set = $.makeMap<number, {}>()",
 		"$.mapSet(seen, 1, {})",
 		"$.genericZero(__typeArgs, \"T\", null)",
 		"$.callGenericMethod(__typeArgs, \"T\", \"String\", v)",
@@ -668,8 +975,8 @@ func TestCompilePackagesAttachesFunctionLiteralTypeInfo(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type Callback = ((value: number) => string) | null",
-		"export function call(cb: Callback): string {\n\treturn cb!(1)",
+		"export type Callback = ((value: number) => string | globalThis.Promise<string>) | null",
+		"export async function call(cb: ((value: number) => string | globalThis.Promise<string>) | null): globalThis.Promise<string> {\n\treturn await cb!(1)",
 		"$.functionValue((value: number): string => {",
 		"kind: $.TypeKind.Function",
 		"params: [{ kind: $.TypeKind.Basic, name: \"int\" }]",
@@ -681,6 +988,44 @@ func TestCompilePackagesAttachesFunctionLiteralTypeInfo(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesEmitsRecursiveFunctionTypeInfo(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/recursive-function-type\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Handler func(Handler) Handler",
+			"type Holder struct { Next Handler }",
+			"func main() { _ = Holder{} }",
+			"",
+		}, "\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", "recursive-function-type", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	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\"",
+		"params: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
+		"results: [{ kind: $.TypeKind.Function, params: [], results: [] }]",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
 func TestCompilePackagesPacksVariadicCalls(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/variadic\n\ngo 1.25.3\n",
@@ -734,7 +1079,7 @@ func TestCompilePackagesPacksVariadicCalls(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"export type Collector = ((label: string, parts: $.Slice<string>) => string) | null",
+		"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]",
@@ -746,7 +1091,7 @@ func TestCompilePackagesPacksVariadicCalls(t *testing.T) {
 		"$.append(parts, \"c\", \"d\")",
 		"maybeErr($.arrayToSlice<string>([\"ok\"]))",
 		"fn!(\"fn\", $.arrayToSlice<string>([\"x\"]))",
-		"joiner!.Join($.arrayToSlice<string>([\"q\", \"r\"]))",
+		"$.pointerValue<Exclude<Joiner, null>>(joiner).Join($.arrayToSlice<string>([\"q\", \"r\"]))",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -754,6 +1099,46 @@ func TestCompilePackagesPacksVariadicCalls(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesPacksVariadicCallsInGeneratedSubpackage(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/variadic-subpackage\n\ngo 1.25.3\n",
+		"json/json.go": strings.Join([]string{
+			"package json",
+			"import \"fmt\"",
+			"type State struct { err error }",
+			"func (s *State) SetErrorf(format string, a ...any) {",
+			"  s.err = fmt.Errorf(format, a...)",
+			"}",
+			"func (s *State) Read(key string) {",
+			"  s.SetErrorf(\"bad %q\", key)",
+			"}",
+			"",
+		}, "\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(), "./json"); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "variadic-subpackage", "json", "json.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	want := "$.pointerValue<State>(s).SetErrorf(\"bad %q\", $.arrayToSlice<any>([key]))"
+	if !strings.Contains(text, want) {
+		t.Fatalf("missing %q in generated output:\n%s", want, text)
+	}
+	if strings.Contains(text, "$.pointerValue<State>(s).SetErrorf(\"bad %q\", key)") {
+		t.Fatalf("generated override subpackage call was not packed:\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",
@@ -781,6 +1166,21 @@ func TestCompilePackagesLowersRangeOverFunctionIterators(t *testing.T) {
 			"    }",
 			"    println(i)",
 			"  }",
+			"  ch := make(chan int, 1)",
+			"  for _, outer := range backward([]int{1, 2}) {",
+			"    for range backward([]int{3}) {",
+			"      ch <- outer",
+			"    }",
+			"  }",
+			"}",
+			"func backward(values []int) func(func(int, int) bool) {",
+			"  return func(yield func(int, int) bool) {",
+			"    for i := len(values) - 1; i >= 0; i-- {",
+			"      if !yield(i, values[i]) {",
+			"        return",
+			"      }",
+			"    }",
+			"  }",
 			"}",
 			"",
 		}, "\n"),
@@ -801,12 +1201,14 @@ func TestCompilePackagesLowersRangeOverFunctionIterators(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"if (!_yield!(i, v))",
+		"if (!await _yield!(i, v))",
 		"break",
-		"pairs!((i, v) => {",
+		"await pairs!(async (i, v) => {",
 		"last = __goscriptRange",
 		"return true",
 		"continue",
+		"await backward($.arrayToSlice<number>([1, 2]))!(async (__goscriptRange",
+		"await backward($.arrayToSlice<number>([3]))!(async (__goscriptRange",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -814,6 +1216,103 @@ func TestCompilePackagesLowersRangeOverFunctionIterators(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersFunctionIteratorControlFlow(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/iterator-control\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func values(yield func(int) bool) {",
+			"  for i := range 4 {",
+			"    if !yield(i) {",
+			"      return",
+			"    }",
+			"  }",
+			"}",
+			"func first(limit int) int {",
+			"  j := 3",
+			"  for i := 0; i < j; i, j = i+1, j-1 {",
+			"    println(i, j)",
+			"  }",
+			"  for v := range values {",
+			"    if v == 0 {",
+			"      continue",
+			"    }",
+			"    for i := range 2 {",
+			"      if i == 1 {",
+			"        break",
+			"      }",
+			"    }",
+			"    if v == limit {",
+			"      break",
+			"    }",
+			"    switch v {",
+			"    case 2:",
+			"      return v",
+			"    }",
+			"    switch any(v).(type) {",
+			"    case int:",
+			"      if v == 3 {",
+			"        return v",
+			"      }",
+			"    }",
+			"  }",
+			"  return -1",
+			"}",
+			"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",
@@ -857,16 +1356,16 @@ func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"Process(v: number): Promise<number>",
-		"public async Process(v: number): Promise<number>",
+		"Process(v: number): globalThis.Promise<number>",
+		"public async Process(v: number): globalThis.Promise<number>",
 		"let ch = $.makeChannel<number>(1, 0, \"both\")",
-		"await $.chanSend($.pointerValue(w).ch, v)",
-		"return await $.chanRecv($.pointerValue(w).ch)",
+		"await $.chanSend($.pointerValue<Worker>(w).ch, v)",
+		"return await $.chanRecv($.pointerValue<Worker>(w).ch)",
 		"await using __defer = new $.AsyncDisposableStack()",
-		"queueMicrotask(async () => { await ($.functionValue(async (): Promise<void> => {",
+		"queueMicrotask(async () => { await ($.functionValue(async (): globalThis.Promise<void> => {",
 		"$.selectStatement<any, void>([",
 		"let v = result.value",
-		"await call(new Worker({ch: $.makeChannel<number>(1, 0, \"both\")}))",
+		"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)
@@ -931,6 +1430,21 @@ func TestCompilePackagesLowersSwitchesAndFunctionValueCalls(t *testing.T) {
 			"  case value > 1:",
 			"    println(\"positive\")",
 			"  }",
+			"Block:",
+			"  for value > 0 {",
+			"    switch value {",
+			"    case 2:",
+			"      value--",
+			"      fallthrough",
+			"    case 1:",
+			"      break Block",
+			"    }",
+			"  }",
+			"Again:",
+			"  value--",
+			"  if value > 0 {",
+			"    goto Again",
+			"  }",
 			"  release := func() { println(\"release\") }",
 			"  rel := &release",
 			"  (*rel)()",
@@ -963,7 +1477,11 @@ func TestCompilePackagesLowersSwitchesAndFunctionValueCalls(t *testing.T) {
 		"case 3:",
 		"let local = \"two-three\"",
 		"switch (true) {",
-		"($.pointerValue(rel))!()",
+		"Block: while (value > 0)",
+		"break Block",
+		"Again: while (true)",
+		"continue Again",
+		"($.pointerValue<(() => void) | null>(rel))!()",
 		"$.functionValue((): void => {\n\t\tusing __defer = new $.DisposableStack()",
 		"__defer.defer(() => { $.println(\"wrapped deferred\") })",
 		"$.println(\"wrapped body\")",
@@ -975,6 +1493,9 @@ func TestCompilePackagesLowersSwitchesAndFunctionValueCalls(t *testing.T) {
 	if strings.Count(text, "\t\tbreak\n") < 3 {
 		t.Fatalf("switch cases were not rendered with implicit breaks:\n%s", text)
 	}
+	if strings.Contains(text, "fallthrough") {
+		t.Fatalf("fallthrough marker leaked into generated output:\n%s", text)
+	}
 }
 
 func TestCompilePackagesLowersMethodValuesWithFixedParameters(t *testing.T) {
@@ -1077,11 +1598,11 @@ func TestCompilePackagesQualifiesImportedTypesInSignaturesAndZeroValues(t *testi
 	for _, want := range []string{
 		"Box: $.VarRef<lib.Box>",
 		"Boxes: $.VarRef<$.Slice<lib.Box>>",
-		"Fn: $.VarRef<((_p0: lib.Box) => [lib.Box, $.GoError]) | null>",
+		"Fn: $.VarRef<((_p0: lib.Box) => [lib.Box, $.GoError] | globalThis.Promise<[lib.Box, $.GoError]>) | null>",
 		"Ptr: $.VarRef<atomic.Pointer<(() => void) | null>>",
 		"$.markAsStructValue(new lib.Box())",
 		"$.markAsStructValue(new atomic.Pointer<(() => void) | null>())",
-		"export function Use(fn: ((_p0: lib.Box) => [lib.Box, $.GoError]) | null, box: lib.Box): [lib.Box, $.GoError]",
+		"export async function Use(fn: ((_p0: lib.Box) => [lib.Box, $.GoError] | globalThis.Promise<[lib.Box, $.GoError]>) | null, box: lib.Box): globalThis.Promise<[lib.Box, $.GoError]>",
 		"$.functionValue((box: lib.Box): [lib.Box, $.GoError] => {",
 	} {
 		if !strings.Contains(text, want) {
@@ -1090,14 +1611,16 @@ func TestCompilePackagesQualifiesImportedTypesInSignaturesAndZeroValues(t *testi
 	}
 }
 
-func TestCompilePackagesReportsUnsupportedUnaryBeforeOutput(t *testing.T) {
+func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
-		"go.mod": "module example.test/unsupported\n\ngo 1.25.3\n",
+		"go.mod": "module example.test/unary-bitwise\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
 			"package main",
 			"var value = 1",
 			"func main() {",
-			"  println(^value)",
+			"  mask := 7",
+			"  mask &^= 3",
+			"  println(^value, value &^ 3, mask, 0700)",
 			"}",
 			"",
 		}, "\n"),
@@ -1108,25 +1631,132 @@ func TestCompilePackagesReportsUnsupportedUnaryBeforeOutput(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 
-	result, err := comp.CompilePackages(context.Background(), ".")
-	if err == nil {
-		t.Fatal("expected unsupported unary expression to fail")
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
 	}
-	requireDiagnostic(t, err, "goscript/lowering:unsupported")
-	if result == nil || len(result.Diagnostics) == 0 {
-		t.Fatalf("expected structured diagnostics in result")
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "unary-bitwise", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
 	}
-	if _, statErr := os.Stat(outputDir); !os.IsNotExist(statErr) {
-		t.Fatalf("compile wrote output directory after lowering failed: %v", statErr)
+	text := string(content)
+	for _, want := range []string{
+		"mask = mask & ~(3)",
+		"$.println(~value, value & ~(3), mask, 0o700)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
 	}
 }
 
-func TestCompileSourceToTypeScriptStopsAtSkeleton(t *testing.T) {
-	_, err := CompileSourceToTypeScript("package main\nfunc main() {}\n", "main")
-	if err == nil {
-		t.Fatal("expected WASM source compile to fail in the skeleton")
+func TestCompileSourceToTypeScriptCompilesSingleFile(t *testing.T) {
+	output, err := CompileSourceToTypeScript("package main\nfunc main() { println(\"hi\") }\n", "main")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(output, "$.println(\"hi\")") {
+		t.Fatalf("missing println in generated output:\n%s", output)
+	}
+}
+
+func TestTypeScriptEmitOwnerEmitsToMemoryOnDiskPath(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":  "module example.test/memoryemit\n\ngo 1.25.3\n",
+		"main.go": "package main\nfunc main() { println(\"memory\") }\n",
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	req := &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          outputDir,
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeReference,
+	}
+	service := NewCompileService()
+	graph, diagnostics := service.PackageGraphOwner().Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("graph diagnostics: %#v", diagnostics)
+	}
+	model, diagnostics := service.SemanticModelOwner().Build(context.Background(), graph)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("semantic diagnostics: %#v", diagnostics)
+	}
+	program, diagnostics := service.LoweringOwner().Build(context.Background(), model)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("lowering diagnostics: %#v", diagnostics)
+	}
+
+	files, diagnostics := service.TypeScriptEmitOwner().EmitToMemory(context.Background(), program)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("memory emit diagnostics: %#v", diagnostics)
+	}
+	path := "@goscript/example.test/memoryemit/main.gs.ts"
+	if !strings.Contains(files[path], "$.println(\"memory\")") {
+		t.Fatalf("missing in-memory output: %#v", files)
+	}
+	if _, diagnostics := service.TypeScriptEmitOwner().Emit(context.Background(), req, program); diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("disk emit diagnostics: %#v", diagnostics)
+	}
+	content, err := os.ReadFile(filepath.Join(outputDir, filepath.FromSlash(path)))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if string(content) != files[path] {
+		t.Fatalf("disk and memory emit diverged:\n%s\n---\n%s", string(content), files[path])
+	}
+}
+
+func TestCompilePackagesLowersNamedStructConversionWithTypedAsyncFact(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/namedstructconvert\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type Source struct { Value int }",
+			"type Target Source",
+			"func Make() Source {",
+			"  ch := make(chan Source, 1)",
+			"  ch <- Source{Value: 7}",
+			"  return <-ch",
+			"}",
+			"func Convert() Target {",
+			"  return Target(Make())",
+			"}",
+			"func ConvertLiteral() Target {",
+			"  return Target(func() Source {",
+			"    ch := make(chan Source, 1)",
+			"    ch <- Source{Value: 9}",
+			"    return <-ch",
+			"  }())",
+			"}",
+			"func main() { println(Convert().Value) }",
+			"",
+		}, "\n"),
+	})
+	outputDir := filepath.Join(t.TempDir(), "output")
+	comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	outputFile := filepath.Join(outputDir, "@goscript", "example.test", "namedstructconvert", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "await (async () => { const __goscriptConvert") {
+		t.Fatalf("missing async named struct conversion:\n%s", text)
+	}
+	if !strings.Contains(text, "$.markAsStructValue(new Target({Value: __goscriptConvert") {
+		t.Fatalf("missing typed named struct conversion target:\n%s", text)
+	}
+	if !strings.Contains(text, "const __goscriptConvert1 = await ($.functionValue(async ") {
+		t.Fatalf("missing async fact from function literal conversion source:\n%s", text)
 	}
-	requireDiagnostic(t, err, "goscript/wasm:single-file-unsupported")
 }
 
 func requireDiagnostic(t *testing.T, err error, code string) {