@scriptc/compiler 0.2.4 → 0.2.6

package/dist/frontend/lowering/lower-modules.js

@@ -1,3 +1,4 @@
+import { dynUndefinedExpr } from "../../ir/build.js";
 import { everyStmtList, everyTypeChild } from "../../ir/traverse.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Module-graph lowering: splitting each source file into its parts, the
@@ -7,29 +8,34 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { bindingSource } from "../binding-source.js";
 import { dirname as dirnamePath, isAbsolute, resolve as resolvePath } from "node:path";
-import { NpmGraphBuilder, packageNameOfPath, probeNodeImportRefusal, probeNodeRequireRefusal } from "../npm.js";
+import { NpmGraphBuilder, packageNameOfPath, probeNodeImportRefusal, probeNodeRequireRefusal, } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
-import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport } from "../program.js";
-import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
-import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType } from "../../ir/ir.js";
-import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, stripTypeCasts } from "./lower-builtins.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, funcTypeFromParamShapes, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
-import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
+import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport, } from "../program.js";
+import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag, } from "../../diagnostics/diagnostic.js";
+import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
+import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall, } from "./lowerer.js";
+import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, } from "./builtins/module-bindings.js";
+import { isPromisifyCall, registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
+import { stripTypeCasts } from "./builtins/arguments.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, } from "./generic-functions.js";
+import { bindingNeverReassigned, deadUnmappableBinding, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
+import { funcTypeFromParamShapes, registerOverloadedCallableAlias } from "./call-signatures.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl, } from "./lower-stmts.js";
 import { objectFactoryGlobalType } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
-import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
+import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf, } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType } from "./lower-classes.js";
+import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType, } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
+import { workerTargetPaths } from "../worker-target.js";
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 /** Program modules selected by statically resolved child_process.fork()
  * calls join the compiled graph without becoming startup dependencies of
@@ -37,9 +43,15 @@ import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
  * in a re-executed fork child. `targets` is append-only so ids stay stable
  * across the dynamic-import/fork discovery fixpoint. */
 export function appendForkModules(program, order, targets, onCycle) {
+    appendEntryModules(program, order, targets, forkTargetPaths(program, order), onCycle);
+}
+export function appendWorkerModules(program, order, targets, onCycle) {
+    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle);
+}
+function appendEntryModules(program, order, targets, paths, onCycle) {
     if (order.length === 0)
         return;
-    const byPath = new Map(program.getSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
+    const byPath = new Map(program.getImplementationSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
     const state = new Map();
     for (const sf of order)
         state.set(sf, "done");
@@ -74,7 +86,7 @@ export function appendForkModules(program, order, targets, onCycle) {
         added.push(sf);
     };
     const knownTargets = new Set(targets);
-    for (const path of forkTargetPaths(program, order)) {
+    for (const path of paths) {
         const target = byPath.get(resolvePath(path));
         if (!target || target.isDeclarationFile || target.fileName.endsWith(".json"))
             continue;
@@ -88,10 +100,10 @@ export function appendForkModules(program, order, targets, onCycle) {
         order.splice(order.length - 1, 0, ...added);
 }
 /** Splits each file into function/class declarations and the top-level
-   * statements that form its init body. Node's evaluation order (depth-first
-   * postorder, entry last), computed by preflight. Single-file programs
-   * (tests, coverage on broken files) may arrive with an empty order — fall
-   * back to the entry alone. */
+ * statements that form its init body. Node's evaluation order (depth-first
+ * postorder, entry last), computed by preflight. Single-file programs
+ * (tests, coverage on broken files) may arrive with an empty order — fall
+ * back to the entry alone. */
 export function splitFiles(lowerer) {
     const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
     return files.map((sf) => {
@@ -123,10 +135,10 @@ export function splitFiles(lowerer) {
     });
 }
 /** A source file dynamic `import("<project specifier>")` can host as a COMPILED
-   * module namespace (lowerOwnModuleImport): a non-declaration program file
-   * that is not JSON and not CommonJS-flavored (a CJS namespace is built
-   * from module.exports through Node's lexer — a different surface with no
-   * static story here). Null for everything else. */
+ * module namespace (lowerOwnModuleImport): a non-declaration program file
+ * that is not JSON and not CommonJS-flavored (a CJS namespace is built
+ * from module.exports through Node's lexer — a different surface with no
+ * static story here). Null for everything else. */
 function dynamicImportProgramTargetOf(program, sf, spec) {
     const dep = resolveImport(program, sf, spec);
     if (!dep || dep.isDeclarationFile)
@@ -138,7 +150,7 @@ function dynamicImportProgramTargetOf(program, sf, spec) {
     return dep;
 }
 /** Every distinct program module a file's `import("literal")` sites name
-   * (source order, deduped). */
+ * (source order, deduped). */
 function dynamicProgramImportsOf(program, sf) {
     const out = [];
     const seen = new Set();
@@ -157,21 +169,21 @@ function dynamicProgramImportsOf(program, sf) {
     return out;
 }
 /** --dynamic builds: program modules reachable ONLY through dynamic
-   * `import()` join the compiled module graph — appended to `order` (before
-   * the entry, which stays last) in depth-first postorder over their own
-   * static import edges, exactly like preflight ordered the static graph.
-   * NOTHING calls their %init at startup (%main runs only the entry's init,
-   * and no static import header names these), so a dynamic-only module
-   * still evaluates exactly when Node evaluates it: the import() site's
-   * namespace builder calls the guarded init on the engine microtask.
-   * Fixpoint: an added module's own import() sites are scanned too. Static
-   * cycles inside the added subgraph ride preflight's own admission engine
-   * (makeCycleAdmission — preflight only walked the entry's static graph,
-   * so it never judged these): benign back edges are Node cache hits the
-   * run-once init guards reproduce, and inadmissible ones get preflight's
-   * SC1016 with the same narrowed reason via `onCycle`. Idempotent —
-   * re-running on an already-extended order adds nothing (both lowering
-   * passes share one array). */
+ * `import()` join the compiled module graph — appended to `order` (before
+ * the entry, which stays last) in depth-first postorder over their own
+ * static import edges, exactly like preflight ordered the static graph.
+ * NOTHING calls their %init at startup (%main runs only the entry's init,
+ * and no static import header names these), so a dynamic-only module
+ * still evaluates exactly when Node evaluates it: the import() site's
+ * namespace builder calls the guarded init on the engine microtask.
+ * Fixpoint: an added module's own import() sites are scanned too. Static
+ * cycles inside the added subgraph ride preflight's own admission engine
+ * (makeCycleAdmission — preflight only walked the entry's static graph,
+ * so it never judged these): benign back edges are Node cache hits the
+ * run-once init guards reproduce, and inadmissible ones get preflight's
+ * SC1016 with the same narrowed reason via `onCycle`. Idempotent —
+ * re-running on an already-extended order adds nothing (both lowering
+ * passes share one array). */
 export function appendDynamicImportModules(program, order, onCycle) {
     if (order.length === 0)
         return; // no preflight order — sites keep their fences
@@ -224,10 +236,10 @@ export function appendDynamicImportModules(program, order, onCycle) {
         order.splice(order.length - 1, 0, ...added);
 }
 /** Collect pass over the WHOLE program: signatures, class shapes, and
-   * file-scope globals visible everywhere → hoisting, mutual recursion, and
-   * cross-module references fall out for free. Runs in both passes —
-   * signatures are cheap and calls resolve against them; only BODY lowering
-   * is reachability-gated. */
+ * file-scope globals visible everywhere → hoisting, mutual recursion, and
+ * cross-module references fall out for free. Runs in both passes —
+ * signatures are cheap and calls resolve against them; only BODY lowering
+ * is reachability-gated. */
 export function collectProgram(lowerer, parts) {
     const computed = new Set();
     for (const fp of parts)
@@ -238,7 +250,9 @@ export function collectProgram(lowerer, parts) {
         }
     // Descendants need the computed ancestor's completed layout before
     // their own fields and inherited methods can be collected.
-    const computedSymbols = new Set([...computed].map((decl) => declSymbolOf(lowerer, decl)).filter((symbol) => symbol !== undefined));
+    const computedSymbols = new Set([...computed]
+        .map((decl) => declSymbolOf(lowerer, decl))
+        .filter((symbol) => symbol !== undefined));
     let expanded = true;
     while (expanded) {
         expanded = false;
@@ -312,18 +326,39 @@ export function collectProgram(lowerer, parts) {
             if (value.type.kind === "dyn" || value.type.kind === "func") {
                 const name = `%class.base.${lowerer.classNamer(decl)}`;
                 const loc = locOf(expression);
-                lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
-                    body: [{ kind: "return", value, loc }], loc });
-                lowerer.computedCallableBases.set(decl, { kind: "call", callee: name, args: [], type: value.type, loc });
+                lowerer.liftedFns.push({
+                    name,
+                    params: [],
+                    returnType: value.type,
+                    locals: context.locals,
+                    body: [{ kind: "return", value, loc }],
+                    loc,
+                });
+                lowerer.computedCallableBases.set(decl, {
+                    kind: "call",
+                    callee: name,
+                    args: [],
+                    type: value.type,
+                    loc,
+                });
             }
             if (value.type.kind === "classval") {
                 const classInfo = lowerer.classes.get(value.type.className);
                 if (classInfo) {
                     const name = `%class.base.${lowerer.classNamer(decl)}`;
                     const loc = locOf(expression);
-                    lowerer.liftedFns.push({ name, params: [], returnType: value.type, locals: context.locals,
-                        body: [{ kind: "return", value, loc }], loc });
-                    lowerer.computedClassBases.set(lowerer.classNamer(decl), { value: { kind: "call", callee: name, args: [], type: value.type, loc }, classInfo });
+                    lowerer.liftedFns.push({
+                        name,
+                        params: [],
+                        returnType: value.type,
+                        locals: context.locals,
+                        body: [{ kind: "return", value, loc }],
+                        loc,
+                    });
+                    lowerer.computedClassBases.set(lowerer.classNamer(decl), {
+                        value: { kind: "call", callee: name, args: [], type: value.type, loc },
+                        classInfo,
+                    });
                 }
             }
         }
@@ -343,25 +378,28 @@ export function collectProgram(lowerer, parts) {
             lowerer.diagSink = previousSink;
         }
         if (symbol && deferred.length) {
-            lowerer.deferredDiags.set(symbol, [...(lowerer.deferredDiags.get(symbol) ?? []), ...deferred]);
+            lowerer.deferredDiags.set(symbol, [
+                ...(lowerer.deferredDiags.get(symbol) ?? []),
+                ...deferred,
+            ]);
             lowerer.deferredClassByName.set(lowerer.classNamer(decl), symbol);
         }
         lowerer.collecting = wasCollecting;
     }
 }
 /** The npm-import chokepoint, run once per pass during collection (so
-   * bodies lowered in ANY pass resolve the bindings). In a static build
-   * every value-importing npm import reports the requires-dynamic
-   * diagnostic naming the package — the package's shipped JS has exactly
-   * one execution home, the embedded engine. Under --dynamic each value
-   * binding becomes a jsval GLOBAL, registered by ALIASED symbol (modules
-   * importing the same export share one global) and initialized at the
-   * top of the importing module's %init by island.import — the engine's
-   * module registry caches, so re-imports are lookups, not re-evaluations.
-   * The runtime graph (the package entry plus everything it reaches)
-   * builds here too; its failures are ordinary diagnostics at the import
-   * site. Type-only imports are free either way: the .d.ts is a type
-   * surface, not code. */
+ * bodies lowered in ANY pass resolve the bindings). In a static build
+ * every value-importing npm import reports the requires-dynamic
+ * diagnostic naming the package — the package's shipped JS has exactly
+ * one execution home, the embedded engine. Under --dynamic each value
+ * binding becomes a jsval GLOBAL, registered by ALIASED symbol (modules
+ * importing the same export share one global) and initialized at the
+ * top of the importing module's %init by island.import — the engine's
+ * module registry caches, so re-imports are lookups, not re-evaluations.
+ * The runtime graph (the package entry plus everything it reaches)
+ * builds here too; its failures are ordinary diagnostics at the import
+ * site. Type-only imports are free either way: the .d.ts is a type
+ * surface, not code. */
 export function collectNpmImports(lowerer, parts) {
     const services = lowerer.frontendServices;
     if (lowerer.dynamic && services === undefined)
@@ -386,9 +424,12 @@ export function collectNpmImports(lowerer, parts) {
                 !stmt.moduleSpecifier.text.startsWith("#")
                 ? stmt.exportClause
                 : null;
-            if (reexport === null && (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)))
+            if (reexport === null &&
+                (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)))
                 continue;
-            const specNode = ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt) ? stmt.moduleSpecifier : undefined;
+            const specNode = ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)
+                ? stmt.moduleSpecifier
+                : undefined;
             if (specNode === undefined || !ts.isStringLiteral(specNode))
                 continue;
             const clause = ts.isImportDeclaration(stmt) ? stmt.importClause : undefined;
@@ -559,18 +600,18 @@ export function collectNpmImports(lowerer, parts) {
     }
 }
 /** Literal dynamic-import collection: every
-   * `import("literal")` in the file — whatever body it sits in — resolves
-   * and embeds AT COLLECTION time, so the per-site lowering later just
-   * looks its key up (the emitted tables are assembled once, here; a
-   * site lowered in any pass finds its module embedded). Resolution
-   * In static builds this records compiled program modules and supported
-   * builtins without constructing an npm graph. Dynamic package-resolution
-   * failures and unshimmed builtins are diagnostics HERE, at the import
-   * expression, exactly like static npm imports at their statements; the
-   * lowering poisons those sites without re-reporting. Non-literal
-   * specifiers are skipped — the lowering owns that fence (the module
-   * graph is a build-time artifact; there is nothing to embed for a
-   * runtime-computed name). */
+ * `import("literal")` in the file — whatever body it sits in — resolves
+ * and embeds AT COLLECTION time, so the per-site lowering later just
+ * looks its key up (the emitted tables are assembled once, here; a
+ * site lowered in any pass finds its module embedded). Resolution
+ * In static builds this records compiled program modules and supported
+ * builtins without constructing an npm graph. Dynamic package-resolution
+ * failures and unshimmed builtins are diagnostics HERE, at the import
+ * expression, exactly like static npm imports at their statements; the
+ * lowering poisons those sites without re-reporting. Non-literal
+ * specifiers are skipped — the lowering owns that fence (the module
+ * graph is a build-time artifact; there is nothing to embed for a
+ * runtime-computed name). */
 function collectDynamicImports(lowerer, builder, sf) {
     ts.walkPreorder(sf, (node) => {
         if (ts.isCallExpression(node) &&
@@ -590,7 +631,10 @@ function collectDynamicImports(lowerer, builder, sf) {
                 // says so. Only non-declaration source files count; a sibling
                 // .d.mts typing shipped JS is the EMBED case, not this one.
                 const modSym = lowerer.checker.getSymbolAtLocation(node.arguments[0]);
-                const ownModule = modSym !== undefined && lowerer.checker.declarationsOf(modSym).some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
+                const ownModule = modSym !== undefined &&
+                    lowerer.checker
+                        .declarationsOf(modSym)
+                        .some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
                 const builtin = canonicalBuiltinModule(spec);
                 const res = ownModule
                     ? { kind: "program-module" }
@@ -613,14 +657,14 @@ function collectDynamicImports(lowerer, builder, sf) {
     });
 }
 /** The createRequire half of the npm chokepoint (--dynamic only): every
-   * `require("bare-literal")` through a createRequire binding — whatever
-   * body it sits in — resolves under Node's "require" condition and
-   * embeds AT COLLECTION time, so the per-site lowering later just looks
-   * its entry up (lowerCreateRequireCall). Builtins, relative documents,
-   * "#" specifiers, --npm-static opt-ins, and Node-refused bare names
-   * are the lowering's own arms — only resolvable installed packages
-   * register here; resolution failures are diagnostics at the call
-   * expression, exactly like static npm imports at their statements. */
+ * `require("bare-literal")` through a createRequire binding — whatever
+ * body it sits in — resolves under Node's "require" condition and
+ * embeds AT COLLECTION time, so the per-site lowering later just looks
+ * its entry up (lowerCreateRequireCall). Builtins, relative documents,
+ * "#" specifiers, --npm-static opt-ins, and Node-refused bare names
+ * are the lowering's own arms — only resolvable installed packages
+ * register here; resolution failures are diagnostics at the call
+ * expression, exactly like static npm imports at their statements. */
 function collectCreateRequires(lowerer, builder, sf) {
     const visit = (node) => {
         if (ts.isCallExpression(node)) {
@@ -654,17 +698,17 @@ function collectCreateRequires(lowerer, builder, sf) {
     visit(sf);
 }
 /** JSON module default imports (`import pkg from "../package.json"`):
-   * the document is DATA known at build time, so the binding bakes into a
-   * record global — the checker's structural type for the module (thanks
-   * to resolveJsonModule) maps to a record shape, the JSON text parses in
-   * the compiler, and comptimeValueToIr turns the value into literal IR
-   * assigned in the importing module's %init prelude (evaluation order:
-   * imports before the importer's body, like npm bindings). Two importers
-   * of the same document share one global (keyed by the ALIASED symbol).
-   * Shapes outside the bakeable surface (null-valued fields, mixed
-   * arrays, ...) report the standard unsupported-type diagnostic at the
-   * import site. Preflight already fenced named/namespace JSON imports
-   * and kept .json files out of the module order. */
+ * the document is DATA known at build time, so the binding bakes into a
+ * record global — the checker's structural type for the module (thanks
+ * to resolveJsonModule) maps to a record shape, the JSON text parses in
+ * the compiler, and comptimeValueToIr turns the value into literal IR
+ * assigned in the importing module's %init prelude (evaluation order:
+ * imports before the importer's body, like npm bindings). Two importers
+ * of the same document share one global (keyed by the ALIASED symbol).
+ * Shapes outside the bakeable surface (null-valued fields, mixed
+ * arrays, ...) report the standard unsupported-type diagnostic at the
+ * import site. Preflight already fenced named/namespace JSON imports
+ * and kept .json files out of the module order. */
 export function collectJsonImports(lowerer, parts) {
     for (const fp of parts) {
         for (const stmt of fp.sf.statements) {
@@ -723,14 +767,14 @@ export function collectJsonImports(lowerer, parts) {
     }
 }
 /** The classes, records, and unions the emitted module carries: exactly
-   * what the lowered functions and globals reference, closed transitively
-   * over record fields, union arms, class field types, base chains, and
-   * constructible descendants and their base chains. Registry entries interned while collecting
-   * signatures nothing reaches stay out — an unreached type leaves no
-   * trace. A referenced class with no registration had its collection
-   * deferred: the reference flushes those diagnostics. Methods whose
-   * bodies were not lowered leave the def's method list, so vtable slots
-   * exist exactly for emitted overrides. */
+ * what the lowered functions and globals reference, closed transitively
+ * over record fields, union arms, class field types, base chains, and
+ * constructible descendants and their base chains. Registry entries interned while collecting
+ * signatures nothing reaches stay out — an unreached type leaves no
+ * trace. A referenced class with no registration had its collection
+ * deferred: the reference flushes those diagnostics. Methods whose
+ * bodies were not lowered leave the def's method list, so vtable slots
+ * exist exactly for emitted overrides. */
 export function moduleArtifacts(lowerer, functions) {
     const valueInstanceOfRoots = new Set();
     const classNames = new Set();
@@ -741,23 +785,30 @@ export function moduleArtifacts(lowerer, functions) {
     const pendingUnions = [];
     const boxedChild = (type, seen = new Set()) => {
         switch (type.kind) {
-            case "child": return true;
+            case "child":
+                return true;
             case "array":
-            case "set": return boxedChild(type.elem, seen);
-            case "promise": return boxedChild(type.inner, seen);
-            case "map": return boxedChild(type.key, seen) || boxedChild(type.value, seen);
-            case "func": return boxedChild(type.ret, seen);
+            case "set":
+                return boxedChild(type.elem, seen);
+            case "promise":
+                return boxedChild(type.inner, seen);
+            case "map":
+                return boxedChild(type.key, seen) || boxedChild(type.value, seen);
+            case "func":
+                return boxedChild(type.ret, seen);
             case "record":
                 if (seen.has(type.shapeId))
                     return false;
                 seen.add(type.shapeId);
-                return lowerer.shapes.get(type.shapeId)?.fields.some((field) => boxedChild(field.type, seen)) ?? false;
+                return (lowerer.shapes.get(type.shapeId)?.fields.some((field) => boxedChild(field.type, seen)) ??
+                    false);
             case "union":
                 if (seen.has(type.unionId))
                     return false;
                 seen.add(type.unionId);
                 return lowerer.unions.get(type.unionId)?.arms.some((arm) => boxedChild(arm, seen)) ?? false;
-            default: return false;
+            default:
+                return false;
         }
     };
     const visitClass = (name) => {
@@ -903,9 +954,7 @@ export function moduleArtifacts(lowerer, functions) {
             pendingClasses.push(name);
         }
     }
-    while (pendingClasses.length > 0 ||
-        pendingShapes.length > 0 ||
-        pendingUnions.length > 0) {
+    while (pendingClasses.length > 0 || pendingShapes.length > 0 || pendingUnions.length > 0) {
         while (pendingShapes.length > 0) {
             // Declared fields AND the index-signature value type: an
             // overflow-valued shape (`{ [key: string]: {script?: string} }`)
@@ -937,6 +986,8 @@ export function moduleArtifacts(lowerer, functions) {
                 visitType(field.type);
             if (info.base)
                 visitClass(info.base.def.name);
+            if (info.def.genericOf)
+                visitClass(info.def.genericOf);
             if (lowerer.inHierarchy(info)) {
                 let root = info;
                 while (root.base)
@@ -987,14 +1038,14 @@ export function moduleArtifacts(lowerer, functions) {
     };
 }
 /** Registers every DIRECT top-level `const`/`let` of a file as a module
-   * global (stable storage: cross-module live bindings, and functions can
-   * reference them without capture). Block-scoped vars inside nested
-   * statements keep their different symbols and stay locals. */
+ * global (stable storage: cross-module live bindings, and functions can
+ * reference them without capture). Block-scoped vars inside nested
+ * statements keep their different symbols and stay locals. */
 /** JS collection failures defer to runtime fences: the registration's
-* diagnostics move off the build (into lowerer.runtimeFences) — the declaring
-* statement re-fails during init lowering and compiles to the
-* runtimeFence trap there, and every use site cascades to its own trap.
-* TypeScript files keep eager collection reports. */
+ * diagnostics move off the build (into lowerer.runtimeFences) — the declaring
+ * statement re-fails during init lowering and compiles to the
+ * runtimeFence trap there, and every use site cascades to its own trap.
+ * TypeScript files keep eager collection reports. */
 function deferJsCollectionDiags(lowerer, sf, diagsBefore) {
     if (!isJsSourceFile(sf))
         return;
@@ -1027,12 +1078,14 @@ function cjsScalarLiteral(e) {
 function checkedGlobalReference(lowerer, expression) {
     if (ts.isIdentifier(expression))
         return lowerer.globalOf(expression)?.type.kind === "dyn";
-    if (!ts.isPropertyAccessExpression(expression) || !ts.isIdentifier(expression.name) || !ts.isIdentifier(expression.expression))
+    if (!ts.isPropertyAccessExpression(expression) ||
+        !ts.isIdentifier(expression.name) ||
+        !ts.isIdentifier(expression.expression))
         return false;
     const root = lowerer.checker.getSymbolAtLocation(expression.expression);
     const namespace = root && lowerer.checker.declarationsOf(root).some(ts.isNamespaceImport);
-    return (namespace || lowerer.cjsLocalModuleBindingOf(expression.expression)) &&
-        lowerer.globalOf(expression.name)?.type.kind === "dyn";
+    return ((namespace || lowerer.cjsLocalModuleBindingOf(expression.expression)) &&
+        lowerer.globalOf(expression.name)?.type.kind === "dyn");
 }
 function jsDynHoldableInitializer(lowerer, init) {
     if (init === undefined)
@@ -1044,15 +1097,18 @@ function jsDynHoldableInitializer(lowerer, init) {
         e = e.expression;
     if (checkedGlobalReference(lowerer, e))
         return true;
-    if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) &&
+    if (ts.isCallExpression(e) &&
+        ts.isPropertyAccessExpression(e.expression) &&
         ["freeze", "seal", "preventExtensions"].includes(e.expression.name.text) &&
-        lowerer.stdlibGlobalMember(e.expression, "Object") !== null && e.arguments[0] &&
+        lowerer.stdlibGlobalMember(e.expression, "Object") !== null &&
+        e.arguments[0] &&
         ts.isArrayLiteralExpression(e.arguments[0]))
         return true;
     // The built-in Array constructor can create an evolving array whose
     // inferred element type has no native mapping. Its checked reference
     // must remain shared with separately declared functions and aliases.
-    if ((ts.isCallExpression(e) || ts.isNewExpression(e)) && lowerer.isStdlibGlobal(e.expression, "Array"))
+    if ((ts.isCallExpression(e) || ts.isNewExpression(e)) &&
+        lowerer.isStdlibGlobal(e.expression, "Array"))
         return true;
     // JavaScript process streams lower to native checked handles even when
     // their declared method overloads prevent a structural type mapping.
@@ -1061,7 +1117,8 @@ function jsDynHoldableInitializer(lowerer, init) {
         const member = lowerer.stdlibGlobalMember(e, "process");
         if (member === "stdin" || member === "stdout" || member === "stderr")
             return true;
-        if (e.name.text === "constructor" && lowerer.checker.getCallSignatures(lowerer.typeOf(e.expression)).length > 0)
+        if (e.name.text === "constructor" &&
+            lowerer.checker.getCallSignatures(lowerer.typeOf(e.expression)).length > 0)
             return true;
     }
     if (e.kind === ts.SyntaxKind.NullKeyword)
@@ -1069,45 +1126,60 @@ function jsDynHoldableInitializer(lowerer, init) {
     if (ts.isIdentifier(e) && e.text === "undefined")
         return true;
     if (ts.isConditionalExpression(e)) {
-        return jsDynHoldableInitializer(lowerer, e.whenTrue) && jsDynHoldableInitializer(lowerer, e.whenFalse);
+        return (jsDynHoldableInitializer(lowerer, e.whenTrue) &&
+            jsDynHoldableInitializer(lowerer, e.whenFalse));
     }
-    if (ts.isBinaryExpression(e) && (e.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
-        e.operatorToken.kind === ts.SyntaxKind.BarBarToken || e.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)) {
+    if (ts.isBinaryExpression(e) &&
+        (e.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+            e.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            e.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)) {
         return jsDynHoldableInitializer(lowerer, e.left) && jsDynHoldableInitializer(lowerer, e.right);
     }
     // A member of a checked module value is itself checked, including a
     // callable whose inferred overloads cannot describe one native ABI.
     if ((ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) &&
-        ts.isIdentifier(e.expression) && lowerer.globalOf(e.expression)?.type.kind === "dyn")
+        ts.isIdentifier(e.expression) &&
+        lowerer.globalOf(e.expression)?.type.kind === "dyn")
         return true;
     if (ts.isPropertyAccessExpression(e)) {
         const member = nsMemberIdentOf(lowerer, e);
-        if (member && (lowerer.globalOf(member)?.type.kind === "dyn" || lowerer.genericFnOf(member)?.implicitParams))
+        if (member &&
+            (lowerer.globalOf(member)?.type.kind === "dyn" || lowerer.genericFnOf(member)?.implicitParams))
             return true;
     }
     // Optional callable reads (for example descriptor?.get) can be held in
     // the same checked slot as a callable. Their nullish arm must remain
     // observable by functions declared outside the module initializer.
-    if (ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e) || ts.isCallExpression(e)) {
+    if (ts.isPropertyAccessExpression(e) ||
+        ts.isElementAccessExpression(e) ||
+        ts.isCallExpression(e)) {
         const fallback = lowerer.mapTypeOf(lowerer.typeOf(e)) ?? dynFallbackType(lowerer, e, lowerer.typeOf(e));
-        if (fallback?.kind === "func" && canBoxFuncIntoDyn(fallback, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+        if (fallback?.kind === "func" &&
+            canBoxFuncIntoDyn(fallback, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
             return true;
         const arms = fallback?.kind === "union" ? lowerer.unions.get(fallback.unionId)?.arms : undefined;
-        if (arms?.some(arm => arm.kind === "func") && arms.every(arm => isUnitType(arm) || (arm.kind === "func" && canBoxFuncIntoDyn(arm, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))))
+        if (arms?.some((arm) => arm.kind === "func") &&
+            arms.every((arm) => isUnitType(arm) ||
+                (arm.kind === "func" &&
+                    canBoxFuncIntoDyn(arm, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))))
             return true;
     }
-    if ((ts.isFunctionExpression(e) || ts.isArrowFunction(e)) && !e.typeParameters?.length && isJsSourceFile(e.getSourceFile()))
+    if ((ts.isFunctionExpression(e) || ts.isArrowFunction(e)) &&
+        !e.typeParameters?.length &&
+        isJsSourceFile(e.getSourceFile()))
         return true;
     if (ts.isIdentifier(e) || ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
         if (ts.isIdentifier(e)) {
             if (lowerer.globalOf(e)?.type.kind === "dyn")
                 return true;
             const signature = lowerer.isTopLevelFnSymbol(e) ? lowerer.fnSigOf(e) : null;
-            if (signature && canBoxFuncIntoDyn(funcTypeFromParamShapes(signature.params, signature.returnType), (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+            if (signature &&
+                canBoxFuncIntoDyn(funcTypeFromParamShapes(signature.params, signature.returnType), (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
                 return true;
         }
         const type = lowerer.mapTypeOf(lowerer.typeOf(e)) ?? dynFallbackType(lowerer, e, lowerer.typeOf(e));
-        if (type?.kind === "func" && canBoxFuncIntoDyn(type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
+        if (type?.kind === "func" &&
+            canBoxFuncIntoDyn(type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)))
             return true;
     }
     if ((ts.isCallExpression(e) || ts.isPropertyAccessExpression(e) || ts.isIdentifier(e)) &&
@@ -1192,9 +1264,11 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 let inner = stmt.expression;
                 while (ts.isParenthesizedExpression(inner))
                     inner = inner.expression;
-                if (ts.isClassExpression(inner) && !isJsSourceFile(sf) &&
+                if (ts.isClassExpression(inner) &&
+                    !isJsSourceFile(sf) &&
                     inner.typeParameters === undefined &&
-                    (decoratorNodesOf(inner).length > 0 || inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
+                    (decoratorNodesOf(inner).length > 0 ||
+                        inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
                     guaranteedDecorationThrow(lowerer, inner) !== null) {
                     continue;
                 }
@@ -1214,7 +1288,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     lowerer.badType(stmt.expression, tsType);
                 // Inferred JavaScript factory exports keep their original value,
                 // including callable objects decorated with Object.assign.
-                if (isJsSourceFile(sf) && ts.isCallExpression(stmt.expression) && type.kind === "record" && lowerer.dynConvertible(type))
+                if (isJsSourceFile(sf) &&
+                    ts.isCallExpression(stmt.expression) &&
+                    type.kind === "record" &&
+                    lowerer.dynConvertible(type))
                     type = DYN;
                 // `export default undefined` — the unit-only union, like any
                 // unit-only binding (`export default null` maps via mapType).
@@ -1253,7 +1330,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // tsgo answers no symbol at the attachment site's NAME (no
                     // expando synthesis); the module symbol's exports table still
                     // names the member — the same identity use sites resolve.
-                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ?? lowerer.cjsModuleExportSymbol(sf, name);
+                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ??
+                        lowerer.cjsModuleExportSymbol(sf, name);
                     if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         return;
                     // JS exports whose strict type has no mapping take the
@@ -1281,7 +1359,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                         lowerer.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
-                                const g = { id: `%g.${tag}%export.${name}`, name, type: vG.type, mutable: false };
+                                const g = {
+                                    id: `%g.${tag}%export.${name}`,
+                                    name,
+                                    type: vG.type,
+                                    mutable: false,
+                                };
                                 lowerer.globalsBySymbol.set(symbol, g);
                                 for (const d of lowerer.checker.declarationsOf(symbol))
                                     lowerer.globalsByDeclNode.set(d, g);
@@ -1358,7 +1441,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         if (factoryValued && t?.kind === "record" && lowerer.dynConvertible(t))
                             t = DYN;
                         if (t && t.kind !== "void") {
-                            const g = { id: `%g.${tag}exports`, name: "exports", type: t, mutable: false };
+                            const g = {
+                                id: `%g.${tag}exports`,
+                                name: "exports",
+                                type: t,
+                                mutable: false,
+                            };
                             lowerer.globalsByDeclNode.set(cjs.expr, g);
                             lowerer.globalsList.push(g);
                         }
@@ -1399,7 +1487,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
             if (ts.isExternalModuleReference(stmt.moduleReference) || stmt.isTypeOnly)
                 continue;
             const aliasSym = lowerer.checker.getSymbolAtLocation(stmt.name);
-            if (!aliasSym || !(aliasSym.flags & ts.SymbolFlags.Alias) || lowerer.globalsBySymbol.has(aliasSym))
+            if (!aliasSym ||
+                !(aliasSym.flags & ts.SymbolFlags.Alias) ||
+                lowerer.globalsBySymbol.has(aliasSym))
                 continue;
             const target = lowerer.checker.getAliasedSymbol(aliasSym);
             const vd = lowerer.checker.valueDeclarationOf(target);
@@ -1450,10 +1540,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
         // require('node:process')` aliases the global process
         // (stdlibGlobalAliasDecl's require form) so reads through the
         // binding lower via the process surface.
-        if (isRequireStatement(stmt) && !(ts.isVariableStatement(stmt) &&
-            stmt.declarationList.declarations.some(decl => isNativeFfiRequire(lowerer, decl.initializer)))) {
-            if (ts.isVariableStatement(stmt) &&
-                (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
+        if (isRequireStatement(stmt) &&
+            !(ts.isVariableStatement(stmt) &&
+                stmt.declarationList.declarations.some((decl) => isNativeFfiRequire(lowerer, decl.initializer)))) {
+            if (ts.isVariableStatement(stmt) && (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
                 for (const decl of stmt.declarationList.declarations) {
                     stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
                 }
@@ -1657,7 +1747,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // statement lowering skips the declaration by the same check. A
             // bad promisify target reports here (recorded once; the statement
             // lowering poisons too, like every collectGlobals failure).
-            if (ts.isIdentifier(decl.name) && decl.initializer && isPromisifyCall(lowerer, decl.initializer)) {
+            if (ts.isIdentifier(decl.name) &&
+                decl.initializer &&
+                isPromisifyCall(lowerer, decl.initializer)) {
                 try {
                     lowerer.registerPromisifiedBuiltinDecl(decl.name, decl.initializer);
                 }
@@ -1728,13 +1820,22 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Checked JavaScript factories can expose inferred callables by
                     // destructuring. Keep each exported binding in module storage so
                     // separately lowered functions see the initialized value.
-                    if (isJsSourceFile(sf) && !ts.isIdentifier(decl.name) && decl.initializer &&
-                        !decl.type && !hasJsTypeAnnotation(decl) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode))) {
+                    if (isJsSourceFile(sf) &&
+                        !ts.isIdentifier(decl.name) &&
+                        decl.initializer &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
-                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
-                                type: DYN, mutable: isLet, source: bindingSource(nameNode),
-                                ...(!isVarDeclared(decl) ? { tdz: true } : {}) };
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                                ...(!isVarDeclared(decl) ? { tdz: true } : {}),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                             if (isVarDeclared(decl))
@@ -1746,16 +1847,25 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // callable ABI. Preserve checked-native values in shared storage;
                     // adapting the loader to (string) would replace its validation.
                     const initializer = decl.initializer ? stripTypeCasts(decl.initializer) : undefined;
-                    if (isJsSourceFile(sf) && nameNode === decl.name && initializer &&
+                    if (isJsSourceFile(sf) &&
+                        nameNode === decl.name &&
+                        initializer &&
                         (isNativeBuiltinValueInitializer(lowerer, initializer) ||
-                            (!decl.type && !hasJsTypeAnnotation(decl) && lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
-                            (!decl.type && !hasJsTypeAnnotation(decl) && checkedGlobalReference(lowerer, initializer)) ||
+                            (!decl.type &&
+                                !hasJsTypeAnnotation(decl) &&
+                                lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
+                            (!decl.type &&
+                                !hasJsTypeAnnotation(decl) &&
+                                checkedGlobalReference(lowerer, initializer)) ||
                             (!lowerer.dynamic && stdlibGlobalNameOf(lowerer, initializer) === "globalThis"))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = {
-                                id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
-                                type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
                                 ...(!isVarDeclared(decl) ? { tdz: true } : {}),
                             };
                             lowerer.globalsBySymbol.set(symbol, g);
@@ -1774,12 +1884,21 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // storage instead of fencing per reference. Identifier
                     // declarations only: a destructured array literal binds its
                     // pieces, not the array.
-                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        decl.initializer !== undefined && ts.isArrayLiteralExpression(decl.initializer)) {
+                    if (isJsSourceFile(sf) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer !== undefined &&
+                        ts.isArrayLiteralExpression(decl.initializer)) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol) {
-                            const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
+                            const g = {
+                                id: `%g.${tag}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                         }
@@ -1789,14 +1908,26 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Methods and computed properties require live checked storage:
                     // symbol identity and a method's receiver cannot be reconstructed
                     // from a copied, inferred record shape.
-                    if (isJsSourceFile(sf) && ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        decl.initializer && ts.isObjectLiteralExpression(decl.initializer) &&
+                    if (isJsSourceFile(sf) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer &&
+                        ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.some((p) => !ts.isSpreadAssignment(p) &&
-                            (ts.isMethodDeclaration(p) || ts.isAccessor(p) || ts.isComputedPropertyName(p.name) ||
-                                ts.isShorthandPropertyAssignment(p) && lowerer.checker.getCallSignatures(lowerer.typeOf(p.name)).length > 0))) {
+                            (ts.isMethodDeclaration(p) ||
+                                ts.isAccessor(p) ||
+                                ts.isComputedPropertyName(p.name) ||
+                                (ts.isShorthandPropertyAssignment(p) &&
+                                    lowerer.checker.getCallSignatures(lowerer.typeOf(p.name)).length > 0)))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
-                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                             if (isVarDeclared(decl))
@@ -1821,21 +1952,31 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Spreads from an existing checked dictionary stay checked too;
                     // copying its entries must not extract nested callable records.
                     if (isJsSourceFile(sf) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        decl.initializer !== undefined && ts.isObjectLiteralExpression(decl.initializer) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer !== undefined &&
+                        ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.every((p) => {
                             if (ts.isSpreadAssignment(p)) {
-                                return ts.isIdentifier(p.expression) && lowerer.globalOf(p.expression)?.type.kind === "dyn";
+                                return (ts.isIdentifier(p.expression) &&
+                                    lowerer.globalOf(p.expression)?.type.kind === "dyn");
                             }
                             if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name))
                                 return false;
                             const mt = lowerer.mapTypeOf(lowerer.typeOf(p.initializer));
-                            return mt === null || mt.kind === "dyn" ||
-                                canConvertToDyn(mt, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id));
+                            return (mt === null ||
+                                mt.kind === "dyn" ||
+                                canConvertToDyn(mt, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id)));
                         })) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
-                            const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
+                            const g = {
+                                id: `%g.${tag}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                         }
@@ -1854,13 +1995,21 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // decl keeps as an %init local) stay OUT: forcing those into
                     // the checked-dynamic tree would trade their working typed representation for
                     // fences.
-                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name &&
+                    if (isJsSourceFile(sf) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
                         jsDynHoldableInitializer(lowerer, decl.initializer) &&
                         dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode))?.kind === "dyn") {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
-                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet, source: bindingSource(nameNode) };
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                             // Mutable dyn globals hold the dyn undefined from module
@@ -1879,13 +2028,23 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // the binding holds the HANDLE — a jsval global, so exports
                     // and separately-declared functions reach the same engine
                     // object.
-                    if (lowerer.dynamic && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        decl.initializer !== undefined && ts.isObjectLiteralExpression(decl.initializer) &&
+                    if (lowerer.dynamic &&
+                        isJsSourceFile(sf) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer !== undefined &&
+                        ts.isObjectLiteralExpression(decl.initializer) &&
                         decl.initializer.properties.some((p) => ts.isGetAccessorDeclaration(p))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
-                            const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: JSVAL, mutable: isLet, source: bindingSource(nameNode) };
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: JSVAL,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
                             lowerer.globalsBySymbol.set(symbol, g);
                             lowerer.globalsList.push(g);
                         }
@@ -1896,23 +2055,37 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // that closure in a checked-value global so class methods and
                     // other module functions see its declaration-position assignment.
                     // A var starts undefined; lexical bindings retain the TDZ guard.
-                    if (isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer &&
+                    if (isJsSourceFile(sf) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode)) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer &&
                         jsDynHoldableInitializer(lowerer, decl.initializer)) {
                         const initializer = decl.initializer;
-                        const member = ts.isPropertyAccessExpression(initializer) ? nsMemberIdentOf(lowerer, initializer) : null;
+                        const member = ts.isPropertyAccessExpression(initializer)
+                            ? nsMemberIdentOf(lowerer, initializer)
+                            : null;
                         const generic = member && lowerer.genericFnOf(member);
-                        const fallback = (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) && !initializer.typeParameters?.length
+                        const fallback = (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) &&
+                            !initializer.typeParameters?.length
                             ? lowerer.lambdaSignature(initializer).funcType
-                            : member && lowerer.globalOf(member)?.type.kind === "dyn" ? DYN
-                                : member && generic?.implicitParams ? lowerer.lowerGenericFnValue(member, generic).type
+                            : member && lowerer.globalOf(member)?.type.kind === "dyn"
+                                ? DYN
+                                : member && generic?.implicitParams
+                                    ? lowerer.lowerGenericFnValue(member, generic).type
                                     : dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode));
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
-                        if (symbol && fallback && (fallback.kind === "dyn" || fallback.kind === "func" || fallback.kind === "union") && lowerer.dynConvertible(fallback)) {
+                        if (symbol &&
+                            fallback &&
+                            (fallback.kind === "dyn" || fallback.kind === "func" || fallback.kind === "union") &&
+                            lowerer.dynConvertible(fallback)) {
                             if (!lowerer.globalsBySymbol.has(symbol)) {
                                 const g = {
-                                    id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text,
-                                    type: DYN, mutable: isLet, source: bindingSource(nameNode),
+                                    id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                    name: nameNode.text,
+                                    type: DYN,
+                                    mutable: isLet,
+                                    source: bindingSource(nameNode),
                                     ...(!isVarDeclared(decl) ? { tdz: true } : {}),
                                 };
                                 lowerer.globalsBySymbol.set(symbol, g);
@@ -1930,37 +2103,63 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // and closures created in the init body capture it normally.
                     // References from separately-declared functions cascade to
                     // their own per-site runtime fences.
-                    const factoryType = !isLet && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
-                        ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer && ts.isNewExpression(decl.initializer)
-                        ? objectFactoryGlobalType(lowerer, decl.initializer) ?? undefined : undefined;
+                    const factoryType = !isLet &&
+                        isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer &&
+                        ts.isNewExpression(decl.initializer)
+                        ? (objectFactoryGlobalType(lowerer, decl.initializer) ?? undefined)
+                        : undefined;
                     // `var p1 = import("./m")` at file scope: the global holds the
                     // island promise/handle — the import expression's only
                     // production — whatever the checker's namespace type mapped to
                     // (lowerVarDecl's rule at module scope; the init body assigns
                     // it).
                     const handleT = ts.isIdentifier(decl.name) && nameNode === decl.name
-                        ? (isNativeProxyInitializer(lowerer, decl.initializer) ? DYN : null) ??
-                            (lowerer.dynamic ? importCallHandleType(decl.initializer) : staticImportNamespaceType(lowerer, decl.initializer)) ??
-                            (lowerer.dynamic ?
-                                // An unchecked-overload call result stores the handle,
-                                // exactly the local rule (uncheckedOverloadHandleCall).
-                                (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
+                        ? ((isNativeProxyInitializer(lowerer, decl.initializer) ? DYN : null) ??
+                            (lowerer.dynamic
+                                ? importCallHandleType(decl.initializer)
+                                : staticImportNamespaceType(lowerer, decl.initializer)) ??
+                            (lowerer.dynamic
+                                ? // An unchecked-overload call result stores the handle,
+                                    // exactly the local rule (uncheckedOverloadHandleCall).
+                                    uncheckedOverloadHandleCall(lowerer, decl.initializer)
+                                        ? JSVAL
+                                        : null
+                                : null))
                         : null;
                     // JavaScript factory results with unmappable annotations still
                     // need shared storage. Unannotated callable unions also use a
                     // checked slot; mappable authored annotations keep their layout.
                     const unannotatedCall = !decl.type && !hasJsTypeAnnotation(decl);
-                    const callSignature = (isJsSourceFile(sf) || unannotatedCall) && decl.initializer && ts.isCallExpression(decl.initializer)
-                        ? lowerer.checker.getResolvedSignature(decl.initializer) : undefined;
+                    const callSignature = (isJsSourceFile(sf) || unannotatedCall) &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer)
+                        ? lowerer.checker.getResolvedSignature(decl.initializer)
+                        : undefined;
                     const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
                     const callType = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile())
-                        ? lowerer.mapTypeOf(lowerer.typeOf(nameNode)) : null;
-                    const inferredJsCall = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile()) &&
-                        (!callType || unannotatedCall && callType.kind === "union" && lowerer.unions.get(callType.unionId)?.arms.some((arm) => arm.kind === "func"));
-                    if (!factoryType && !inferredJsCall && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
+                        ? lowerer.mapTypeOf(lowerer.typeOf(nameNode))
+                        : null;
+                    const inferredJsCall = callDeclaration &&
+                        isJsSourceFile(callDeclaration.getSourceFile()) &&
+                        (!callType ||
+                            (unannotatedCall &&
+                                callType.kind === "union" &&
+                                lowerer.unions.get(callType.unionId)?.arms.some((arm) => arm.kind === "func")));
+                    if (!factoryType &&
+                        !inferredJsCall &&
+                        isJsSourceFile(sf) &&
+                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
                         continue;
                     let type = handleT ?? factoryType ?? (inferredJsCall ? DYN : lowerer.irTypeOf(nameNode));
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer &&
                         (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) &&
                         !decl.initializer.typeParameters?.length) {
                         type = lowerer.lambdaSignature(decl.initializer).funcType;
@@ -1968,8 +2167,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Namespace aliases of inferred helpers carry the helper's
                     // settled callable, whose return can differ from checker inference.
                     // Keep a shared checked slot before any consumer specializes it.
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" &&
-                        decl.initializer && ts.isPropertyAccessExpression(decl.initializer)) {
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        type.kind === "func" &&
+                        decl.initializer &&
+                        ts.isPropertyAccessExpression(decl.initializer)) {
                         const member = nsMemberIdentOf(lowerer, decl.initializer);
                         if (member && lowerer.genericFnOf(member)?.implicitParams)
                             type = DYN;
@@ -1979,24 +2182,43 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                 type = source.type;
                         }
                     }
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
-                        decl.initializer && ts.isCallExpression(decl.initializer) && type.kind === "union") {
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer) &&
+                        type.kind === "union") {
                         const arms = lowerer.unions.get(type.unionId)?.arms;
-                        if (arms?.some((arm) => arm.kind === "record") && arms.every((arm) => isUnitType(arm) || arm.kind === "record"))
+                        if (arms?.some((arm) => arm.kind === "record") &&
+                            arms.every((arm) => isUnitType(arm) || arm.kind === "record"))
                             type = DYN;
                     }
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
-                        ts.isNewExpression(decl.initializer) && lowerer.mapTypeOf(lowerer.typeOf(decl.initializer.expression))?.kind === "dyn" &&
-                        !(ts.isIdentifier(decl.initializer.expression) && lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(decl.initializer.expression))))
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer &&
+                        ts.isNewExpression(decl.initializer) &&
+                        lowerer.mapTypeOf(lowerer.typeOf(decl.initializer.expression))?.kind === "dyn" &&
+                        !(ts.isIdentifier(decl.initializer.expression) &&
+                            lowerer.isStdlibSymbol(lowerer.checker.getSymbolAtLocation(decl.initializer.expression))))
                         type = DYN;
                     // Calls through checked function values retain their object
                     // identity, including symbol keys absent from inferred records.
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
-                        decl.initializer && ts.isCallExpression(decl.initializer) && lowerer.dynConvertible(type)) {
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        type.kind === "record" &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer) &&
+                        lowerer.dynConvertible(type)) {
                         type = DYN;
                     }
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
-                        decl.initializer && ts.isCallExpression(decl.initializer) &&
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        type.kind === "record" &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer) &&
                         ts.isPropertyAccessExpression(decl.initializer.expression) &&
                         lowerer.stdlibGlobalMember(decl.initializer.expression, "Object") === "assign" &&
                         decl.initializer.arguments.some((arg) => ts.isIdentifier(arg) && lowerer.globalOf(arg)?.type.kind === "dyn")) {
@@ -2005,24 +2227,43 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Runtime-arity JavaScript callables can be returned by a
                     // checked factory. Keep that callable boxed instead of asking
                     // a fixed-signature adapter to reconstruct its hidden rest ABI.
-                    if (!decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" && type.rest === true && type.restAbi === undefined)
+                    if (!decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        type.kind === "func" &&
+                        type.rest === true &&
+                        type.restAbi === undefined)
                         type = DYN;
-                    if (isJsSourceFile(sf) && isLet && !decl.type && !hasJsTypeAnnotation(decl) &&
+                    if (isJsSourceFile(sf) &&
+                        isLet &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
                         (type.kind === "object" || jsBindingHasOpenWrites(lowerer, decl)))
                         type = DYN;
                     // JavaScript call results may retain a checked array supplied by
                     // the caller. A typed global here would copy it on extraction.
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "array" &&
-                        decl.initializer && ts.isCallExpression(decl.initializer))
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        type.kind === "array" &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer))
                         type = DYN;
-                    if (!lowerer.dynamic && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
-                        decl.initializer && ts.isNewExpression(decl.initializer) && lowerer.isStdlibGlobal(decl.initializer.expression, "Array") &&
+                    if (!lowerer.dynamic &&
+                        isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer &&
+                        ts.isNewExpression(decl.initializer) &&
+                        lowerer.isStdlibGlobal(decl.initializer.expression, "Array") &&
                         (type.kind !== "array" || type.elem.kind === "dyn"))
                         type = DYN;
                     // Unannotated JavaScript aliases retain an existing native
                     // checked object instead of copying it into an inferred record.
-                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
-                        decl.initializer && ts.isIdentifier(decl.initializer) &&
+                    if (isJsSourceFile(sf) &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer &&
+                        ts.isIdentifier(decl.initializer) &&
                         (type.kind === "record" || type.kind === "func")) {
                         const source = lowerer.globalOf(decl.initializer);
                         if (source?.type.kind === "dyn")
@@ -2030,10 +2271,15 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     }
                     // JavaScript bind inference can leave an artificial tuple-rest
                     // signature. Keep the returned callable's runtime arity intact.
-                    if (isJsSourceFile(sf) && type.kind === "func" && decl.initializer &&
-                        ts.isCallExpression(decl.initializer) && ts.isPropertyAccessExpression(decl.initializer.expression) &&
-                        decl.initializer.expression.name.text === "bind" && lowerer.isStdlibMember(decl.initializer.expression) &&
-                        decl.type === undefined && !hasJsTypeAnnotation(decl)) {
+                    if (isJsSourceFile(sf) &&
+                        type.kind === "func" &&
+                        decl.initializer &&
+                        ts.isCallExpression(decl.initializer) &&
+                        ts.isPropertyAccessExpression(decl.initializer.expression) &&
+                        decl.initializer.expression.name.text === "bind" &&
+                        lowerer.isStdlibMember(decl.initializer.expression) &&
+                        decl.type === undefined &&
+                        !hasJsTypeAnnotation(decl)) {
                         type = DYN;
                     }
                     // An evolving-`any` array's DERIVED file-scope binding under
@@ -2046,18 +2292,21 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // element array (lowerVarDecl's adoption, the file-scope
                     // face). Annotated declarations keep the validated-boundary
                     // fence.
-                    if (lowerer.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name &&
-                        decl.type === undefined && decl.initializer !== undefined &&
-                        type.kind === "array" && type.elem.kind !== "jsval" &&
+                    if (lowerer.dynamic &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.type === undefined &&
+                        decl.initializer !== undefined &&
+                        type.kind === "array" &&
+                        type.elem.kind !== "jsval" &&
                         handleArrayPreservingCall(lowerer, decl.initializer)) {
                         type = arrayOf(JSVAL);
                     }
-                    // `const r: Repo = new MemRepo()` over an all-generic-method
-                    // interface: the binding keeps the initializer's CLASS
-                    // representation (the record shape maps empty and the width
-                    // copy would drop the class the generic-method calls
-                    // monomorphize against) — see genericIfaceBindingKeepsClass.
-                    if (type.kind === "record" && ts.isIdentifier(decl.name) && nameNode === decl.name &&
+                    // An exact class behind a generic interface keeps its native
+                    // representation so generic calls can specialize against its body.
+                    if ((type.kind === "record" || type.kind === "dyn") &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
                         genericIfaceBindingKeepsClass(lowerer, decl, type)) {
                         const initT = lowerer.mapTypeOf(lowerer.typeOf(decl.initializer));
                         if (initT?.kind === "object")
@@ -2073,8 +2322,11 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (lowerer.dynamic && !ts.isIdentifier(decl.name) && decl.initializer !== undefined) {
                         const srcT = lowerer.mapTypeOf(lowerer.typeOf(decl.initializer));
                         const island = srcT !== null &&
-                            (srcT.kind === "jsval" || srcT.kind === "f64" || srcT.kind === "bool" ||
-                                srcT.kind === "string" || isUnitType(srcT));
+                            (srcT.kind === "jsval" ||
+                                srcT.kind === "f64" ||
+                                srcT.kind === "bool" ||
+                                srcT.kind === "string" ||
+                                isUnitType(srcT));
                         if (island && type.kind !== "f64" && type.kind !== "bool" && type.kind !== "string") {
                             type = JSVAL;
                         }
@@ -2096,7 +2348,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // adapter would re-copy at the assignment.
                     if (isJsSourceFile(sf) &&
                         type.kind === "func" &&
-                        (type.ret.kind === "date" || type.ret.kind === "record" && lowerer.dynConvertible(type.ret)) &&
+                        (type.ret.kind === "date" ||
+                            (type.ret.kind === "record" && lowerer.dynConvertible(type.ret))) &&
                         decl.initializer !== undefined &&
                         (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer)) &&
                         decl.initializer.type === undefined &&
@@ -2115,13 +2368,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Module vars hold real undefined until their declaration runs.
                     // Unannotated JS function values need that state too: callers
                     // before the initializer must see undefined and a TypeError.
-                    if (isJsSourceFile(sf) && isVarDeclared(decl) && type.kind === "func" && lowerer.dynConvertible(type))
+                    if (isJsSourceFile(sf) &&
+                        isVarDeclared(decl) &&
+                        type.kind === "func" &&
+                        lowerer.dynConvertible(type))
                         type = DYN;
                     // Codec records keep that state in the ordinary optional union;
                     // lexical codec declarations retain their separate TDZ guard.
-                    const codec = type.kind === "record" && recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null;
+                    const codec = type.kind === "record" &&
+                        recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null;
                     if (codec && isVarDeclared(decl)) {
-                        type = { kind: "union", unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]) };
+                        type = {
+                            kind: "union",
+                            unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]),
+                        };
                     }
                     else if (codec && !decl.initializer) {
                         lowerer.noLowering("uninitialized lexical codec bindings", decl, "initialize let or const TextEncoder/TextDecoder bindings at their declaration");
@@ -2141,7 +2401,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         // A function pointer must not be dereferenced before a lexical
                         // declaration assigns it. The shared pointer TDZ guard handles
                         // these bindings like stored codec records.
-                        ...(((codec || type.kind === "func") && !isVarDeclared(decl)) ? { tdz: true } : {}),
+                        ...((codec || type.kind === "func") && !isVarDeclared(decl)
+                            ? { tdz: true }
+                            : {}),
                     };
                     lowerer.globalsBySymbol.set(symbol, g);
                     lowerer.globalsList.push(g);
@@ -2167,19 +2429,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
     }
 }
 /** True iff this initializer's VALUE is a jsval-element array from a
-   * module global already registered as one (the evolving-`any` binding
-   * under --dynamic): the global itself, or a receiver-TYPE-PRESERVING
-   * array-method call chain over it (filter/slice/splice/concat — each
-   * answers the receiver's own array type). Registration runs in source
-   * order, so the root's global — declared above, TDZ-guaranteed — is
-   * already in the table. */
+ * module global already registered as one (the evolving-`any` binding
+ * under --dynamic): the global itself, or a receiver-TYPE-PRESERVING
+ * array-method call chain over it (filter/slice/splice/concat — each
+ * answers the receiver's own array type). Registration runs in source
+ * order, so the root's global — declared above, TDZ-guaranteed — is
+ * already in the table. */
 function handleArrayPreservingCall(lowerer, e) {
     const PRESERVING = new Set(["filter", "slice", "splice", "concat"]);
     let cur = e;
     for (;;) {
         while (ts.isParenthesizedExpression(cur))
             cur = cur.expression;
-        if (ts.isCallExpression(cur) && ts.isPropertyAccessExpression(cur.expression) &&
+        if (ts.isCallExpression(cur) &&
+            ts.isPropertyAccessExpression(cur.expression) &&
             PRESERVING.has(cur.expression.name.text)) {
             cur = cur.expression.expression;
             continue;
@@ -2193,14 +2456,14 @@ function handleArrayPreservingCall(lowerer, e) {
     return g?.type.kind === "array" && g.type.elem.kind === "jsval";
 }
 /** Registers the entry-init note for a `var` module global: JS hoists
-   * module vars to `undefined` at module entry, so an undefined-armed slot
-   * must hold the interned undefined arm BEFORE the body runs (a function
-   * called above the declaration statement may read it — lowerFileInit
-   * emits the assigns right after the run-once guard). Checked-dynamic
-   * slots hold the dyn undefined the same way (a NULL dyn is a trap, not
-   * a value). Other types need nothing: tsc's flow analysis rejects their
-   * direct early reads, and closure reads share let's documented
-   * zero/NULL divergence window. */
+ * module vars to `undefined` at module entry, so an undefined-armed slot
+ * must hold the interned undefined arm BEFORE the body runs (a function
+ * called above the declaration statement may read it — lowerFileInit
+ * emits the assigns right after the run-once guard). Checked-dynamic
+ * slots hold the dyn undefined the same way (a NULL dyn is a trap, not
+ * a value). Other types need nothing: tsc's flow analysis rejects their
+ * direct early reads, and closure reads share let's documented
+ * zero/NULL divergence window. */
 function noteVarGlobalEntryInit(lowerer, sf, g) {
     // 'any' globals need the entry init exactly like undefined-armed
     // unions: tsc never guards `any` reads, so `var x: any;` is readable
@@ -2215,25 +2478,31 @@ function noteVarGlobalEntryInit(lowerer, sf, g) {
     lowerer.varGlobalEntryInits.set(sf, inits);
 }
 /** The nested half of module-scope `var` hoisting: a `var` inside a
-   * top-level BLOCK (an if arm, a loop body, a try) is module-scoped in
-   * JS — other functions in the file read the same binding — so it must
-   * be a module global like its top-level siblings. Walks a top-level
-   * statement's insides for var-flagged declaration lists (statement and
-   * for/for-in/for-of initializer positions), never descending into
-   * function-likes, classes, or static blocks (each hoists to its own
-   * scope). Registration mirrors the main path's identifier story:
-   * JS-unmappable types register nothing (per-site fences own the
-   * references), everything else gets a mutable global. */
+ * top-level BLOCK (an if arm, a loop body, a try) is module-scoped in
+ * JS — other functions in the file read the same binding — so it must
+ * be a module global like its top-level siblings. Walks a top-level
+ * statement's insides for var-flagged declaration lists (statement and
+ * for/for-in/for-of initializer positions), never descending into
+ * function-likes, classes, or static blocks (each hoists to its own
+ * scope). Registration mirrors the main path's identifier story:
+ * JS-unmappable types register nothing (per-site fences own the
+ * references), everything else gets a mutable global. */
 function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
     const lists = [];
     // Iterative walk (walkPreorder): this sweep sees every non-var top-level
     // statement whole — the binderBinaryExpressionStress bare ~6500-term
     // chain sat within ~50 terms of overflowing the recursive form.
     ts.walkPreorder(stmt, (node) => {
-        if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) ||
-            ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) ||
-            ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) ||
-            ts.isClassStaticBlockDeclaration(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node) ||
+        if (ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node) ||
+            ts.isConstructorDeclaration(node) ||
+            ts.isGetAccessorDeclaration(node) ||
+            ts.isSetAccessorDeclaration(node) ||
+            ts.isClassStaticBlockDeclaration(node) ||
+            ts.isClassDeclaration(node) ||
+            ts.isClassExpression(node) ||
             ts.isModuleDeclaration(node)) {
             return "skip";
         }
@@ -2263,13 +2532,23 @@ function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
                         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
                             type = DYN;
                     }
-                    if (type.kind === "record" && recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null) {
-                        type = { kind: "union", unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]) };
+                    if (type.kind === "record" &&
+                        recordTextCodecClass(lowerer.shapes.get(type.shapeId)) !== null) {
+                        type = {
+                            kind: "union",
+                            unionId: lowerer.unions.intern([type, { kind: "undefinedT" }]),
+                        };
                     }
                     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                     if (!symbol || lowerer.globalsBySymbol.has(symbol))
                         continue;
-                    const g = { id: `%g.${tag}${nameNode.text}`, name: nameNode.text, type, mutable: true, source: bindingSource(nameNode) };
+                    const g = {
+                        id: `%g.${tag}${nameNode.text}`,
+                        name: nameNode.text,
+                        type,
+                        mutable: true,
+                        source: bindingSource(nameNode),
+                    };
                     lowerer.globalsBySymbol.set(symbol, g);
                     lowerer.globalsList.push(g);
                     noteVarGlobalEntryInit(lowerer, sf, g);
@@ -2284,21 +2563,21 @@ function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
     }
 }
 /** The checker's symbol for a module's default export — the symbol a
-   * default import of this module aliases to (getAliasedSymbol), so keying
-   * the default's global by it makes every importer resolve to the same
-   * storage through the ordinary globalOf path. Null for modules without
-   * a default export (or non-module files). */
+ * default import of this module aliases to (getAliasedSymbol), so keying
+ * the default's global by it makes every importer resolve to the same
+ * storage through the ordinary globalOf path. Null for modules without
+ * a default export (or non-module files). */
 export function defaultExportSymbolOf(lowerer, sf) {
     const moduleSym = lowerer.checker.getSymbolAtLocation(sf);
     return moduleSym?.getExports().get(ts.InternalSymbolName.Default) ?? null;
 }
 /** The declaration symbol of a top-level function/class declaration,
-   * covering the one legal NAMELESS form: `export default function () {}` /
-   * `export default class {}`. A named declaration answers through its
-   * name node; the anonymous default IS the module's `default` export
-   * symbol (the binder declares it there), so collection, reachability,
-   * and body lowering all key that one identity — which is also what a
-   * default import's alias chain resolves to. */
+ * covering the one legal NAMELESS form: `export default function () {}` /
+ * `export default class {}`. A named declaration answers through its
+ * name node; the anonymous default IS the module's `default` export
+ * symbol (the binder declares it there), so collection, reachability,
+ * and body lowering all key that one identity — which is also what a
+ * default import's alias chain resolves to. */
 export function declSymbolOf(lowerer, decl) {
     if (decl.name)
         return lowerer.checker.getSymbolAtLocation(decl.name);
@@ -2310,18 +2589,18 @@ export function declSymbolOf(lowerer, decl) {
     return sym ?? undefined;
 }
 /** `export default <expr>` in a module's init body: the first (and only)
-   * assignment of the pre-registered `default` global — evaluated at the
-   * statement's source position, exactly where Node runs it (Node's
-   * expression defaults snapshot exactly once, here). ENTITY-NAME defaults
-   * of immutable targets are alias plumbing with no storage of their own:
-   * the statement lowers to nothing — importers' alias-resolved reads
-   * equal the snapshot. MUTABLE entity-name defaults registered snapshot
-   * storage in collection and assign it here like any expression default
-   * (the identifier read takes the let's value at this statement's
-   * position — Node's snapshot). A NON-alias default whose type had no
-   * registration (collection reported the blocker) re-lowers the
-   * expression so the expression's OWN diagnostic wins when it has one,
-   * then poisons. */
+ * assignment of the pre-registered `default` global — evaluated at the
+ * statement's source position, exactly where Node runs it (Node's
+ * expression defaults snapshot exactly once, here). ENTITY-NAME defaults
+ * of immutable targets are alias plumbing with no storage of their own:
+ * the statement lowers to nothing — importers' alias-resolved reads
+ * equal the snapshot. MUTABLE entity-name defaults registered snapshot
+ * storage in collection and assign it here like any expression default
+ * (the identifier read takes the let's value at this statement's
+ * position — Node's snapshot). A NON-alias default whose type had no
+ * registration (collection reported the blocker) re-lowers the
+ * expression so the expression's OWN diagnostic wins when it has one,
+ * then poisons. */
 export function lowerDefaultExport(lowerer, stmt) {
     const symbol = defaultExportSymbolOf(lowerer, stmt.getSourceFile());
     if (symbol && symbol.flags & ts.SymbolFlags.Alias && !lowerer.globalsBySymbol.has(symbol))
@@ -2335,9 +2614,11 @@ export function lowerDefaultExport(lowerer, stmt) {
             let inner = stmt.expression;
             while (ts.isParenthesizedExpression(inner))
                 inner = inner.expression;
-            if (ts.isClassExpression(inner) && !isJsSourceFile(stmt.getSourceFile()) &&
+            if (ts.isClassExpression(inner) &&
+                !isJsSourceFile(stmt.getSourceFile()) &&
                 inner.typeParameters === undefined &&
-                (decoratorNodesOf(inner).length > 0 || inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
+                (decoratorNodesOf(inner).length > 0 ||
+                    inner.members.some((m) => decoratorNodesOf(m).length > 0)) &&
                 guaranteedDecorationThrow(lowerer, inner) !== null) {
                 return { kind: "exprStmt", expr: lowerer.lowerExpr(stmt.expression), loc: locOf(stmt) };
             }
@@ -2349,19 +2630,19 @@ export function lowerDefaultExport(lowerer, stmt) {
     return { kind: "assign", localId: g.id, value, loc: locOf(stmt) };
 }
 /** One file's top-level statements as its init function — RUN-ONCE like a
-   * Node module body: non-entry inits open with a guard flag test (already
-   * ran → return) and set the flag before anything else, so every caller —
-   * hoisted import headers, inline require statements, diamonds, cache-hit
-   * re-requires — gets Node's module-cache semantics from the same call.
-   * After the guard comes the file's HOISTED module-edge header: one
-   * guarded %init call per imported user module and the island loads for
-   * npm imports, in import order (Node evaluates every imported module
-   * before the importer's body — depth-first postorder falls out of the
-   * nesting). CommonJS requires are NOT in the header: Node runs them at
-   * their statements, so the statement lowering emits their %init calls
-   * inline in the body. JSON-import bindings (pure data) load next; then
-   * the body. Top-level var statements assign the pre-registered globals
-   * instead of declaring locals. */
+ * Node module body: non-entry inits open with a guard flag test (already
+ * ran → return) and set the flag before anything else, so every caller —
+ * hoisted import headers, inline require statements, diamonds, cache-hit
+ * re-requires — gets Node's module-cache semantics from the same call.
+ * After the guard comes the file's HOISTED module-edge header: one
+ * guarded %init call per imported user module and the island loads for
+ * npm imports, in import order (Node evaluates every imported module
+ * before the importer's body — depth-first postorder falls out of the
+ * nesting). CommonJS requires are NOT in the header: Node runs them at
+ * their statements, so the statement lowering emits their %init calls
+ * inline in the body. JSON-import bindings (pure data) load next; then
+ * the body. Top-level var statements assign the pre-registered globals
+ * instead of declaring locals. */
 export function lowerFileInit(lowerer, sf, stmts, name) {
     const isAsync = lowerer.asyncInitFiles.has(sf);
     const ctx = newFnCtx(false, null, null, VOID);
@@ -2519,8 +2800,16 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // that evaluates them. MIXIN instantiations join by their CALL
         // SITE's position instead (below) — their inner class node may
         // even live in another file.
-        c.decl && ts.isClassDeclaration(c.decl) && !c.mixinInstance && c.decl.getSourceFile() === sf &&
-            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.runtimeStatics !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
+        c.decl &&
+            ts.isClassDeclaration(c.decl) &&
+            !c.mixinInstance &&
+            c.decl.getSourceFile() === sf &&
+            (c.callableBase !== undefined ||
+                c.def.baseValueGlobal !== undefined ||
+                c.runtimeStatics !== undefined ||
+                c.staticFields.length > 0 ||
+                (c.staticBlocks?.length ?? 0) > 0 ||
+                c.classDecorators !== undefined))
             .map((c) => ({ pos: c.decl.getStart(), info: c }));
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the
@@ -2581,12 +2870,14 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                         loc: loc0,
                     },
                     ...(guardId !== undefined
-                        ? [{
+                        ? [
+                            {
                                 kind: "assign",
                                 localId: guardId,
                                 value: { kind: "boolLit", value: false, type: BOOL, loc: loc0 },
                                 loc: loc0,
-                            }]
+                            },
+                        ]
                         : []),
                     { kind: "rethrow", localId: catchLocal.id, loc: loc0 },
                 ],
@@ -2615,15 +2906,15 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
     }
 }
 /** %main is just the entry's %init call: Node's whole module evaluation
-   * order lives in the init functions themselves — each file's hoisted
-   * import header runs its dependencies first (depth-first postorder by
-   * nesting), CommonJS require statements call dependency inits inline in
-   * their bodies, and the run-once guards turn every revisit (diamonds,
-   * re-imports, re-requires) into a cache hit. */
+ * order lives in the init functions themselves — each file's hoisted
+ * import header runs its dependencies first (depth-first postorder by
+ * nesting), CommonJS require statements call dependency inits inline in
+ * their bodies, and the run-once guards turn every revisit (diamonds,
+ * re-imports, re-requires) into a cache hit. */
 export function buildMain(lowerer) {
     const loc = { file: lowerer.entry.fileName, start: 0, end: 0 };
     const body = [...cjsModuleRegistryPrelude(lowerer, loc)];
-    const roots = [lowerer.entry, ...lowerer.forkTargets];
+    const roots = [lowerer.entry, ...lowerer.forkTargets, ...lowerer.workerTargets];
     const isAsync = roots.some((root) => lowerer.asyncInitFiles.has(root));
     const callRoot = (root) => {
         const init = lowerer.initNameOf.get(root);
@@ -2637,11 +2928,13 @@ export function buildMain(lowerer) {
             type: rootAsync ? { kind: "promise", inner: VOID } : VOID,
             loc,
         };
-        return [{
+        return [
+            {
                 kind: "exprStmt",
                 expr: rootAsync ? { kind: "awaitExpr", value: call, type: VOID, loc } : call,
                 loc,
-            }];
+            },
+        ];
     };
     const locals = [];
     if (lowerer.forkTargets.length === 0) {
@@ -2665,7 +2958,8 @@ export function buildMain(lowerer) {
         const selector = () => ({ kind: "varRef", localId: targetId, type: F64, loc });
         let workerBranch = null;
         for (let id = lowerer.forkTargets.length - 1; id >= 0; id--) {
-            workerBranch = [{
+            workerBranch = [
+                {
                     kind: "if",
                     cond: {
                         kind: "bin",
@@ -2678,7 +2972,8 @@ export function buildMain(lowerer) {
                     then: callRoot(lowerer.forkTargets[id]),
                     else_: workerBranch,
                     loc,
-                }];
+                },
+            ];
         }
         body.push({
             kind: "if",
@@ -2695,6 +2990,35 @@ export function buildMain(lowerer) {
             loc,
         });
     }
+    if (lowerer.workerTargets.length > 0) {
+        const mainBody = body.splice(0);
+        let workerBody = null;
+        for (let id = lowerer.workerTargets.length - 1; id >= 0; id--) {
+            workerBody = [
+                {
+                    kind: "if",
+                    cond: {
+                        kind: "bin",
+                        op: "===",
+                        left: { kind: "libCall", fn: "worker.root", args: [], type: F64, loc },
+                        right: { kind: "numLit", value: id, type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    then: callRoot(lowerer.workerTargets[id]),
+                    else_: workerBody,
+                    loc,
+                },
+            ];
+        }
+        body.push({
+            kind: "if",
+            cond: { kind: "libCall", fn: "worker.isMainThread", args: [], type: BOOL, loc },
+            then: mainBody,
+            else_: [...cjsModuleRegistryPrelude(lowerer, loc), ...(workerBody ?? [])],
+            loc,
+        });
+    }
     // Node's startup refusal (a resolution the graph carries that Node
     // rejects — preflight's Node-order resolution walk — or a module-LINK
     // SyntaxError from either named-import checker): the graph is refused
@@ -2710,7 +3034,9 @@ export function buildMain(lowerer) {
             value: {
                 kind: "libCall",
                 fn: "error.new",
-                args: [{ kind: "strLit", value: lowerer.startupCrash.message, type: STRING, loc: crashLoc }],
+                args: [
+                    { kind: "strLit", value: lowerer.startupCrash.message, type: STRING, loc: crashLoc },
+                ],
                 type: { kind: "object", className: lowerer.startupCrash.className },
                 loc: crashLoc,
             },