goscript 0.2.5 → 0.2.7

package/compiler/runtime-contract.go

@@ -33,12 +33,15 @@ const (
 	RuntimeHelperPrint     RuntimeHelper = "builtin.print"
 	RuntimeHelperInt       RuntimeHelper = "builtin.int"
 	RuntimeHelperUint      RuntimeHelper = "builtin.uint"
+	RuntimeHelperInt64     RuntimeHelper = "builtin.int64"
+	RuntimeHelperUint64    RuntimeHelper = "builtin.uint64"
 	RuntimeHelperByte      RuntimeHelper = "builtin.byte"
 	RuntimeHelperLen       RuntimeHelper = "builtin.len"
 	RuntimeHelperCap       RuntimeHelper = "builtin.cap"
 	RuntimeHelperClear     RuntimeHelper = "builtin.clear"
 	RuntimeHelperPanic     RuntimeHelper = "builtin.panic"
 	RuntimeHelperRecover   RuntimeHelper = "builtin.recover"
+	RuntimeHelperRecovered RuntimeHelper = "builtin.recovered"
 	RuntimeHelperMin       RuntimeHelper = "builtin.min"
 	RuntimeHelperMax       RuntimeHelper = "builtin.max"
 	RuntimeHelperComplex   RuntimeHelper = "builtin.complex"
@@ -103,6 +106,7 @@ const (
 	RuntimeHelperSliceHeaderRef               RuntimeHelper = "slice.sliceHeaderRef"
 	RuntimeHelperGenericBytesOrStringToString RuntimeHelper = "slice.genericBytesOrStringToString"
 	RuntimeHelperIndexStringOrBytes           RuntimeHelper = "slice.indexStringOrBytes"
+	RuntimeHelperArrayIndex                   RuntimeHelper = "slice.arrayIndex"
 	RuntimeHelperSliceStringOrBytes           RuntimeHelper = "slice.sliceStringOrBytes"
 	RuntimeHelperIndexRef                     RuntimeHelper = "slice.indexRef"
 	RuntimeHelperIndexAddress                 RuntimeHelper = "slice.indexAddress"
@@ -267,12 +271,15 @@ func runtimeHelperContracts() []RuntimeHelperContract {
 		runtimeHelper(RuntimeHelperPrint, "print", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperInt, "int", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperUint, "uint", RuntimeHelperCategoryBuiltin),
+		runtimeHelper(RuntimeHelperInt64, "int64", RuntimeHelperCategoryBuiltin),
+		runtimeHelper(RuntimeHelperUint64, "uint64", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperByte, "byte", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperLen, "len", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperCap, "cap", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperClear, "clear", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperPanic, "panic", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperRecover, "recover", RuntimeHelperCategoryBuiltin),
+		runtimeHelper(RuntimeHelperRecovered, "recovered", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperMin, "min", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperMax, "max", RuntimeHelperCategoryBuiltin),
 		runtimeHelper(RuntimeHelperComplex, "complex", RuntimeHelperCategoryBuiltin),
@@ -334,6 +341,7 @@ func runtimeHelperContracts() []RuntimeHelperContract {
 		runtimeHelper(RuntimeHelperSliceHeaderRef, "sliceHeaderRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperGenericBytesOrStringToString, "genericBytesOrStringToString", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexStringOrBytes, "indexStringOrBytes", RuntimeHelperCategorySlice),
+		runtimeHelper(RuntimeHelperArrayIndex, "arrayIndex", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperSliceStringOrBytes, "sliceStringOrBytes", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexRef, "indexRef", RuntimeHelperCategorySlice),
 		runtimeHelper(RuntimeHelperIndexAddress, "indexAddress", RuntimeHelperCategorySlice),

package/compiler/service.go

@@ -12,6 +12,7 @@ type CompileService struct {
 	semanticOwner *SemanticModelOwner
 	loweringOwner *LoweringOwner
 	emitterOwner  *TypeScriptEmitOwner
+	cacheOwner    *CompilerCacheOwner
 	runtimeOwner  *RuntimeContractOwner
 	overrideOwner *OverrideRegistryOwner
 	parityOwner   *OverrideParityVerifier
@@ -27,6 +28,7 @@ func NewCompileService(overrideDirs ...string) *CompileService {
 		semanticOwner: NewSemanticModelOwner(overrideOwner),
 		loweringOwner: NewLoweringOwner(runtimeOwner, overrideOwner),
 		emitterOwner:  NewTypeScriptEmitOwner(runtimeOwner),
+		cacheOwner:    NewCompilerCacheOwner(),
 		runtimeOwner:  runtimeOwner,
 		overrideOwner: overrideOwner,
 		parityOwner:   NewOverrideParityVerifier(),
@@ -58,6 +60,11 @@ func (s *CompileService) TypeScriptEmitOwner() *TypeScriptEmitOwner {
 	return s.emitterOwner
 }
 
+// CompilerCacheOwner returns the compiler cache owner.
+func (s *CompileService) CompilerCacheOwner() *CompilerCacheOwner {
+	return s.cacheOwner
+}
+
 // RuntimeContractOwner returns the runtime contract owner.
 func (s *CompileService) RuntimeContractOwner() *RuntimeContractOwner {
 	return s.runtimeOwner
@@ -88,6 +95,44 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return NewCompileService(req.OverrideDirs...).Compile(ctx, req)
 	}
 
+	var overrideFacts *OverrideFacts
+	var cacheReplayTried bool
+	if s.cacheOwner.Enabled(req) {
+		graph, graphDiagnostics := s.graphOwner.LoadIdentity(ctx, req)
+		diagnostics = append(diagnostics, graphDiagnostics...)
+		if graph != nil {
+			result.OriginalPackages = append([]string(nil), graph.RequestedPackagePaths...)
+		}
+		if diagnosticsHaveErrors(diagnostics) {
+			result.Diagnostics = diagnostics
+			return result, NewCompileError(diagnostics)
+		}
+
+		var factsDiagnostics []Diagnostic
+		overrideFacts, factsDiagnostics = s.overrideOwner.Facts(ctx)
+		diagnostics = append(diagnostics, factsDiagnostics...)
+		if diagnosticsHaveErrors(diagnostics) {
+			result.Diagnostics = diagnostics
+			return result, NewCompileError(diagnostics)
+		}
+
+		if compilerCacheFastReplayAllowed(req, graph, overrideFacts) {
+			overridePlan, overrideDiagnostics := s.overrideOwner.CopyPlan(ctx, req, graph)
+			diagnostics = append(diagnostics, overrideDiagnostics...)
+			if diagnosticsHaveErrors(diagnostics) {
+				result.Diagnostics = diagnostics
+				return result, NewCompileError(diagnostics)
+			}
+			cacheEntries := s.cacheOwner.Entries(req, graph, overridePlan)
+			if cached, ok := s.cacheOwner.Replay(ctx, req, cacheEntries); ok {
+				cached.OriginalPackages = append([]string(nil), result.OriginalPackages...)
+				cached.Diagnostics = diagnostics
+				return cached, nil
+			}
+			cacheReplayTried = true
+		}
+	}
+
 	graph, graphDiagnostics := s.graphOwner.Load(ctx, req)
 	diagnostics = append(diagnostics, graphDiagnostics...)
 	if graph != nil {
@@ -98,11 +143,14 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
-	overrideFacts, factsDiagnostics := s.overrideOwner.Facts(ctx)
-	diagnostics = append(diagnostics, factsDiagnostics...)
-	if diagnosticsHaveErrors(diagnostics) {
-		result.Diagnostics = diagnostics
-		return result, NewCompileError(diagnostics)
+	if overrideFacts == nil {
+		var factsDiagnostics []Diagnostic
+		overrideFacts, factsDiagnostics = s.overrideOwner.Facts(ctx)
+		diagnostics = append(diagnostics, factsDiagnostics...)
+		if diagnosticsHaveErrors(diagnostics) {
+			result.Diagnostics = diagnostics
+			return result, NewCompileError(diagnostics)
+		}
 	}
 	parityDiagnostics := s.parityOwner.Verify(ctx, graph, overrideFacts)
 	diagnostics = append(diagnostics, parityDiagnostics...)
@@ -111,6 +159,26 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
+	var cacheEntries []compilerCacheEntry
+	var overridePlan *overrideCopyPlan
+	if s.cacheOwner.Enabled(req) {
+		var overrideDiagnostics []Diagnostic
+		overridePlan, overrideDiagnostics = s.overrideOwner.CopyPlan(ctx, req, graph)
+		diagnostics = append(diagnostics, overrideDiagnostics...)
+		if diagnosticsHaveErrors(diagnostics) {
+			result.Diagnostics = diagnostics
+			return result, NewCompileError(diagnostics)
+		}
+		cacheEntries = s.cacheOwner.Entries(req, graph, overridePlan)
+		if !cacheReplayTried {
+			if cached, ok := s.cacheOwner.Replay(ctx, req, cacheEntries); ok {
+				cached.OriginalPackages = append([]string(nil), result.OriginalPackages...)
+				cached.Diagnostics = diagnostics
+				return cached, nil
+			}
+		}
+	}
+
 	semanticModel, semanticDiagnostics := s.semanticOwner.Build(ctx, graph)
 	diagnostics = append(diagnostics, semanticDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
@@ -118,11 +186,14 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
-	overridePlan, overrideDiagnostics := s.overrideOwner.CopyPlan(ctx, req, graph)
-	diagnostics = append(diagnostics, overrideDiagnostics...)
-	if diagnosticsHaveErrors(diagnostics) {
-		result.Diagnostics = diagnostics
-		return result, NewCompileError(diagnostics)
+	if overridePlan == nil {
+		var overrideDiagnostics []Diagnostic
+		overridePlan, overrideDiagnostics = s.overrideOwner.CopyPlan(ctx, req, graph)
+		diagnostics = append(diagnostics, overrideDiagnostics...)
+		if diagnosticsHaveErrors(diagnostics) {
+			result.Diagnostics = diagnostics
+			return result, NewCompileError(diagnostics)
+		}
 	}
 
 	loweredProgram, loweringDiagnostics := s.loweringOwner.Build(ctx, semanticModel, LoweringOptions{
@@ -130,6 +201,7 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		DisplayRoot:               req.Dir,
 		OutputPath:                req.OutputPath,
 		ProtobufTypeScriptBinding: req.ProtobufTypeScriptBinding,
+		TrimTypeInfo:              !packageGraphContainsPackage(graph, "reflect"),
 	})
 	diagnostics = append(diagnostics, loweringDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
@@ -137,13 +209,20 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 
-	compiledPackages, emitDiagnostics := s.emitterOwner.Emit(ctx, req, loweredProgram)
+	files, emitDiagnostics := s.emitterOwner.EmitToMemory(ctx, loweredProgram)
 	diagnostics = append(diagnostics, emitDiagnostics...)
 	if diagnosticsHaveErrors(diagnostics) {
 		result.Diagnostics = diagnostics
 		return result, NewCompileError(diagnostics)
 	}
+	compiledPackages, writeDiagnostics := s.emitterOwner.WriteFiles(ctx, req, loweredProgram, files)
+	diagnostics = append(diagnostics, writeDiagnostics...)
+	if diagnosticsHaveErrors(diagnostics) {
+		result.Diagnostics = diagnostics
+		return result, NewCompileError(diagnostics)
+	}
 	result.CompiledPackages = append(result.CompiledPackages, compiledPackages...)
+	s.cacheOwner.StoreGenerated(req, cacheEntries, loweredProgram, files)
 
 	copiedPackages, copyDiagnostics := s.overrideOwner.CopyPackages(ctx, req, overridePlan)
 	diagnostics = append(diagnostics, copyDiagnostics...)
@@ -153,7 +232,15 @@ func (s *CompileService) Compile(ctx context.Context, req *CompileRequest) (*Com
 		return result, NewCompileError(diagnostics)
 	}
 	result.CopiedPackages = append(result.CopiedPackages, copiedPackages...)
+	s.cacheOwner.StoreCopied(req, cacheEntries, overridePlan)
 
 	result.Diagnostics = diagnostics
 	return result, nil
 }
+
+func compilerCacheFastReplayAllowed(req *CompileRequest, graph *PackageGraph, facts *OverrideFacts) bool {
+	if req == nil || req.DependencyMode != DependencyModeAll {
+		return false
+	}
+	return !overrideParityRequiresTypedGraph(graph, facts)
+}

package/compiler/skeleton_test.go

@@ -741,7 +741,7 @@ func TestCompilePackagesLowersWideIntegerConstantsForUint64Targets(t *testing.T)
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	for _, want := range []string{`$.uint("18014398509481983", 64)`, `$.uint("9007199254740993", 64)`} {
+	for _, want := range []string{`18014398509481983n`, `9007199254740993n`} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing wide integer constant %q in generated output:\n%s", want, text)
 		}
@@ -1584,7 +1584,7 @@ func TestCompilePackagesLowersUnsafeBytePointerArithmetic(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "$.indexByteAddress(bits!, $.uint64Shr(idx, 6), 8)") {
+	if !strings.Contains(text, "$.indexByteAddress(bits!, Number($.uint64Shr(idx, 6)), 8)") {
 		t.Fatalf("missing byte-addressed unsafe pointer root:\n%s", text)
 	}
 	if !strings.Contains(text, "$.unsafePointerRef<number>(ptr).value =") {
@@ -1640,7 +1640,7 @@ func TestCompilePackagesLowersGMSUnsafeArrayPointerConversions(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "$.arrayPointerFromIndexRef<number>($.indexRef([n.value], 0), 8, 8, 1)") {
+	if !strings.Contains(text, "$.arrayPointerFromIndexRef<bigint>($.indexRef([n.value], 0), 8, 8, 1)") {
 		t.Fatalf("missing scalar unsafe array pointer conversion:\n%s", text)
 	}
 	if !strings.Contains(text, "$.arrayPointerFromIndexRef<number>($.indexRef($.stringToBytes(str.value), 0), 2147418112, 1, 1)") {
@@ -1714,8 +1714,8 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 		"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\" })",
-		"{ name: \"Value\", key: \"Value\", type: { kind: $.TypeKind.Basic, name: \"int\" }, tag: \"json:\\\"value\\\"\", index: [0], offset: 0, exported: true }",
-		"{ name: \"ID\", key: \"ID\", type: { kind: $.TypeKind.Basic, name: \"int32\", typeName: \"main.ObjectID\" }, index: [1], offset: 8, exported: true }",
+		"{ name: \"Value\", key: \"Value\", type: { kind: $.TypeKind.Basic, name: \"int\" }, tag: \"json:\\\"value\\\"\" }",
+		"{ name: \"ID\", key: \"ID\", type: { kind: $.TypeKind.Basic, name: \"int32\", typeName: \"main.ObjectID\" } }",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -1723,6 +1723,102 @@ func TestCompilePackagesEmitsStructMethodsAndPointerAssertions(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesTypeInfoTrimFollowsReflectReachability(t *testing.T) {
+	source := func(importReflect bool) string {
+		lines := []string{
+			"package main",
+		}
+		if importReflect {
+			lines = append(lines,
+				"import \"reflect\"",
+				"var _ = reflect.TypeOf(Sample{})",
+			)
+		}
+		lines = append(lines,
+			"type Reader interface { Read(v int) string }",
+			"type Sample struct { Name string `json:\"name\"` }",
+			"func (Sample) Read(v int) string { return \"\" }",
+			"func main() {}",
+			"",
+		)
+		return strings.Join(lines, "\n")
+	}
+
+	t.Run("reflect absent trims registration payload", func(t *testing.T) {
+		moduleDir := writePackageGraphFixture(t, map[string]string{
+			"go.mod":  "module example.test/typeinfotrim\n\ngo 1.25.3\n",
+			"main.go": source(false),
+		})
+		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", "typeinfotrim", "main.gs.ts"))
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		text := string(content)
+		for _, want := range []string{
+			`args: [{ type: { kind: $.TypeKind.Basic, name: "unknown" } }]`,
+			`returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }]`,
+			`{ name: "Name", key: "Name", type: { kind: $.TypeKind.Basic, name: "string" }, tag: "json:\"name\"" }`,
+		} {
+			if !strings.Contains(text, want) {
+				t.Fatalf("missing trimmed type-info payload %q:\n%s", want, text)
+			}
+		}
+		for _, dropped := range []string{
+			`args: [{ name: "v", type: { kind: $.TypeKind.Basic, name: "int" } }]`,
+			`returns: [{ name: "_r0", type: { kind: $.TypeKind.Basic, name: "string" } }]`,
+			`index: [0]`,
+			`offset: 0`,
+			`exported: true`,
+		} {
+			if strings.Contains(text, dropped) {
+				t.Fatalf("trimmed type-info payload kept %q:\n%s", dropped, text)
+			}
+		}
+	})
+
+	t.Run("reflect reachable keeps full registration payload", func(t *testing.T) {
+		moduleDir := writePackageGraphFixture(t, map[string]string{
+			"go.mod":  "module example.test/typeinfofull\n\ngo 1.25.3\n",
+			"main.go": source(true),
+		})
+		outputDir := filepath.Join(t.TempDir(), "output")
+		comp, err := NewCompiler(&Config{Dir: moduleDir, OutputPath: outputDir, AllDependencies: true}, nil, nil)
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+
+		if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+			t.Fatal(err.Error())
+		}
+		content, err := os.ReadFile(filepath.Join(outputDir, "@goscript", "example.test", "typeinfofull", "main.gs.ts"))
+		if err != nil {
+			t.Fatal(err.Error())
+		}
+		text := string(content)
+		for _, want := range []string{
+			`args: [{ name: "v", type: { kind: $.TypeKind.Basic, name: "int" } }]`,
+			`returns: [{ name: "_r0", type: { kind: $.TypeKind.Basic, name: "string" } }]`,
+			`{ name: "Name", key: "Name", type: { kind: $.TypeKind.Basic, name: "string" }, tag: "json:\"name\"", index: [0], offset: 0, exported: true }`,
+		} {
+			if !strings.Contains(text, want) {
+				t.Fatalf("missing full type-info payload %q:\n%s", want, text)
+			}
+		}
+		if strings.Contains(text, `args: [{ type: { kind: $.TypeKind.Basic, name: "unknown" } }]`) {
+			t.Fatalf("reflect-reachable type-info payload was trimmed:\n%s", text)
+		}
+	})
+}
+
 func TestCompilePackagesEscapesReservedTypeNames(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/reservedtypes\n\ngo 1.25.3\n",
@@ -2129,12 +2225,12 @@ func TestCompilePackagesEmitsArraySliceMapStringAndNamedMethods(t *testing.T) {
 		"let empty: $.Slice<number> = $.arrayToSlice<number>([])",
 		"let literal: $.Slice<number> = $.arrayToSlice<number>([1, 2])",
 		"literal = $.append(literal, 3)",
-		"slice![0] = arr[1]",
+		"slice![0] = $.arrayIndex(arr, 1)",
 		"let m: globalThis.Map<string, number> | null = $.makeMap<string, number>()",
 		"$.mapSet(m, \"one\", 1)",
 		"let [value, ok] = $.mapGet<string, number, number>(m, \"missing\", 0)",
 		"slice![0]",
-		"literal![2]",
+		"$.arrayIndex(literal!, 2)",
 		"let list: $.VarRef<MySlice> = $.varRef(null as MySlice)",
 		"MySlice_Add(list, 7)",
 		"$.indexStringOrBytes(text, 0)",
@@ -2661,7 +2757,7 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 		"Read(): string",
 		"Close(): string",
 		"$.registerInterfaceType(\n\t\"main.ReadCloser\"",
-		"{ name: \"Close\", args: [], returns: [{ name: \"_r0\", type: { kind: $.TypeKind.Basic, name: \"string\" } }] }]\n);",
+		"{ name: \"Close\", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: \"string\" } }] }",
 		"((__receiver) => () => __receiver.Inc())($.pointerValue<Counter>(counter))",
 		"$.namedFunction(greet, \"main.Greeter\", ({ kind: $.TypeKind.Function, name: \"main.Greeter\"",
 		"params: [{ kind: $.TypeKind.Basic, name: \"string\" }]",
@@ -5129,9 +5225,9 @@ func TestCompilePackagesLowersUnaryBitwiseComplement(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"return $.uint($.uint64Xor(crc, -1n), 64)",
+		"return $.uint64Xor(crc, -1n)",
 		"mask = mask & ~((3))",
-		"$.println($.int64Xor(value, -1n), $.uint($.uint64Xor(wide, -1n), 64), $.int($.int64Xor(signed, -1n)), $.uint(invert($.uint(wide, 64)), 64), value & ~(3), mask, 0o700)",
+		"$.println(Number($.int64Xor(value, -1n)), $.uint64Xor(wide, -1n), $.int64Xor(signed, -1n), invert(wide), value & ~(3), mask, 0o700)",
 	} {
 		if !strings.Contains(text, want) {
 			t.Fatalf("missing %q in generated output:\n%s", want, text)
@@ -5207,8 +5303,8 @@ func TestCompilePackagesNormalizesWideIntegerReturnTargets(t *testing.T) {
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if !strings.Contains(text, "return $.uint(await $.pointerValue<Exclude<hash.Hash64, null>>(h).Sum64(), 64)") {
-		t.Fatalf("missing uint64 return normalization:\n%s", text)
+	if !strings.Contains(text, "return await $.pointerValue<Exclude<hash.Hash64, null>>(h).Sum64()") {
+		t.Fatalf("missing uint64 return passthrough:\n%s", text)
 	}
 }
 
@@ -5362,7 +5458,7 @@ func TestCompilePackagesUnwrapsImportedArrayPackageVarReads(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"$.pointerValue<number[]>(dep.Table)[1]",
+		"$.arrayIndex($.pointerValue<number[]>(dep.Table), 1)",
 		"dep.Sum($.pointerValue<number[]>(dep.Table))",
 	} {
 		if !strings.Contains(text, want) {
@@ -5450,7 +5546,7 @@ func TestCompilePackagesUnwrapsAliasedArrayPackageVarReads(t *testing.T) {
 	}
 	text := string(content)
 	for _, want := range []string{
-		"$.pointerValue<number[]>(__goscript_table.Table)[1]",
+		"$.arrayIndex($.pointerValue<number[]>(__goscript_table.Table), 1)",
 		"Sum($.pointerValue<number[]>(__goscript_table.Table))",
 	} {
 		if !strings.Contains(text, want) {

package/compiler/typescript-emitter.go

@@ -56,7 +56,36 @@ func (o *TypeScriptEmitOwner) Emit(
 	if diagnosticsHaveErrors(diagnostics) {
 		return nil, diagnostics
 	}
+	return o.WriteFiles(ctx, req, program, files)
+}
+
+// WriteFiles writes an in-memory emitted file tree to the request output root.
+func (o *TypeScriptEmitOwner) WriteFiles(
+	ctx context.Context,
+	req *CompileRequest,
+	program *LoweredProgram,
+	files map[string]string,
+) ([]string, []Diagnostic) {
+	if err := ctx.Err(); err != nil {
+		return nil, []Diagnostic{contextCanceledDiagnostic(err)}
+	}
+	if req == nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/emitter:no-request",
+			Message:  "TypeScript emission requires a compile request",
+		}}
+	}
+	if program == nil {
+		return nil, []Diagnostic{{
+			Severity: DiagnosticSeverityError,
+			Code:     "goscript/emitter:no-program",
+			Message:  "TypeScript emission requires a lowered program",
+		}}
+	}
+
 	var compiled []string
+	var diagnostics []Diagnostic
 	for _, pkg := range program.packages {
 		if err := ctx.Err(); err != nil {
 			diagnostics = append(diagnostics, Diagnostic{
@@ -125,14 +154,14 @@ func (o *TypeScriptEmitOwner) EmitToMemory(
 			return files, []Diagnostic{contextCanceledDiagnostic(err)}
 		}
 		for _, file := range pkg.files {
-			files["@goscript/"+pkg.pkgPath+"/"+file.outputName] = o.renderLoweredFile(pkg, file)
+			files["@goscript/"+pkg.pkgPath+"/"+file.outputName] = o.renderLoweredFile(pkg, file, program.trimTypeInfo)
 		}
 		files["@goscript/"+pkg.pkgPath+"/index.ts"] = renderIndex(pkg)
 	}
 	return files, nil
 }
 
-func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *loweredFile) string {
+func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *loweredFile, trimTypeInfo bool) string {
 	var b strings.Builder
 	b.Grow(estimateLoweredFileSize(file))
 	if file.sourcePath != "" {
@@ -178,7 +207,7 @@ func (o *TypeScriptEmitOwner) renderLoweredFile(pkg *loweredPackage, file *lower
 	writeDecl := func(decl loweredDecl) {
 		if decl.structType != nil {
 			writeSeparator()
-			renderStruct(&b, decl.structType, o.runtimeOwner)
+			renderStruct(&b, decl.structType, o.runtimeOwner, trimTypeInfo)
 			return
 		}
 		if decl.function != nil {
@@ -378,7 +407,7 @@ func structZeroValueDeps(structType *loweredStruct, names map[string]bool) []str
 	return deps
 }
 
-func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *RuntimeContractOwner) {
+func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *RuntimeContractOwner, trimTypeInfo bool) {
 	varRef := runtimeOwner.QualifiedHelper(RuntimeHelperVarRef)
 	markStructValue := runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue)
 	cloneStructValue := runtimeOwner.QualifiedHelper(RuntimeHelperCloneStructValue)
@@ -524,7 +553,7 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		if idx != 0 {
 			b.WriteString(", ")
 		}
-		b.WriteString(runtimeMethodSignatureExpr(method))
+		b.WriteString(runtimeMethodSignatureExpr(method, trimTypeInfo))
 	}
 	b.WriteString("],\n\t\t")
 	b.WriteString(structType.name)
@@ -533,23 +562,30 @@ func renderStruct(b *strings.Builder, structType *loweredStruct, runtimeOwner *R
 		if idx != 0 {
 			b.WriteString(", ")
 		}
-		b.WriteString(runtimeStructFieldInfoExpr(
-			field.runtimeType,
-			field.name,
-			field.runtimeName,
-			field.tag,
-			field.pkgPath,
-			field.anonymous,
-			field.index,
-			field.offset,
-			field.exported,
-		))
+		if trimTypeInfo {
+			b.WriteString(trimmedRuntimeStructFieldInfoExpr(field.runtimeType, field.name, field.runtimeName, field.tag, field.anonymous))
+		} else {
+			b.WriteString(runtimeStructFieldInfoExpr(
+				field.runtimeType,
+				field.name,
+				field.runtimeName,
+				field.tag,
+				field.pkgPath,
+				field.anonymous,
+				field.index,
+				field.offset,
+				field.exported,
+			))
+		}
 	}
 	b.WriteString("]\n\t)\n")
 	b.WriteString("}\n")
 }
 
-func runtimeMethodSignatureExpr(method loweredFunction) string {
+func runtimeMethodSignatureExpr(method loweredFunction, trimTypeInfo bool) string {
+	if trimTypeInfo && method.runtimeTrimmedSignature != "" {
+		return method.runtimeTrimmedSignature
+	}
 	if method.runtimeSignature != "" {
 		return method.runtimeSignature
 	}
@@ -560,6 +596,31 @@ func runtimeMethodSignatureExpr(method loweredFunction) string {
 	return "{ name: " + strconvQuote(methodName) + ", args: [], returns: [] }"
 }
 
+func trimmedRuntimeStructFieldInfoExpr(
+	runtimeType string,
+	storageKey string,
+	runtimeName string,
+	tag string,
+	anonymous bool,
+) string {
+	name := runtimeName
+	if name == "" {
+		name = storageKey
+	}
+	fields := []string{
+		"name: " + strconvQuote(name),
+		"key: " + strconvQuote(storageKey),
+		"type: " + runtimeType,
+	}
+	if tag != "" {
+		fields = append(fields, "tag: "+strconvQuote(tag))
+	}
+	if anonymous {
+		fields = append(fields, "anonymous: true")
+	}
+	return "{ " + strings.Join(fields, ", ") + " }"
+}
+
 func writeLineComment(b *strings.Builder, indent string, comment string) {
 	comment = strings.TrimSpace(comment)
 	if comment == "" {
@@ -619,9 +680,10 @@ func renderFunction(b *strings.Builder, fn *loweredFunction) {
 	}
 	renderStmts(b, fn.paramBindings, 1)
 	renderNamedResults(b, fn.namedResults, 1)
-	renderDeferStack(b, fn.deferState, 1)
-	renderStmts(b, fn.body, 1)
-	renderUnreachableReturn(b, fn, 1)
+	renderBodyWithDefer(b, fn, 1)
+	if fn.deferState == nil || !fn.deferState.recover {
+		renderUnreachableReturn(b, fn, 1)
+	}
 	b.WriteString("}\n")
 }
 
@@ -663,9 +725,10 @@ func renderMethod(b *strings.Builder, fn *loweredFunction) {
 	}
 	renderStmts(b, fn.paramBindings, 2)
 	renderNamedResults(b, fn.namedResults, 2)
-	renderDeferStack(b, fn.deferState, 2)
-	renderStmts(b, fn.body, 2)
-	renderUnreachableReturn(b, fn, 2)
+	renderBodyWithDefer(b, fn, 2)
+	if fn.deferState == nil || !fn.deferState.recover {
+		renderUnreachableReturn(b, fn, 2)
+	}
 	writeIndent(b, 1)
 	b.WriteString("}\n")
 }
@@ -736,6 +799,40 @@ func renderDeferStack(b *strings.Builder, state *loweredDeferState, indent int)
 	b.WriteString("using __defer = new $.DisposableStack()\n")
 }
 
+// renderBodyWithDefer emits the defer stack, body, and trailing return for a
+// function. When the function uses recover, it wraps the defer stack and body in
+// a try/catch so the deferred functions run during stack unwinding (via the
+// using-declaration's disposal) before the catch decides whether the panic was
+// recovered; an unrecovered panic rethrows, a recovered one falls through to the
+// function's named-result return. Functions without recover keep the plain
+// using-declaration shape.
+func renderBodyWithDefer(b *strings.Builder, fn *loweredFunction, indent int) {
+	if fn.deferState == nil || !fn.deferState.recover {
+		renderDeferStack(b, fn.deferState, indent)
+		renderStmts(b, fn.body, indent)
+		return
+	}
+	writeIndent(b, indent)
+	b.WriteString("try {\n")
+	renderDeferStack(b, fn.deferState, indent+1)
+	renderStmts(b, fn.body, indent+1)
+	writeIndent(b, indent)
+	b.WriteString("} catch (e) {\n")
+	writeIndent(b, indent+1)
+	b.WriteString("if (!$.recovered(e)) {\n")
+	writeIndent(b, indent+2)
+	b.WriteString("throw e\n")
+	writeIndent(b, indent+1)
+	b.WriteString("}\n")
+	writeIndent(b, indent)
+	b.WriteString("}\n")
+	if fn.recoverReturn != "" {
+		writeIndent(b, indent)
+		b.WriteString(fn.recoverReturn)
+		b.WriteString("\n")
+	}
+}
+
 func renderStmts(b *strings.Builder, stmts []loweredStmt, indent int) {
 	for idx, stmt := range stmts {
 		renderLeadingLines(b, stmt.leading, indent)

package/dist/compiler/index.d.ts

@@ -8,6 +8,8 @@ export interface CompileConfig {
     output?: string;
     /** The working directory for the compiler. Defaults to the current working directory. */
     dir?: string;
+    /** Explicit compiler package artifact cache root. Defaults to disabled. */
+    compilerCacheRoot?: string;
     /** Compile all transitive dependencies of the requested package. */
     allDependencies?: boolean;
     /** Go import paths to reject from the compiled package graph. */

package/dist/compiler/index.js

@@ -28,6 +28,9 @@ export async function compile(config) {
     if (config.allDependencies) {
         args.push('--all-dependencies');
     }
+    if (config.compilerCacheRoot) {
+        args.push('--compiler-cache-root', path.resolve(config.compilerCacheRoot));
+    }
     const packageBlocklist = normalizePackageBlocklist(config.packageBlocklist);
     if (packageBlocklist) {
         args.push('--package-blocklist', packageBlocklist);