goscript 0.2.4 → 0.2.5

package/compiler/lowering_bench_test.go

@@ -47,6 +47,8 @@ func BenchmarkLoweringPackage(b *testing.B) {
 			fixture.model,
 			fixture.semPkg,
 			make(map[string]map[types.Object]bool),
+			make(map[*types.Func]bool),
+			make(map[*types.Func]bool),
 			make(runtimeMethodSetCache),
 			LoweringOptions{},
 		); diagnosticsHaveErrors(diagnostics) {
@@ -86,6 +88,8 @@ func BenchmarkLoweringFile(b *testing.B) {
 			fixture.file.outputNames,
 			fixture.file.lazyPackageVars,
 			fixture.lazyPackageVarsByPkg,
+			make(map[*types.Func]bool),
+			make(map[*types.Func]bool),
 			make(runtimeMethodSetCache),
 			false,
 			"",

package/compiler/override-facts.go

@@ -13,8 +13,8 @@ import (
 	"slices"
 	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	jsoniter "github.com/aperturerobotics/json-iterator-lite"
+	gs "github.com/s4wave/goscript"
 )
 
 // OverrideFacts is the immutable compiler-visible view of GoScript overrides.

package/compiler/package-graph.go

@@ -5,6 +5,7 @@ import (
 	"go/ast"
 	"os"
 	"slices"
+	"strconv"
 	"strings"
 
 	"golang.org/x/tools/go/packages"
@@ -163,6 +164,9 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			Message:  "package graph did not contain any package nodes",
 		})
 	}
+	if len(req.PackageBlocklist) != 0 {
+		diagnostics = append(diagnostics, packageBlocklistDiagnostics(graph, req.PackageBlocklist)...)
+	}
 	return graph, diagnostics
 }
 
@@ -245,6 +249,94 @@ func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *O
 	}
 }
 
+func packageBlocklistDiagnostics(graph *PackageGraph, blocklist []string) []Diagnostic {
+	chain := packageBlocklistChain(graph, blocklist)
+	if len(chain) == 0 {
+		return nil
+	}
+	blocked := chain[len(chain)-1]
+	return []Diagnostic{{
+		Severity: DiagnosticSeverityError,
+		Code:     "goscript/package-graph:blocklisted-package",
+		Message:  "package graph contains blocklisted package " + strconv.Quote(blocked),
+		Detail:   "import chain: " + strings.Join(chain, " -> "),
+	}}
+}
+
+func packageBlocklistChain(graph *PackageGraph, blocklist []string) []string {
+	if graph == nil || len(graph.RequestedPackagePaths) == 0 {
+		return nil
+	}
+
+	roots := slices.Clone(graph.RequestedPackagePaths)
+	slices.Sort(roots)
+
+	type queueEntry struct {
+		path  string
+		chain []string
+	}
+	queue := make([]queueEntry, 0, len(roots))
+	seen := make(map[string]bool)
+	for _, root := range roots {
+		if graph.NodesByPackagePath[root] == nil || seen[root] {
+			continue
+		}
+		seen[root] = true
+		queue = append(queue, queueEntry{
+			path:  root,
+			chain: []string{root},
+		})
+	}
+
+	for len(queue) != 0 {
+		entry := queue[0]
+		queue = queue[1:]
+		if packagePathBlocklisted(entry.path, blocklist) {
+			return entry.chain
+		}
+
+		node := graph.NodesByPackagePath[entry.path]
+		if node == nil {
+			continue
+		}
+		// Override candidates are compiled from their GoScript override, whose
+		// TypeScript imports replace the native Go imports. collect prunes their
+		// native dependencies from the graph, so the blocklist walk must treat
+		// them as leaves; otherwise an overridden package (for example a
+		// reflect-free encoding/json override) would falsely chain to a
+		// blocklisted package it no longer imports in the compiled output.
+		if node.OverrideCandidate {
+			continue
+		}
+		imports := slices.Clone(node.Imports)
+		slices.Sort(imports)
+		for _, importPath := range imports {
+			if graph.NodesByPackagePath[importPath] == nil || seen[importPath] {
+				continue
+			}
+			seen[importPath] = true
+			nextChain := slices.Clone(entry.chain)
+			nextChain = append(nextChain, importPath)
+			queue = append(queue, queueEntry{
+				path:  importPath,
+				chain: nextChain,
+			})
+		}
+	}
+	return nil
+}
+
+func packagePathBlocklisted(path string, blocklist []string) bool {
+	for _, blocked := range blocklist {
+		// Match the package exactly or any subpackage, on a path-segment
+		// boundary so "crypto" blocks "crypto/ecdsa" but not "cryptobyte".
+		if path == blocked || strings.HasPrefix(path, blocked+"/") {
+			return true
+		}
+	}
+	return false
+}
+
 func normalizePackageFileOrder(pkg *packages.Package) {
 	if pkg == nil {
 		return

package/compiler/package-graph_test.go

@@ -266,6 +266,119 @@ func TestPackageGraphLoadsLocalReplacement(t *testing.T) {
 	}
 }
 
+func TestPackageBlocklistAllowsCleanFixture(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":       "module example.test/blockclean\n\ngo 1.25.3\n",
+		"main.go":      "package blockclean\nimport \"example.test/blockclean/dep\"\nfunc Value() int { return dep.Value() }\n",
+		"dep/dep.go":   "package dep\nfunc Value() int { return 1 }\n",
+		"other/doc.go": "package other\n",
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:              moduleDir,
+		OutputPath:       filepath.Join(t.TempDir(), "out"),
+		AllDependencies:  true,
+		PackageBlocklist: []string{"example.test/blockclean/other"},
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatalf("compile with clean blocklist failed: %v", err)
+	}
+}
+
+func TestPackageBlocklistReportsShortestImportChain(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":                 "module example.test/blockchain\n\ngo 1.25.3\n",
+		"main.go":                "package blockchain\nimport \"example.test/blockchain/dep\"\nfunc Value() int { return dep.Value() }\n",
+		"dep/dep.go":             "package dep\nimport \"example.test/blockchain/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+		"mid/leaf.go":            "package mid\nimport \"example.test/blockchain/mid/blocked\"\nfunc Leaf() int { return blocked.Value() }\n",
+		"mid/blocked/blocked.go": "package blocked\nfunc Value() int { return 1 }\n",
+	})
+	comp, err := NewCompiler(&Config{
+		Dir:              moduleDir,
+		OutputPath:       filepath.Join(t.TempDir(), "out"),
+		AllDependencies:  true,
+		PackageBlocklist: []string{"example.test/blockchain/mid/blocked"},
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	_, err = comp.CompilePackages(context.Background(), ".")
+	if err == nil {
+		t.Fatal("expected blocklisted package diagnostic")
+	}
+	text := err.Error()
+	if !strings.Contains(text, "goscript/package-graph:blocklisted-package") {
+		t.Fatalf("expected blocklist diagnostic, got %q", text)
+	}
+	if !strings.Contains(text, `package graph contains blocklisted package "example.test/blockchain/mid/blocked"`) {
+		t.Fatalf("expected blocklisted package name, got %q", text)
+	}
+	expected := "example.test/blockchain -> example.test/blockchain/dep -> example.test/blockchain/mid/blocked"
+	if !strings.Contains(text, expected) {
+		t.Fatalf("expected shortest import chain %q, got %q", expected, text)
+	}
+}
+
+func TestPackageBlocklistIgnoresOverrideCandidateImports(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": strings.Join([]string{
+			"module example.test/blockoverride",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/over v0.0.0",
+			"replace example.test/over => ./over",
+			"",
+		}, "\n"),
+		"main.go":                "package blockoverride\nimport (\n\t\"example.test/over\"\n\t\"example.test/blockoverride/dep\"\n)\nfunc Value() int { return over.Value() + dep.Value() }\n",
+		"dep/dep.go":             "package dep\nimport \"example.test/blockoverride/mid\"\nfunc Value() int { return mid.Value() }\n",
+		"mid/mid.go":             "package mid\nimport \"example.test/blockoverride/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+		"mid/blocked/blocked.go": "package blocked\nfunc Value() int { return 1 }\n",
+		"over/go.mod": strings.Join([]string{
+			"module example.test/over",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/blockoverride v0.0.0",
+			"replace example.test/blockoverride => ../",
+			"",
+		}, "\n"),
+		"over/over.go": "package over\nimport \"example.test/blockoverride/mid/blocked\"\nfunc Value() int { return blocked.Value() }\n",
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/over/index.ts", "export function Value(): number { return 0 }\n")
+
+	overrideOwner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+		PackageBlocklist:    []string{"example.test/blockoverride/mid/blocked"},
+	}
+	graph, diagnostics := NewPackageGraphOwner(overrideOwner).Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		chain := packageBlocklistChain(graph, req.PackageBlocklist)
+		if slices.Contains(chain, "example.test/over") {
+			t.Fatalf("blocklist chain routed through override candidate: %v", chain)
+		}
+		expected := []string{
+			"example.test/blockoverride",
+			"example.test/blockoverride/dep",
+			"example.test/blockoverride/mid",
+			"example.test/blockoverride/mid/blocked",
+		}
+		if !slices.Equal(chain, expected) {
+			t.Fatalf("expected real import chain %v, got %v", expected, chain)
+		}
+	} else {
+		t.Fatal("expected blocklisted package diagnostic via the real import path")
+	}
+}
+
 func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod":  "module example.test/override\n\ngo 1.25.3\n",

package/compiler/runtime-contract.go

@@ -5,8 +5,8 @@ import (
 	"slices"
 	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	"github.com/pkg/errors"
+	gs "github.com/s4wave/goscript"
 )
 
 // RuntimeHelperCategory names a runtime helper family owned by the contract.

package/compiler/semantic-model.go

@@ -756,6 +756,15 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 				if typed.Op == token.ARROW {
 					markFunctionAsync(semFn, "channel-receive")
 				}
+			case *ast.RangeStmt:
+				if signatureForType(pkg.TypesInfo.TypeOf(typed.X)) != nil {
+					if called := calledFunction(pkg, typed.X); called != nil {
+						semFn.calls[functionOriginOrSelf(called)] = true
+					}
+					if rangeFunctionExprNeedsAwait(model, pkg, overrideFacts, typed.X) {
+						markFunctionAsync(semFn, "range-function")
+					}
+				}
 			case *ast.CallExpr:
 				if called := calledFunction(pkg, typed.Fun); called != nil {
 					semFn.calls[functionOriginOrSelf(called)] = true
@@ -785,6 +794,29 @@ func (o *SemanticModelOwner) collectFunctionFacts(
 	return diagnostics
 }
 
+func rangeFunctionExprNeedsAwait(
+	model *SemanticModel,
+	pkg *packages.Package,
+	overrideFacts *OverrideFacts,
+	expr ast.Expr,
+) bool {
+	if model == nil || pkg == nil || signatureForType(pkg.TypesInfo.TypeOf(expr)) == nil {
+		return false
+	}
+	if called := calledFunction(pkg, expr); called != nil {
+		if semFn := semanticFunctionFor(model, called); semFn != nil && semFn.async {
+			return true
+		}
+		if called.Pkg() != nil && overrideFacts.IsFunctionAsync(called.Pkg().Path(), called.Name()) {
+			return true
+		}
+	}
+	if overrideFacts.IsMethodAsync(overrideCallPackage(pkg, expr), overrideCallMethod(pkg, expr)) {
+		return true
+	}
+	return callUsesFunctionValue(pkg, expr)
+}
+
 func recordImmediateFuncLitAsyncFacts(
 	model *SemanticModel,
 	pkg *packages.Package,

package/compiler/skeleton_test.go

@@ -789,6 +789,61 @@ func TestCompilePackagesReadsShadowedVarRefStructFieldsOnce(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesUnwrapsAnonymousStructPointerFieldReceivers(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/anonstructptr\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package anonstructptr",
+			"func mergeCore(dst, src *struct {",
+			"  IsBare bool",
+			"  Worktree string",
+			"}) {",
+			"  if src.IsBare {",
+			"    dst.IsBare = true",
+			"  }",
+			"  if src.Worktree != \"\" {",
+			"    dst.Worktree = src.Worktree",
+			"  }",
+			"}",
+			"",
+		}, "\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", "anonstructptr", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		`$.pointerValue<{"IsBare": boolean, "Worktree": string}>(src).IsBare`,
+		`$.pointerValue<{"IsBare": boolean, "Worktree": string}>(dst).IsBare = true`,
+		`$.pointerValue<{"IsBare": boolean, "Worktree": string}>(dst).Worktree = $.pointerValue<{"IsBare": boolean, "Worktree": string}>(src).Worktree`,
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	for _, bad := range []string{
+		"src.IsBare",
+		"dst.IsBare",
+		"src.Worktree",
+		"dst.Worktree",
+	} {
+		if strings.Contains(text, bad) {
+			t.Fatalf("anonymous struct pointer field receiver stayed wrapped at %q:\n%s", bad, text)
+		}
+	}
+}
+
 func TestCompilePackagesWrapsChannelSendInterfaceValues(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/chansendiface\n\ngo 1.25.3\n",
@@ -1436,7 +1491,7 @@ func TestCompilePackagesEmitsSideEffectImportsForInterfaceRegistry(t *testing.T)
 		"import * as dep from \"@goscript/example.test/interface-registry/dep/index.js\"",
 		"import \"@goscript/example.test/interface-registry/dep/index.js\"",
 		"import type * as __goscript_local from \"./local.gs.ts\"",
-		"case $.typeAssert<Exclude<__goscript_local.Local, null>>(__goscriptTypeSwitchValue, \"main.Local\").ok",
+		"case $.typeAssert<__goscript_local.Local | null>(__goscriptTypeSwitchValue, \"main.Local\").ok",
 		"$.typeAssertTuple<dep.Remote | null>(v, \"dep.Remote\")",
 	} {
 		if !strings.Contains(mainText, want) {
@@ -1546,6 +1601,56 @@ func TestCompilePackagesLowersUnsafeBytePointerArithmetic(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesLowersGMSUnsafeArrayPointerConversions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/gmsunsafe\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"reflect\"",
+			"  \"unsafe\"",
+			")",
+			"func IntBytes(n int64) byte {",
+			"  mem := (*[8]byte)(unsafe.Pointer(&n))",
+			"  bytes := *mem",
+			"  return bytes[0]",
+			"}",
+			"func StringToBytes(str string) []byte {",
+			"  if len(str) == 0 {",
+			"    return []byte{}",
+			"  }",
+			"  return (*[0x7fff0000]byte)(unsafe.Pointer((*reflect.StringHeader)(unsafe.Pointer(&str)).Data))[:len(str):len(str)]",
+			"}",
+			"",
+		}, "\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", "gmsunsafe", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	if !strings.Contains(text, "$.arrayPointerFromIndexRef<number>($.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)") {
+		t.Fatalf("missing string data unsafe array pointer conversion:\n%s", text)
+	}
+	if strings.Contains(text, "unsafe.Pointer(&n) as any") || strings.Contains(text, "StringHeader)(unsafe.Pointer(&str)).Data) as any") {
+		t.Fatalf("unsafe array pointer conversion fell back to any cast:\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",
@@ -1669,6 +1774,124 @@ func TestCompilePackagesEscapesReservedTypeNames(t *testing.T) {
 	}
 }
 
+func TestCompilePackagesEscapesStrictModeRestrictedIdentifiers(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/strictidents\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"func choose(arguments int) (eval int) {",
+			"  eval = arguments + 1",
+			"  arguments = eval + arguments",
+			"  return",
+			"}",
+			"func main() {",
+			"  eval := choose(1)",
+			"  arguments := eval + 1",
+			"  println(eval, arguments)",
+			"}",
+			"",
+		}, "\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", "strictidents", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"function choose(_arguments: number): number",
+		"let _eval: number = 0",
+		"_eval = _arguments + 1",
+		"_arguments = _eval + _arguments",
+		"let _eval = choose(1)",
+		"let _arguments = _eval + 1",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	for _, bad := range []string{
+		"let eval",
+		" eval =",
+		"function choose(arguments",
+		"let arguments",
+		" arguments =",
+	} {
+		if strings.Contains(text, bad) {
+			t.Fatalf("strict-mode restricted identifier was not escaped, found %q:\n%s", bad, text)
+		}
+	}
+}
+
+func TestCompilePackagesDoesNotEmitHiddenEmbeddedMethodOverField(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/hiddenembeddedmethod\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"type embedded struct{}",
+			"func (embedded) Database() string {",
+			"  return \"method\"",
+			"}",
+			"type holder struct {",
+			"  Database string",
+			"  embedded",
+			"}",
+			"func value(h holder) string {",
+			"  return h.Database",
+			"}",
+			"",
+		}, "\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", "hiddenembeddedmethod", "main.gs.ts")
+	content, err := os.ReadFile(outputFile)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"public get Database(): string",
+		"public set Database(value: string)",
+		"return h.Database",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+	if got := strings.Count(text, "public Database("); got != 1 {
+		t.Fatalf("expected only embedded.Database method, got %d declarations:\n%s", got, text)
+	}
+	holderStart := strings.Index(text, "export class holder")
+	embeddedStart := strings.Index(text, "export class embedded")
+	if holderStart < 0 || embeddedStart < 0 {
+		t.Fatalf("missing holder or embedded class:\n%s", text)
+	}
+	holderText := text[holderStart:]
+	if embeddedStart > holderStart {
+		holderText = text[holderStart:embeddedStart]
+	}
+	if strings.Contains(holderText, "public Database(") {
+		t.Fatalf("hidden embedded method was emitted on holder:\n%s", holderText)
+	}
+}
+
 func TestCompilePackagesAvoidsPointerMethodTypeNameShadow(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/methodshadow\n\ngo 1.25.3\n",
@@ -1907,9 +2130,9 @@ func TestCompilePackagesEmitsArraySliceMapStringAndNamedMethods(t *testing.T) {
 		"let literal: $.Slice<number> = $.arrayToSlice<number>([1, 2])",
 		"literal = $.append(literal, 3)",
 		"slice![0] = arr[1]",
-		"let m: Map<string, number> | null = $.makeMap<string, number>()",
+		"let m: globalThis.Map<string, number> | null = $.makeMap<string, number>()",
 		"$.mapSet(m, \"one\", 1)",
-		"let [value, ok] = $.mapGet(m, \"missing\", 0)",
+		"let [value, ok] = $.mapGet<string, number, number>(m, \"missing\", 0)",
 		"slice![0]",
 		"literal![2]",
 		"let list: $.VarRef<MySlice> = $.varRef(null as MySlice)",
@@ -2447,8 +2670,8 @@ func TestCompilePackagesEmitsInterfacesMethodValuesTypeSwitchesAndFunctionAssert
 		"elemType: { kind: $.TypeKind.Struct, methods: [], fields: [{ name: \"Name\", key: \"Name\", type: { kind: $.TypeKind.Basic, name: \"string\" }",
 		"let fn = __goscriptTuple",
 		"switch (true)",
-		"case $.typeAssert<Exclude<ReadCloser, null>>(__goscriptTypeSwitchValue, \"main.ReadCloser\").ok",
-		"let v: Exclude<ReadCloser, null> = $.typeAssert<Exclude<ReadCloser, null>>(__goscriptTypeSwitchValue, \"main.ReadCloser\").value",
+		"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)
@@ -2541,8 +2764,8 @@ func TestCompilePackagesUsesNonNilInterfaceTypeSwitchCaseVarRefs(t *testing.T) {
 	text := string(content)
 	for _, want := range []string{
 		"export type tcpConn = {",
-		"case $.typeAssert<Exclude<tcpConn, null>>(__goscriptTypeSwitchValue, \"main.tcpConn\").ok",
-		"let c: $.VarRef<Exclude<tcpConn, null>> = $.varRef($.typeAssert<Exclude<tcpConn, null>>(__goscriptTypeSwitchValue, \"main.tcpConn\").value)",
+		"case $.typeAssert<tcpConn | null>(__goscriptTypeSwitchValue, \"main.tcpConn\").ok",
+		"let c: $.VarRef<tcpConn | null> = $.varRef($.typeAssert<tcpConn | null>(__goscriptTypeSwitchValue, \"main.tcpConn\").value)",
 		"$.pointerValue<Exclude<tcpConn, null>>(c.value).SyscallConn()",
 	} {
 		if !strings.Contains(text, want) {
@@ -3454,7 +3677,7 @@ func TestCompilePackagesEmitsAsyncChannelsSelectAndDefer(t *testing.T) {
 		"await $.chanSend($.pointerValue<Worker>(w).ch, v)",
 		"return await $.chanRecv($.pointerValue<Worker>(w).ch)",
 		"await using __defer = new $.AsyncDisposableStack()",
-		"queueMicrotask(async () => { await ($.functionValue(async (): globalThis.Promise<void> => {",
+		"queueMicrotask(async () => { await (async (): globalThis.Promise<void> => {",
 		"$.selectStatement<any, void>([",
 		"let v = __goscriptSelect1Result.value",
 		"return $.selectVoidReturn()",
@@ -4755,7 +4978,7 @@ func TestCompilePackagesLowersMethodValuesWithFixedParameters(t *testing.T) {
 	}
 }
 
-func TestCompilePackagesLowersSyncOverrideCallbackWithoutAsyncWrapper(t *testing.T) {
+func TestCompilePackagesLowersSortSearchCallbackAsAsyncCompatible(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": "module example.test/sync-callback\n\ngo 1.25.3\n",
 		"main.go": strings.Join([]string{
@@ -4794,11 +5017,14 @@ func TestCompilePackagesLowersSyncOverrideCallbackWithoutAsyncWrapper(t *testing
 		t.Fatal(err.Error())
 	}
 	text := string(content)
-	if strings.Contains(text, "$.functionValue(async (i: number)") {
-		t.Fatalf("sync override callback lowered as async:\n%s", text)
-	}
-	if !strings.Contains(text, "$.functionValue((i: number): boolean => {") {
-		t.Fatalf("sync override callback was not lowered as a synchronous function value:\n%s", text)
+	for _, want := range []string{
+		"return await sort.Search(",
+		"$.functionValue(async (i: number): globalThis.Promise<boolean> => {",
+		"let item = await $.pointerValue<Exclude<Items, null>>(items).Get(i)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
 	}
 }
 
@@ -5379,7 +5605,7 @@ func TestCompilePackagesLowersNamedStructConversionWithTypedAsyncFact(t *testing
 	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 ") {
+	if !strings.Contains(text, "const __goscriptConvert1 = await (async ") {
 		t.Fatalf("missing async fact from function literal conversion source:\n%s", text)
 	}
 }

package/compiler/wasm/compile.go

@@ -2,7 +2,7 @@
 package wasm
 
 import (
-	"github.com/aperturerobotics/goscript/compiler"
+	"github.com/s4wave/goscript/compiler"
 )
 
 // CompileSource compiles import-free browser source strings to TypeScript.

package/compiler/wasm/compile_test.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/compiler"
+	"github.com/s4wave/goscript/compiler"
 )
 
 func TestCompileSourceCompilesSingleFile(t *testing.T) {

package/dist/compiler/index.d.ts

@@ -8,6 +8,10 @@ export interface CompileConfig {
     output?: string;
     /** The working directory for the compiler. Defaults to the current working directory. */
     dir?: string;
+    /** Compile all transitive dependencies of the requested package. */
+    allDependencies?: boolean;
+    /** Go import paths to reject from the compiled package graph. */
+    packageBlocklist?: string[] | string;
     /** The path to the goscript executable. Defaults to `go run ./cmd/goscript`. */
     goscriptPath?: string;
 }