@scriptc/compiler 0.0.34 → 0.0.36

package/dist/frontend/lowering/lowerer.js

@@ -1,3 +1,4 @@
+import { InternalCompilerError } from "../../errors.js";
 /* AST + checker → IR.
  *
  * Invariants:
@@ -13,21 +14,22 @@
  *   ("x.0", "x.1" for shadowing); the IR is scope-flat.
  */
 import { resolve } from "node:path";
-import { isRelativeSpecifier, tsgoPath } from "../shared.js";
+import { tsgoPath } from "../dts-paths.js";
+import { isRelativeSpecifier } from "../workspace-registry.js";
 import * as ts from "../ts7/adapter.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
-import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
+import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.js";
 import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
-import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerFfiCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction, validateFfiImports } from "./lower-calls.js";
+import { bindingNeverReassigned, bodyReadsArguments, implicitMonoFile, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerFfiCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction, validateFfiImports } from "./lower-calls.js";
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
-import { lowerEmitOverrideSpec } from "./lower-emitter.js";
+import { lowerEmitOverrideSpec } from "./lower-event-emitter.js";
 import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerCryptoModuleCall, lowerFsConstantsProperty, lowerBuiltinConstantsProperty, builtinConstantBindingOf, builtinConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall, textCodecBindingClassOf } from "./lower-builtins.js";
 import { fenceFetchObjectAssignment, fenceFetchObjectBinding, fenceStaticAbortControllerMemberRead, fenceStaticHeadersIteration, fenceStaticHeadersMember, fenceStaticReadableStreamMember, fenceStaticResponseMember, fenceUnsupportedFetchConstructorMember, isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerAbortControllerNew, lowerDynamicHeadersIteratorCall, lowerDynamicHeadersSpread, lowerDynamicImportCall, lowerFetchCall, lowerFetchElementMethodCall, lowerResponseNew, lowerStaticFetchCompanionCall, lowerStaticAbortControllerCall, lowerStaticAbortSignalListenerCall, lowerStaticReadableStreamCancelCall, lowerStaticReadableStreamControllerCall, lowerStaticReadableStreamNew, lowerStaticReadableStreamReaderCall, lowerStaticResponseCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty, lowerTlsRootCertificates } from "./lower-server.js";
@@ -40,6 +42,7 @@ import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, pr
 import { lowerDynObjectLiteral, lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
+import { numLit, varRef } from "../../ir/build.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
  * function can never collide with it (mangling is injective per prefix). */
 export const ENTRY_NAME = "%main";
@@ -56,7 +59,7 @@ export function own(table, key) {
 /** Sentinel binding key for `this` (which has no ts.Symbol): a stable
  * object identity used in the same scope/capture maps as real symbols, so
  * arrows capturing `this` ride the ordinary capture machinery. */
-export const THIS_BINDING = { escapedName: "%this" };
+const THIS_BINDING = { escapedName: "%this" };
 export function newFnCtx(lifted, selfSymbol, selfType, returnType) {
     return {
         locals: [],
@@ -76,7 +79,7 @@ export function newFnCtx(lifted, selfSymbol, selfType, returnType) {
  * visit; descending would attribute a nested island statement to every
  * enclosing construct too). The top-level statement object itself is
  * always visited. */
-export const IR_STMT_KINDS = new Set([
+const IR_STMT_KINDS = new Set([
     "varDecl", "assign", "exprStmt", "if", "while", "doWhile", "switch",
     "arraySet", "forOf", "return", "fieldSet", "recordSet", "break",
     "continue", "block", "tryCatch", "throw", "rethrow", "runtimeFence",
@@ -308,8 +311,8 @@ export function importCallHandleType(expr) {
  * Ambient (.d.ts) declarations never reach this: they have no compiled
  * implementation, so their calls lower through the island/builtin paths
  * whose validated exits keep the checker-trust trap. */
-export function uncheckedOverloadHandleCall(L, expr) {
-    if (!L.dynamic || !expr)
+export function uncheckedOverloadHandleCall(lowerer, expr) {
+    if (!lowerer.dynamic || !expr)
         return false;
     let e = expr;
     while (ts.isParenthesizedExpression(e))
@@ -319,25 +322,25 @@ export function uncheckedOverloadHandleCall(L, expr) {
     // overload of an any-returning implementation stores the handle.
     if (!ts.isCallExpression(e) && !ts.isTaggedTemplateExpression(e))
         return false;
-    const rsig = L.checker.getResolvedSignature(e);
-    const rdecl = rsig ? L.checker.signatureDeclaration(rsig) : undefined;
+    const rsig = lowerer.checker.getResolvedSignature(e);
+    const rdecl = rsig ? lowerer.checker.signatureDeclaration(rsig) : undefined;
     if (!rsig || !rdecl)
         return false;
     if (!(ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) || rdecl.body)
         return false;
     const name = rdecl.name;
-    const symbol = name ? L.checker.getSymbolAtLocation(name) : undefined;
+    const symbol = name ? lowerer.checker.getSymbolAtLocation(name) : undefined;
     if (!symbol)
         return false;
-    const impl = L.checker
+    const impl = lowerer.checker
         .declarationsOf(symbol)
         .find((d) => (ts.isFunctionDeclaration(d) || ts.isMethodDeclaration(d)) && d.body !== undefined);
     if (!impl)
         return false;
-    const implSig = L.checker.getSignatureFromDeclaration(impl);
+    const implSig = lowerer.checker.getSignatureFromDeclaration(impl);
     if (!implSig)
         return false;
-    return L.mapTypeOf(L.checker.getReturnTypeOfSignature(implSig))?.kind === "jsval";
+    return lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(implSig))?.kind === "jsval";
 }
 /** The JavaScript declaration fallback for unmappable binding types (see
  * irTypeOf): `any` and every other inference residue is the checked-
@@ -356,16 +359,16 @@ export function uncheckedOverloadHandleCall(L, expr) {
  * checked-dynamic fallbacks apply, the pre-never-mapping behavior. Bare
  * `never` at the ROOT stays out (`for (const v of [])`'s loop var — the
  * dead read the f64 mapping is FOR). */
-export function neverTaintedJsType(L, node, t) {
+export function neverTaintedJsType(lowerer, node, t) {
     if (!isJsSourceFile(node.getSourceFile()))
         return false;
     const walk = (x, depth) => {
         if (depth === 0)
             return false;
         if (x.isUnionType())
-            return x.getTypes().some((a) => walk(a, depth - 1));
-        if (L.checker.isArrayType(x) || L.checker.isTupleType(x)) {
-            return L.checker
+            return ts.constituentTypes(x).some((a) => walk(a, depth - 1));
+        if (lowerer.checker.isArrayType(x) || lowerer.checker.isTupleType(x)) {
+            return lowerer.checker
                 .getTypeArguments(x)
                 .some((a) => (a.flags & ts.TypeFlags.Never) !== 0 || walk(a, depth - 1));
         }
@@ -414,10 +417,10 @@ export function nodeThrowExpr(kind, code, message, type, loc) {
  * (scr_throw_lowering_fence). The diagnostic joins the runtime-fence
  * ledger exactly like a deferred statement fence — nothing silently
  * drops off the coverage report. */
-export function ladderFenceExpr(L, surface, node, hint) {
+export function ladderFenceExpr(lowerer, surface, node, hint) {
     const loc = locOf(node);
     const d = noLoweringDiag(surface, loc, hint);
-    L.runtimeFences.push(d);
+    lowerer.runtimeFences.push(d);
     const sf = node.getSourceFile();
     const pos = ts.getLineAndCharacterOfPosition(sf, loc.start);
     return {
@@ -450,7 +453,7 @@ export function ladderFenceExpr(L, surface, node, hint) {
  * this fallback for `any` (mapType answers jsval first).
  *
  * Null for void (no value exists to represent). */
-export function dynFallbackType(L, node, t) {
+export function dynFallbackType(lowerer, node, t) {
     if (t.flags & ts.TypeFlags.Void)
         return null;
     if (!isJsSourceFile(node.getSourceFile())) {
@@ -459,13 +462,13 @@ export function dynFallbackType(L, node, t) {
         // TS single-call-signature function types: per-piece fallback, but
         // ONLY `any` pieces fall to dyn — any other unmappable piece keeps
         // the whole type's own fence.
-        return anyPiecedFuncType(L, node, t);
+        return anyPiecedFuncType(lowerer, node, t);
     }
-    if (L.checker.isArrayType(t)) {
-        const elem = L.checker.getTypeArguments(t)[0];
+    if (lowerer.checker.isArrayType(t)) {
+        const elem = lowerer.checker.getTypeArguments(t)[0];
         const elemTainted = elem !== undefined &&
-            ((elem.flags & ts.TypeFlags.Never) !== 0 || neverTaintedJsType(L, node, elem));
-        const mappedElem = elem !== undefined && !elemTainted ? L.mapTypeOf(elem) : null;
+            ((elem.flags & ts.TypeFlags.Never) !== 0 || neverTaintedJsType(lowerer, node, elem));
+        const mappedElem = elem !== undefined && !elemTainted ? lowerer.mapTypeOf(elem) : null;
         // A mappable element keeps the static array; an unmappable one makes
         // the WHOLE value dyn (the checked-dynamic tree has real arrays — length/index/push
         // read through the keyed-dyn paths; dyn-element STATIC arrays have no
@@ -482,14 +485,14 @@ export function dynFallbackType(L, node, t) {
     // construct signatures, overloads, and function-with-properties shapes
     // stay out (the whole value falls to dyn below, where every reached
     // use meets its own fence or boxes as-is).
-    const sig = pureSingleCallSignatureOf(L, t);
+    const sig = pureSingleCallSignatureOf(lowerer, t);
     if (sig) {
         const params = sig.getParameters().map((p) => {
-            const pt = L.checker.getTypeOfSymbolAtLocation(p, node);
-            return L.mapTypeOf(pt) ?? DYN;
+            const pt = lowerer.checker.getTypeOfSymbolAtLocation(p, node);
+            return lowerer.mapTypeOf(pt) ?? DYN;
         });
-        const retT = L.checker.getReturnTypeOfSignature(sig);
-        const ret = retT.flags & ts.TypeFlags.Void ? VOID : L.mapTypeOf(retT) ?? DYN;
+        const retT = lowerer.checker.getReturnTypeOfSignature(sig);
+        const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
         return { kind: "func", params, ret };
     }
     return DYN;
@@ -498,23 +501,23 @@ export function dynFallbackType(L, node, t) {
  * properties, no construct signatures, no type parameters, no rest params
  * (declared or synthesized from an `arguments` read). Null for every
  * other shape. The structural gate both dynFallbackType arms share. */
-function pureSingleCallSignatureOf(L, t) {
+function pureSingleCallSignatureOf(lowerer, t) {
     if (!(t.flags & ts.TypeFlags.Object))
         return null;
-    const sigs = L.checker.getCallSignatures(t);
+    const sigs = lowerer.checker.getCallSignatures(t);
     if (sigs.length === 1 &&
-        L.checker.getPropertiesOfType(t).length === 0 &&
-        L.checker.getConstructSignatures(t).length === 0 &&
+        lowerer.checker.getPropertiesOfType(t).length === 0 &&
+        lowerer.checker.getConstructSignatures(t).length === 0 &&
         sigs[0].getTypeParameters().length === 0 &&
         sigs[0].getParameters().every((p) => {
-            const pDecl = L.checker.valueDeclarationOf(p);
+            const pDecl = lowerer.checker.valueDeclarationOf(p);
             return !pDecl || !ts.isParameter(pDecl) || pDecl.dotDotDotToken === undefined;
         }) &&
         // A SYNTHESIZED rest param (tsc's `arguments` inference — no
         // valueDeclaration to carry the dotDotDot): param-count mismatch
         // against the signature's declaration; the whole value stays dyn.
         (() => {
-            const sigDecl = L.checker.signatureDeclaration(sigs[0]);
+            const sigDecl = lowerer.checker.signatureDeclaration(sigs[0]);
             const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters : undefined;
             if (declParams !== undefined && declParams.length !== sigs[0].getParameters().length)
                 return false;
@@ -534,21 +537,21 @@ function pureSingleCallSignatureOf(L, t) {
  * irTypeOf fallback, so the binding type and the closure type agree).
  * A piece that fails to map for any other reason answers null — the
  * whole type keeps its own diagnostic. */
-function anyPiecedFuncType(L, node, t) {
-    const sig = pureSingleCallSignatureOf(L, t);
+function anyPiecedFuncType(lowerer, node, t) {
+    const sig = pureSingleCallSignatureOf(lowerer, t);
     if (!sig)
         return null;
     const params = [];
     for (const p of sig.getParameters()) {
-        const pt = L.checker.getTypeOfSymbolAtLocation(p, node);
-        const mapped = L.mapTypeOf(pt) ?? (pt.flags & ts.TypeFlags.Any ? DYN : null);
+        const pt = lowerer.checker.getTypeOfSymbolAtLocation(p, node);
+        const mapped = lowerer.mapTypeOf(pt) ?? (pt.flags & ts.TypeFlags.Any ? DYN : null);
         if (!mapped || mapped.kind === "void")
             return null;
         params.push(mapped);
     }
-    const retT = L.checker.getReturnTypeOfSignature(sig);
+    const retT = lowerer.checker.getReturnTypeOfSignature(sig);
     const ret = retT.flags & (ts.TypeFlags.Void | ts.TypeFlags.Never) ? VOID
-        : L.mapTypeOf(retT) ?? (retT.flags & ts.TypeFlags.Any ? DYN : null);
+        : lowerer.mapTypeOf(retT) ?? (retT.flags & ts.TypeFlags.Any ? DYN : null);
     if (!ret)
         return null;
     return { kind: "func", params, ret };
@@ -863,7 +866,7 @@ export class Lowerer {
      * Reachability lowers inits before the declarations they discover, so
      * these rebuild after the worklist restores historical shape metadata. */
     shapeOrderHelperFinalizers = [];
-    /** Emit-override specializations (`%C.emit:<event>` — lower-emitter.ts's
+    /** Emit-override specializations (`%C.emit:<event>` — lower-event-emitter.ts's
      * emit-overrides block): interned names, the drive-loop queue, and the
      * currently-lowering specialization's context (the super-forward
      * interception reads it). */
@@ -1130,7 +1133,7 @@ export class Lowerer {
     get ctx() {
         const top = this.fnStack[this.fnStack.length - 1];
         if (!top)
-            throw new Error("lowerer bug: no active function context");
+            throw new InternalCompilerError("lowerer bug: no active function context");
         return top;
     }
     get scopes() {
@@ -1377,6 +1380,31 @@ export class Lowerer {
         this.flushDeferred(symbol);
         return symbol;
     }
+    /** Whether this exact direct call belongs to a manifest-validated native
+     * binding. Declaration classification uses this as a probe before normal
+     * expression lowering: resolving must not flush deferred diagnostics or
+     * trigger the merged-namespace fence just because it is asking ownership.
+     * Call lowering remains the authority for every ABI and call-shape
+     * diagnostic once this answers true. */
+    ownsFfiCall(expr) {
+        if (!ts.isIdentifier(expr.expression))
+            return false;
+        const binding = this.ffiImportsByName.get(expr.expression.text);
+        if (binding === undefined || this.ffiBindingSymbols === null)
+            return false;
+        const validSymbols = this.ffiBindingSymbols.get(binding.name);
+        if (validSymbols === undefined)
+            return false;
+        const wasCollecting = this.collecting;
+        this.collecting = true;
+        try {
+            const symbol = this.resolveValueSymbol(expr.expression);
+            return symbol !== null && validSymbols.has(symbol);
+        }
+        finally {
+            this.collecting = wasCollecting;
+        }
+    }
     /** The configured external host module owning an expression's runtime
      * value, or null. Alias chains are followed to their declaration file so
      * direct imports and local re-export facades classify identically. Type
@@ -1985,6 +2013,16 @@ export class Lowerer {
     }
     run() {
         const parts = this.splitFiles();
+        // The coverage remainder deliberately visits every body that reachable
+        // emit skipped. Those files are already phase-managed, so an ordinary
+        // checker miss would stay a one-node IPC query instead of falling back
+        // to the facade's whole-file batch. Coverage has no dead-body boundary
+        // to preserve: prime each complete file now, reusing the answers the
+        // reachable pass already memoized and batching only the cold remainder.
+        if (this.remainder) {
+            for (const fp of parts)
+                this.checker.prefetchSourceFile(fp.sf);
+        }
         this.collectProgram(parts);
         // Decorated classes analyze AFTER the whole collection pass: a
         // decorator's return type may name a subclass declared below the
@@ -2339,6 +2377,23 @@ export class Lowerer {
      * themselves. */
     emitReachable(extraRoots) {
         const parts = this.splitFiles();
+        // Direct lowering callers do not necessarily run program preflight.
+        // Establish the same managed header/top-level batch here before
+        // collection, while the production path simply finds warm memos.
+        this.checker.prefetchSourceFileStructures(parts.map((fp) => fp.sf));
+        // Signature collection may read the initializer type of a default whose
+        // body type still admits undefined (for example `value =
+        // process.env.VALUE`). The expression executes only when reached, but
+        // that type query is mandatory now; batch hot defaults across ordinary
+        // declarations before collectProgram visits their signatures.
+        this.checker.prefetchCollectionTypes(parts.flatMap((fp) => fp.fnDecls
+            .filter((decl) => decl.body !== undefined && decl.typeParameters === undefined)
+            .flatMap((decl) => decl.parameters.flatMap((param) => param.initializer ? [param.initializer] : []))));
+        // JavaScript class shapes are partly declared by constructor-body
+        // assignments. Batch those collection-time queries across declarations
+        // before collectProgram visits them one by one; reached body lowering
+        // will reuse the same answers later.
+        this.prefetchClassCollection(parts.flatMap((fp) => fp.classDecls));
         this.collectProgram(parts);
         // Decorated classes analyze post-collection here too: the %init seeds
         // lower the decoration calls, whose edges (decorator bodies, construct
@@ -2350,6 +2405,14 @@ export class Lowerer {
         // retained-function keys and are deterministic by construction
         // (qualified declaration names).
         const units = new Map();
+        const bodyRoots = (...roots) => roots.filter((root) => root !== undefined && root !== null);
+        const functionRoots = (decl) => bodyRoots(...decl.parameters.map((param) => param.initializer), decl.body);
+        const classCtorRoots = (info) => bodyRoots(...(info.ctor?.parameters ?? []).map((param) => param.initializer), info.ctor?.body, ...info.fieldOrder.map((field) => field.initializer));
+        const classMemberRoots = (info) => [
+            ...classCtorRoots(info),
+            ...[...this.classMethodMembers(info)].flatMap(({ member }) => functionRoots(member)),
+            ...[...(info.staticMethods?.values() ?? [])].flatMap(({ member }) => functionRoots(member)),
+        ];
         let unitOrder = 0;
         for (const fp of parts) {
             for (const decl of fp.fnDecls) {
@@ -2362,8 +2425,13 @@ export class Lowerer {
                 if (!declSymbol || this.genericFnsBySymbol.has(declSymbol))
                     continue;
                 const sig = this.fnSigsBySymbol.get(declSymbol);
-                if (sig)
-                    units.set(sig.name, { order: unitOrder++, lower: () => this.lowerFunction(decl) });
+                if (sig) {
+                    units.set(sig.name, {
+                        order: unitOrder++,
+                        roots: functionRoots(decl),
+                        lower: () => this.lowerFunction(decl),
+                    });
+                }
             }
         }
         for (const info of this.classes.values()) {
@@ -2378,16 +2446,32 @@ export class Lowerer {
             // A FAMILY has no constructor function and no instance members —
             // only its statics are units.
             if (!info.generic) {
-                units.set(`%${cName}.constructor`, { order: unitOrder++, lower: () => this.lowerClassCtor(info) });
+                units.set(`%${cName}.constructor`, {
+                    order: unitOrder++,
+                    roots: classCtorRoots(info),
+                    lower: () => this.lowerClassCtor(info),
+                });
                 for (const { mName, member } of this.classMethodMembers(info)) {
-                    units.set(`%${cName}.${mName}`, { order: unitOrder++, lower: () => this.lowerClassMethodMember(info, member) });
+                    units.set(`%${cName}.${mName}`, {
+                        order: unitOrder++,
+                        roots: functionRoots(member),
+                        lower: () => this.lowerClassMethodMember(info, member),
+                    });
                 }
                 for (const prop of info.throwingSetters) {
-                    units.set(`%${cName}.set:${prop}`, { order: unitOrder++, lower: () => this.throwingSetterFn(info, prop) });
+                    units.set(`%${cName}.set:${prop}`, {
+                        order: unitOrder++,
+                        roots: [],
+                        lower: () => this.throwingSetterFn(info, prop),
+                    });
                 }
             }
-            for (const name of info.staticMethods?.keys() ?? []) {
-                units.set(`%${cName}.static:${name}`, { order: unitOrder++, lower: () => lowerStaticMethod(this, info, name) });
+            for (const [name, entry] of info.staticMethods ?? []) {
+                units.set(`%${cName}.static:${name}`, {
+                    order: unitOrder++,
+                    roots: functionRoots(entry.member),
+                    lower: () => lowerStaticMethod(this, info, name),
+                });
             }
         }
         // The old emit pass visited each file's functions and then its classes,
@@ -2461,19 +2545,19 @@ export class Lowerer {
         // edge to them can fire (references require the collected class).
         this.onExprClassCollected = (info) => {
             const cName = info.def.name;
-            const register = (name, lower) => {
-                units.set(name, { order: unitOrder++, lower });
+            const register = (name, roots, lower) => {
+                units.set(name, { order: unitOrder++, roots, lower });
                 metadataPriority.set(name, [3, expressionMetadataOrder++]);
             };
-            register(`%${cName}.constructor`, () => this.lowerClassCtor(info));
+            register(`%${cName}.constructor`, classCtorRoots(info), () => this.lowerClassCtor(info));
             for (const { mName, member } of this.classMethodMembers(info)) {
-                register(`%${cName}.${mName}`, () => this.lowerClassMethodMember(info, member));
+                register(`%${cName}.${mName}`, functionRoots(member), () => this.lowerClassMethodMember(info, member));
             }
-            for (const name of info.staticMethods?.keys() ?? []) {
-                register(`%${cName}.static:${name}`, () => lowerStaticMethod(this, info, name));
+            for (const [name, entry] of info.staticMethods ?? []) {
+                register(`%${cName}.static:${name}`, functionRoots(entry.member), () => lowerStaticMethod(this, info, name));
             }
             for (const prop of info.throwingSetters) {
-                register(`%${cName}.set:${prop}`, () => this.throwingSetterFn(info, prop));
+                register(`%${cName}.set:${prop}`, [], () => this.throwingSetterFn(info, prop));
             }
         };
         // Generic instances queued by the bodies above lower here (an instance
@@ -2488,45 +2572,73 @@ export class Lowerer {
                 clsInstLowered < this.genericClassInstances.length ||
                 specLowered < this.emitSpecQueue.length) {
                 while (clsInstLowered < this.genericClassInstances.length) {
-                    const info = this.genericClassInstances[clsInstLowered++];
-                    const owner = demandOwner();
-                    this.genericClassDemandOwner.set(info, owner);
-                    const ref = this.genericClassDemandPriority.get(info) ?? { rank: [4, instanceMetadataOrder++] };
-                    this.genericClassDemandPriority.set(info, ref);
-                    instanceFunctions.push(...this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info))));
+                    const waveEnd = this.genericClassInstances.length;
+                    this.checker.prefetchRoots(this.genericClassInstances.slice(clsInstLowered, waveEnd).flatMap(classMemberRoots));
+                    while (clsInstLowered < waveEnd) {
+                        const info = this.genericClassInstances[clsInstLowered++];
+                        const owner = demandOwner();
+                        this.genericClassDemandOwner.set(info, owner);
+                        const ref = this.genericClassDemandPriority.get(info) ?? { rank: [4, instanceMetadataOrder++] };
+                        this.genericClassDemandPriority.set(info, ref);
+                        instanceFunctions.push(...this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerClassMembers(info))));
+                    }
                 }
                 while (instLowered < this.instantiationQueue.length) {
-                    const { info, inst } = this.instantiationQueue[instLowered++];
-                    const owner = demandOwner();
-                    this.genericFunctionDemandOwner.set(inst, owner);
-                    const ref = this.genericDemandPriority.get(inst) ?? { rank: [4, instanceMetadataOrder++] };
-                    this.genericDemandPriority.set(inst, ref);
-                    // Body-level poisons skip the instance after retaining the
-                    // diagnostic and every edge fired before poisoning.
-                    try {
-                        instanceFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerGenericInstance(info, inst))));
-                    }
-                    catch (e) {
-                        if (!(e instanceof PoisonError))
-                            throw e;
+                    const waveEnd = this.instantiationQueue.length;
+                    this.checker.prefetchRoots(this.instantiationQueue
+                        .slice(instLowered, waveEnd)
+                        .flatMap(({ info }) => functionRoots(info.decl)));
+                    while (instLowered < waveEnd) {
+                        const { info, inst } = this.instantiationQueue[instLowered++];
+                        const owner = demandOwner();
+                        this.genericFunctionDemandOwner.set(inst, owner);
+                        const ref = this.genericDemandPriority.get(inst) ?? { rank: [4, instanceMetadataOrder++] };
+                        this.genericDemandPriority.set(inst, ref);
+                        // Body-level poisons skip the instance after retaining the
+                        // diagnostic and every edge fired before poisoning.
+                        try {
+                            instanceFunctions.push(this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(ref, () => this.lowerGenericInstance(info, inst))));
+                        }
+                        catch (e) {
+                            if (!(e instanceof PoisonError))
+                                throw e;
+                        }
                     }
                 }
                 // Emit-override specialization bodies fire edges of their own
                 // (the super-forward chain, closures, generic calls) — lower them
                 // exactly like generic instances.
                 while (specLowered < this.emitSpecQueue.length) {
-                    try {
-                        const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]));
-                        if (fn)
-                            instanceFunctions.push(fn);
-                    }
-                    catch (e) {
-                        if (!(e instanceof PoisonError))
-                            throw e;
+                    const waveEnd = this.emitSpecQueue.length;
+                    this.checker.prefetchRoots(this.emitSpecQueue
+                        .slice(specLowered, waveEnd)
+                        .flatMap(({ info }) => info.emitOverride ? functionRoots(info.emitOverride.decl) : []));
+                    while (specLowered < waveEnd) {
+                        try {
+                            const fn = this.shapes.withDeclaredOrderPriority([4, instanceMetadataOrder++], () => lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]));
+                            if (fn)
+                                instanceFunctions.push(fn);
+                        }
+                        catch (e) {
+                            if (!(e instanceof PoisonError))
+                                throw e;
+                        }
                     }
                 }
             }
         };
+        // Module inits are the unconditional root wave. Structure prefetch
+        // already covered ordinary top-level expressions, but this full-root
+        // pass also picks up nested/lifted function bodies and the class
+        // declaration-time code that splitFiles hoists out of topStmts.
+        this.checker.prefetchRoots([
+            ...parts.flatMap((fp) => fp.topStmts),
+            ...[...this.classes.values()].flatMap((info) => [
+                ...info.staticFields.map((field) => field.initializer),
+                ...(info.staticBlocks ?? []),
+                ...(info.classDecorators?.nodes ?? []),
+            ]),
+        ]);
         parts.forEach((fp, index) => {
             const priority = [2, index];
             const owner = demandOwner(priority);
@@ -2538,25 +2650,31 @@ export class Lowerer {
         // (the export-map resolution reports them as SC4002 later).
         for (const root of extraRoots ?? [])
             this.onEdge?.(root);
-        while (queue.length > 0) {
-            // A body-level poison outside the per-statement catches (a fenced
-            // constructor/method parameter default lowered by declareParams):
-            // every edge fired before poisoning remains retained; the diagnostic
-            // stays recorded and the member stays omitted.
-            try {
-                const name = queue.shift();
-                const unit = units.get(name);
-                const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++];
-                const owner = demandOwner(priority);
-                const fn = this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, unit.lower));
-                if (fn)
-                    loweredUnits.set(name, fn);
-            }
-            catch (e) {
-                if (!(e instanceof PoisonError))
-                    throw e;
+        const drainUnits = () => {
+            while (queue.length > 0) {
+                const wave = queue.splice(0);
+                this.checker.prefetchRoots(wave.flatMap((name) => units.get(name).roots));
+                for (const name of wave) {
+                    // A body-level poison outside the per-statement catches (a fenced
+                    // constructor/method parameter default lowered by declareParams):
+                    // every edge fired before poisoning remains retained; the diagnostic
+                    // stays recorded and the member stays omitted.
+                    try {
+                        const unit = units.get(name);
+                        const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++];
+                        const owner = demandOwner(priority);
+                        const fn = this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, unit.lower));
+                        if (fn)
+                            loweredUnits.set(name, fn);
+                    }
+                    catch (e) {
+                        if (!(e instanceof PoisonError))
+                            throw e;
+                    }
+                }
             }
-        }
+        };
+        drainUnits();
         this.restoreGenericInstanceOrder();
         this.restoreGenericClassInstanceOrder();
         // Generic bodies can reach ordinary declarations, whose bodies can in
@@ -2567,21 +2685,7 @@ export class Lowerer {
             drainInstances();
             if (queue.length === 0)
                 break;
-            while (queue.length > 0) {
-                try {
-                    const name = queue.shift();
-                    const unit = units.get(name);
-                    const priority = metadataPriority.get(name) ?? [3, expressionMetadataOrder++];
-                    const owner = demandOwner(priority);
-                    const fn = this.withGenericDemandOwner(owner, () => this.shapes.withDeclaredOrderPriority(priority, unit.lower));
-                    if (fn)
-                        loweredUnits.set(name, fn);
-                }
-                catch (e) {
-                    if (!(e instanceof PoisonError))
-                        throw e;
-                }
-            }
+            drainUnits();
             this.restoreGenericInstanceOrder(instLowered);
             this.restoreGenericClassInstanceOrder(clsInstLowered);
         }
@@ -2634,7 +2738,61 @@ export class Lowerer {
     moduleArtifacts(functions) {
         return moduleArtifacts(this, functions);
     }
-    /* ── diagnostics plumbing ─────────────────────────────────────────── */
+    deferToRuntimeFence(diagsBefore, node, target) {
+        if ((this.diagSink !== null && target.allowDiagSink !== true) ||
+            (this.diags.length <= diagsBefore && target.fallback === undefined)) {
+            return null;
+        }
+        const captured = this.diags.splice(diagsBefore);
+        if (captured.some((d) => d.code === "SC9001")) {
+            this.diags.push(...captured);
+            return null;
+        }
+        this.runtimeFences.push(...captured);
+        const first = captured[0];
+        const loc = locOf(node);
+        const code = first?.code ?? target.fallback.code;
+        const baseMessage = first?.message ?? target.fallback.message;
+        const messageLoc = first?.loc ?? loc;
+        const source = first
+            ? this.program.getSourceFile(messageLoc.file) ?? node.getSourceFile()
+            : node.getSourceFile();
+        const pos = ts.getLineAndCharacterOfPosition(source, messageLoc.start);
+        const fence = {
+            kind: "runtimeFence",
+            code,
+            message: target.bareMessage
+                ? baseMessage
+                : `${baseMessage} [${code} at ${messageLoc.file}:${pos.line + 1}]`,
+            loc,
+        };
+        if (target.kind === "statement")
+            return fence;
+        const params = target.params ?? [];
+        const name = typeof target.name === "function" ? target.name() : target.name;
+        const fn = {
+            name,
+            params,
+            returnType: target.returnType,
+            locals: params.map((p) => ({
+                id: p.localId,
+                name: p.name,
+                type: p.type,
+                mutable: target.paramsMutable ?? false,
+            })),
+            body: [fence],
+            loc,
+        };
+        if (target.async)
+            fn.async = true;
+        if (target.generator)
+            fn.generator = target.generator;
+        if (target.kind === "function")
+            return fn;
+        fn.captures = [];
+        this.liftedFns.push(fn);
+        return { kind: "closure", fnName: fn.name, captures: [], type: target.type, loc };
+    }
     /** All diagnostics land here; while a generic instance body is lowering,
      * the instantiation context is appended so the user knows which concrete
      * types made the (source-anchored) construct fail. */
@@ -2781,7 +2939,7 @@ export class Lowerer {
         // story through its callable arm. After the package check: a
         // package-declared generic signature stays the package's story.
         {
-            const parts = widened.isUnionType() ? widened.getTypes() : [widened];
+            const parts = widened.isUnionType() ? ts.constituentTypes(widened) : [widened];
             if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => (s.typeParameters?.length ?? 0) > 0))) {
                 this.pushDiag(genericSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
                 throw new PoisonError();
@@ -3094,10 +3252,10 @@ export class Lowerer {
             // when one constituent is; a union is array-proven only when EVERY
             // arm is, so an ordinary `any[] | string` never qualifies.
             if ((part.flags & ts.TypeFlags.Intersection) !== 0) {
-                return part.getTypes().some(visit);
+                return ts.constituentTypes(part).some(visit);
             }
             if (part.isUnionType())
-                return part.getTypes().every(visit);
+                return ts.constituentTypes(part).every(visit);
             return false;
         };
         return visit(t);
@@ -3240,7 +3398,7 @@ export class Lowerer {
     /** Unwraps a HYBRID (function-with-properties) record to its callable:
      * a record whose shape carries the reserved `%call` func field reads
      * that field; anything else returns unchanged. The consumer half of
-     * types.ts's chalk-shape mapping — call paths and func-slot coercions
+     * type-mapper.ts's chalk-shape mapping — call paths and func-slot coercions
      * share it. */
     hybridCallUnwrap(expr) {
         if (expr.type.kind !== "record")
@@ -3423,7 +3581,7 @@ export class Lowerer {
         }
         // A HYBRID (function-with-properties) record flowing into a plain
         // func slot extracts its reserved %call field — the chalk shape's
-        // "the value IS callable" half (types.ts's hybrid mapping).
+        // "the value IS callable" half (type-mapper.ts's hybrid mapping).
         if (expected.kind === "func" && expr.type.kind === "record") {
             const un = this.hybridCallUnwrap(expr);
             if (un !== expr && typeEquals(un.type, expected))
@@ -3878,102 +4036,102 @@ export class Lowerer {
                 return value;
             case "wrap": {
                 if (dst.kind !== "union")
-                    throw new Error("lowerer bug: wrap lift against a non-union");
+                    throw new InternalCompilerError("lowerer bug: wrap lift against a non-union");
                 return { kind: "unionWrap", unionId: dst.unionId, tag: lift.tag, value, type: dst, loc };
             }
             case "retag": {
                 if (dst.kind !== "union" || value.type.kind !== "union")
-                    throw new Error("lowerer bug: retag lift shape");
+                    throw new InternalCompilerError("lowerer bug: retag lift shape");
                 const retag = this.unionRetagHelper(value.type.unionId, dst.unionId, loc);
                 if (!retag)
-                    throw new Error("lowerer bug: planned retag lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned retag lift failed to intern");
                 return { kind: "call", callee: retag, args: [value], type: dst, loc };
             }
             case "liftWrap": {
                 if (dst.kind !== "union")
-                    throw new Error("lowerer bug: liftWrap lift against a non-union");
+                    throw new InternalCompilerError("lowerer bug: liftWrap lift against a non-union");
                 const inner = this.widthLiftPlan(value.type, lift.arm);
                 if (!inner)
-                    throw new Error("lowerer bug: planned liftWrap arm stopped lifting");
+                    throw new InternalCompilerError("lowerer bug: planned liftWrap arm stopped lifting");
                 const lifted = this.applyWidthLift(inner, value, lift.arm, loc);
                 return { kind: "unionWrap", unionId: dst.unionId, tag: lift.tag, value: lifted, type: dst, loc };
             }
             case "width": {
                 if (dst.kind !== "record" || value.type.kind !== "record")
-                    throw new Error("lowerer bug: width lift shape");
+                    throw new InternalCompilerError("lowerer bug: width lift shape");
                 const helper = this.recordWidthHelper(value.type.shapeId, dst.shapeId, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned width lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned width lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "arr": {
                 if (dst.kind !== "array" || value.type.kind !== "array")
-                    throw new Error("lowerer bug: arr lift shape");
+                    throw new InternalCompilerError("lowerer bug: arr lift shape");
                 const helper = this.arrayWidthHelper(value.type, dst, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned arr lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned arr lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "tupleArr": {
                 if (dst.kind !== "array" || value.type.kind !== "record")
-                    throw new Error("lowerer bug: tupleArr lift shape");
+                    throw new InternalCompilerError("lowerer bug: tupleArr lift shape");
                 const helper = this.tupleArrayWidthHelper(value.type.shapeId, dst, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned tupleArr lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned tupleArr lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "emptyArr": {
                 if (dst.kind !== "array" || value.type.kind !== "array")
-                    throw new Error("lowerer bug: emptyArr lift shape");
+                    throw new InternalCompilerError("lowerer bug: emptyArr lift shape");
                 const helper = this.emptyArrayLiftHelper(value.type, dst, loc);
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "objWidth": {
                 if (dst.kind !== "record" || value.type.kind !== "object")
-                    throw new Error("lowerer bug: objWidth lift shape");
+                    throw new InternalCompilerError("lowerer bug: objWidth lift shape");
                 const helper = this.objRecordWidthHelper(value.type.className, dst.shapeId, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned objWidth lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned objWidth lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "clsWidth": {
                 if (dst.kind !== "object" || value.type.kind !== "record")
-                    throw new Error("lowerer bug: clsWidth lift shape");
+                    throw new InternalCompilerError("lowerer bug: clsWidth lift shape");
                 const helper = this.recordClassWidthHelper(value.type.shapeId, dst.className, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned clsWidth lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned clsWidth lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "narrow": {
                 if (value.type.kind !== "union")
-                    throw new Error("lowerer bug: narrow lift on a non-union");
+                    throw new InternalCompilerError("lowerer bug: narrow lift on a non-union");
                 const helper = this.narrowedArmHelper(value.type.unionId, dst, loc);
                 if (!helper)
-                    throw new Error("lowerer bug: planned narrow lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned narrow lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
             case "dynIn": {
                 if (dst.kind !== "dyn")
-                    throw new Error("lowerer bug: dynIn lift against a non-dyn slot");
+                    throw new InternalCompilerError("lowerer bug: dynIn lift against a non-dyn slot");
                 return { kind: "dynFrom", value, type: DYN, loc };
             }
             case "upcast": {
                 if (dst.kind !== "object" || value.type.kind !== "object")
-                    throw new Error("lowerer bug: upcast lift shape");
+                    throw new InternalCompilerError("lowerer bug: upcast lift shape");
                 return this.upcastTo(value, dst.className);
             }
             case "funcAdapt": {
                 if (dst.kind !== "func" || value.type.kind !== "func")
-                    throw new Error("lowerer bug: funcAdapt lift shape");
+                    throw new InternalCompilerError("lowerer bug: funcAdapt lift shape");
                 const adapter = this.funcCoerceAdapter(value.type, dst, loc);
                 if (!adapter)
-                    throw new Error("lowerer bug: planned funcAdapt lift failed to intern");
+                    throw new InternalCompilerError("lowerer bug: planned funcAdapt lift failed to intern");
                 return { kind: "call", callee: adapter, args: [value], type: dst, loc };
             }
             default: {
                 const _exhaustive = lift;
                 void _exhaustive;
-                throw new Error("unreachable");
+                throw new InternalCompilerError("unreachable");
             }
         }
     }
@@ -4188,7 +4346,7 @@ export class Lowerer {
                             }
                             if ("absent" in lift) {
                                 if (f.type.kind !== "union")
-                                    throw new Error("lowerer bug: absent lift against a non-union field");
+                                    throw new InternalCompilerError("lowerer bug: absent lift against a non-union field");
                                 // The unset optional field: build the undefined arm.
                                 return {
                                     name: f.name,
@@ -4330,8 +4488,6 @@ export class Lowerer {
         this.widthHelpers.set(key, name);
         const arrT = { kind: "array", elem: fromElem };
         const outT = { kind: "array", elem: toElem };
-        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
-        const num = (value) => ({ kind: "numLit", value, type: { kind: "f64" }, loc });
         const f64 = { kind: "f64" };
         this.liftedFns.push({
             name,
@@ -4348,17 +4504,17 @@ export class Lowerer {
                 {
                     kind: "varDecl",
                     localId: "n.0",
-                    init: { kind: "arrIntrinsic", method: "length", receiver: ref("a.0", arrT), args: [], type: f64, loc },
+                    init: { kind: "arrIntrinsic", method: "length", receiver: varRef("a.0", arrT, loc), args: [], type: f64, loc },
                     loc,
                 },
                 {
                     kind: "for",
-                    init: { kind: "varDecl", localId: "i.0", init: num(0), loc },
-                    cond: { kind: "bin", op: "<", left: ref("i.0", f64), right: ref("n.0", f64), type: BOOL, loc },
+                    init: { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: varRef("i.0", f64, loc), right: varRef("n.0", f64, loc), type: BOOL, loc },
                     update: {
                         kind: "assign",
                         localId: "i.0",
-                        value: { kind: "bin", op: "+", left: ref("i.0", f64), right: num(1), type: f64, loc },
+                        value: { kind: "bin", op: "+", left: varRef("i.0", f64, loc), right: numLit(1, loc), type: f64, loc },
                         loc,
                     },
                     body: [
@@ -4367,9 +4523,9 @@ export class Lowerer {
                             expr: {
                                 kind: "arrIntrinsic",
                                 method: "push",
-                                receiver: ref("out.0", outT),
+                                receiver: varRef("out.0", outT, loc),
                                 args: [
-                                    this.applyWidthLift(elemLift, { kind: "arrayGet", arr: ref("a.0", arrT), index: ref("i.0", f64), type: fromElem, loc }, toElem, loc),
+                                    this.applyWidthLift(elemLift, { kind: "arrayGet", arr: varRef("a.0", arrT, loc), index: varRef("i.0", f64, loc), type: fromElem, loc }, toElem, loc),
                                 ],
                                 type: f64,
                                 loc,
@@ -4379,7 +4535,7 @@ export class Lowerer {
                     ],
                     loc,
                 },
-                { kind: "return", value: ref("out.0", outT), loc },
+                { kind: "return", value: varRef("out.0", outT, loc), loc },
             ],
             loc,
         });
@@ -4478,7 +4634,7 @@ export class Lowerer {
                             const lift = plan.get(f.name);
                             if ("absent" in lift) {
                                 if (f.type.kind !== "union")
-                                    throw new Error("lowerer bug: absent lift against a non-union field");
+                                    throw new InternalCompilerError("lowerer bug: absent lift against a non-union field");
                                 return {
                                     name: f.name,
                                     value: {
@@ -4607,7 +4763,7 @@ export class Lowerer {
             if ("absent" in entry) {
                 const u = this.wrappedUndefined(shape.type, loc);
                 if (!u)
-                    throw new Error("lowerer bug: planned absent ctor arg has no undefined arm");
+                    throw new InternalCompilerError("lowerer bug: planned absent ctor arg has no undefined arm");
                 return u;
             }
             const get = { kind: "recordGet", obj: r, shapeId: fromId, field: entry.field, type: entry.src, loc };
@@ -4910,7 +5066,7 @@ export class Lowerer {
                 const aRef = { kind: "varRef", localId: `a.${i}`, type: toT.params[i], loc };
                 const converted = this.coerceToExpected(aRef, pt);
                 if (!typeEquals(converted.type, pt))
-                    throw new Error("lowerer bug: probed fn-adapter param stopped coercing");
+                    throw new InternalCompilerError("lowerer bug: probed fn-adapter param stopped coercing");
                 return converted;
             });
             const call = {
@@ -4953,7 +5109,7 @@ export class Lowerer {
             else {
                 const result = this.coerceToExpected(call, toT.ret);
                 if (!typeEquals(result.type, toT.ret))
-                    throw new Error("lowerer bug: probed fn-adapter return stopped coercing");
+                    throw new InternalCompilerError("lowerer bug: probed fn-adapter return stopped coercing");
                 body = [{ kind: "return", value: result, loc }];
             }
         }
@@ -5644,7 +5800,7 @@ export class Lowerer {
         if (e.type.kind === "dyn" || e.type.kind === "func") {
             return { kind: "jsMarshal", value: e, type: JSVAL, loc };
         }
-        throw new Error(`lowerer bug: jsvalLiftExpr of unliftable ${e.type.kind}`);
+        throw new InternalCompilerError(`lowerer bug: jsvalLiftExpr of unliftable ${e.type.kind}`);
     }
     /** Interned `%jsin.union.<n>(u)` — the runtime tag switch marshaling a
      * union value INTO the island: unit arms become the engine's own
@@ -5661,7 +5817,7 @@ export class Lowerer {
             return existing;
         const def = this.unions.get(unionId);
         if (!def)
-            throw new Error(`lowerer bug: jsval lift of unknown union ${unionId}`);
+            throw new InternalCompilerError(`lowerer bug: jsval lift of unknown union ${unionId}`);
         const name = `%jsin.union.${this.jsinHelpers.size}`;
         this.jsinHelpers.set(key, name);
         const fromT = { kind: "union", unionId };
@@ -5703,7 +5859,7 @@ export class Lowerer {
             return existing;
         const shape = this.shapes.get(shapeId);
         if (!shape)
-            throw new Error(`lowerer bug: jsval lift of unknown shape ${shapeId}`);
+            throw new InternalCompilerError(`lowerer bug: jsval lift of unknown shape ${shapeId}`);
         const name = `%jsin.rec.${this.jsinHelpers.size}`;
         this.jsinHelpers.set(key, name);
         const recT = { kind: "record", shapeId };
@@ -5736,9 +5892,7 @@ export class Lowerer {
         const iv = shape.indexValue;
         const f64 = { kind: "f64" };
         const ksT = arrayOf(STRING);
-        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
-        const num = (value) => ({ kind: "numLit", value, type: f64, loc });
-        const kRef = ref("k.0", STRING);
+        const kRef = varRef("k.0", STRING, loc);
         this.liftedFns.push({
             name,
             params: [{ localId: "r.0", name: "r", type: recT }],
@@ -5755,25 +5909,25 @@ export class Lowerer {
                 { kind: "varDecl", localId: "ks.0", init: { kind: "recordOvfKeys", obj: r, shapeId, type: ksT, loc }, loc },
                 {
                     kind: "for",
-                    init: { kind: "varDecl", localId: "i.0", init: num(0), loc },
+                    init: { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
                     cond: {
                         kind: "bin",
                         op: "<",
-                        left: ref("i.0", f64),
-                        right: { kind: "arrIntrinsic", method: "length", receiver: ref("ks.0", ksT), args: [], type: f64, loc },
+                        left: varRef("i.0", f64, loc),
+                        right: { kind: "arrIntrinsic", method: "length", receiver: varRef("ks.0", ksT, loc), args: [], type: f64, loc },
                         type: BOOL,
                         loc,
                     },
-                    update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: ref("i.0", f64), right: num(1), type: f64, loc }, loc },
+                    update: { kind: "assign", localId: "i.0", value: { kind: "bin", op: "+", left: varRef("i.0", f64, loc), right: numLit(1, loc), type: f64, loc }, loc },
                     body: [
-                        { kind: "varDecl", localId: "k.0", init: { kind: "arrayGet", arr: ref("ks.0", ksT), index: ref("i.0", f64), type: STRING, loc }, loc },
+                        { kind: "varDecl", localId: "k.0", init: { kind: "arrayGet", arr: varRef("ks.0", ksT, loc), index: varRef("i.0", f64, loc), type: STRING, loc }, loc },
                         {
                             kind: "exprStmt",
                             expr: {
                                 kind: "jsOp",
                                 op: "setIdx",
                                 args: [
-                                    ref("out.0", JSVAL),
+                                    varRef("out.0", JSVAL, loc),
                                     { kind: "jsMarshal", value: kRef, type: JSVAL, loc },
                                     this.jsvalLiftExpr({ kind: "recordKeyGet", obj: r, shapeId, key: kRef, overflowOnly: true, type: iv, loc }, loc),
                                 ],
@@ -5785,7 +5939,7 @@ export class Lowerer {
                     ],
                     loc,
                 },
-                { kind: "return", value: ref("out.0", JSVAL), loc },
+                { kind: "return", value: varRef("out.0", JSVAL, loc), loc },
             ],
             loc,
         });
@@ -5804,8 +5958,6 @@ export class Lowerer {
         this.jsinHelpers.set(key, name);
         const arrT = { kind: "array", elem };
         const f64 = { kind: "f64" };
-        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
-        const num = (value) => ({ kind: "numLit", value, type: f64, loc });
         this.liftedFns.push({
             name,
             params: [{ localId: "a.0", name: "a", type: arrT }],
@@ -5821,17 +5973,17 @@ export class Lowerer {
                 {
                     kind: "varDecl",
                     localId: "n.0",
-                    init: { kind: "arrIntrinsic", method: "length", receiver: ref("a.0", arrT), args: [], type: f64, loc },
+                    init: { kind: "arrIntrinsic", method: "length", receiver: varRef("a.0", arrT, loc), args: [], type: f64, loc },
                     loc,
                 },
                 {
                     kind: "for",
-                    init: { kind: "varDecl", localId: "i.0", init: num(0), loc },
-                    cond: { kind: "bin", op: "<", left: ref("i.0", f64), right: ref("n.0", f64), type: BOOL, loc },
+                    init: { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: varRef("i.0", f64, loc), right: varRef("n.0", f64, loc), type: BOOL, loc },
                     update: {
                         kind: "assign",
                         localId: "i.0",
-                        value: { kind: "bin", op: "+", left: ref("i.0", f64), right: num(1), type: f64, loc },
+                        value: { kind: "bin", op: "+", left: varRef("i.0", f64, loc), right: numLit(1, loc), type: f64, loc },
                         loc,
                     },
                     body: [
@@ -5841,9 +5993,9 @@ export class Lowerer {
                                 kind: "jsOp",
                                 op: "setIdx",
                                 args: [
-                                    ref("out.0", JSVAL),
-                                    { kind: "jsMarshal", value: ref("i.0", f64), type: JSVAL, loc },
-                                    this.jsvalLiftExpr({ kind: "arrayGet", arr: ref("a.0", arrT), index: ref("i.0", f64), type: elem, loc }, loc),
+                                    varRef("out.0", JSVAL, loc),
+                                    { kind: "jsMarshal", value: varRef("i.0", f64, loc), type: JSVAL, loc },
+                                    this.jsvalLiftExpr({ kind: "arrayGet", arr: varRef("a.0", arrT, loc), index: varRef("i.0", f64, loc), type: elem, loc }, loc),
                                 ],
                                 type: { kind: "void" },
                                 loc,
@@ -5853,7 +6005,7 @@ export class Lowerer {
                     ],
                     loc,
                 },
-                { kind: "return", value: ref("out.0", JSVAL), loc },
+                { kind: "return", value: varRef("out.0", JSVAL, loc), loc },
             ],
             loc,
         });
@@ -5875,8 +6027,6 @@ export class Lowerer {
         const arrT = { kind: "array", elem: fromElem };
         const outT = { kind: "array", elem: JSVAL };
         const f64 = { kind: "f64" };
-        const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
-        const num = (value) => ({ kind: "numLit", value, type: f64, loc });
         this.liftedFns.push({
             name,
             params: [{ localId: "a.0", name: "a", type: arrT }],
@@ -5892,17 +6042,17 @@ export class Lowerer {
                 {
                     kind: "varDecl",
                     localId: "n.0",
-                    init: { kind: "arrIntrinsic", method: "length", receiver: ref("a.0", arrT), args: [], type: f64, loc },
+                    init: { kind: "arrIntrinsic", method: "length", receiver: varRef("a.0", arrT, loc), args: [], type: f64, loc },
                     loc,
                 },
                 {
                     kind: "for",
-                    init: { kind: "varDecl", localId: "i.0", init: num(0), loc },
-                    cond: { kind: "bin", op: "<", left: ref("i.0", f64), right: ref("n.0", f64), type: BOOL, loc },
+                    init: { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
+                    cond: { kind: "bin", op: "<", left: varRef("i.0", f64, loc), right: varRef("n.0", f64, loc), type: BOOL, loc },
                     update: {
                         kind: "assign",
                         localId: "i.0",
-                        value: { kind: "bin", op: "+", left: ref("i.0", f64), right: num(1), type: f64, loc },
+                        value: { kind: "bin", op: "+", left: varRef("i.0", f64, loc), right: numLit(1, loc), type: f64, loc },
                         loc,
                     },
                     body: [
@@ -5911,9 +6061,9 @@ export class Lowerer {
                             expr: {
                                 kind: "arrIntrinsic",
                                 method: "push",
-                                receiver: ref("out.0", outT),
+                                receiver: varRef("out.0", outT, loc),
                                 args: [
-                                    this.jsvalLiftExpr({ kind: "arrayGet", arr: ref("a.0", arrT), index: ref("i.0", f64), type: fromElem, loc }, loc),
+                                    this.jsvalLiftExpr({ kind: "arrayGet", arr: varRef("a.0", arrT, loc), index: varRef("i.0", f64, loc), type: fromElem, loc }, loc),
                                 ],
                                 type: f64,
                                 loc,
@@ -5923,7 +6073,7 @@ export class Lowerer {
                     ],
                     loc,
                 },
-                { kind: "return", value: ref("out.0", outT), loc },
+                { kind: "return", value: varRef("out.0", outT, loc), loc },
             ],
             loc,
         });
@@ -6050,7 +6200,7 @@ export class Lowerer {
                 const t = this.typeOf(d.initializer);
                 if (!isUnitOnlyTsType(t))
                     return null;
-                for (const p of t.isUnionType() ? t.getTypes() : [t]) {
+                for (const p of t.isUnionType() ? ts.constituentTypes(t) : [t]) {
                     units.add((p.flags & ts.TypeFlags.Null) !== 0 ? "null" : "undefined");
                 }
             }
@@ -6414,10 +6564,83 @@ export class Lowerer {
         return lowerGenericInstance(this, info, inst);
     }
     /* ── classes ──────────────────────────────────────────────────────── */
+    /** Checker work class SHAPE collection performs inside otherwise
+     * deferred JavaScript bodies. Constructor assignments declare fields,
+     * so collection asks for each `this.x` symbol and RHS type even when the
+     * constructor is unreachable. Keep that mandatory work batched without
+     * sweeping unrelated dead method bodies. */
+    prefetchClassCollection(decls) {
+        const defaultTypeNodes = [];
+        const typeNodes = [];
+        const symbolRoots = [];
+        for (const decl of decls) {
+            for (const member of decl.members) {
+                if ((ts.isConstructorDeclaration(member) ||
+                    ts.isMethodDeclaration(member) ||
+                    ts.isGetAccessor(member) ||
+                    ts.isSetAccessor(member)) &&
+                    (!ts.isMethodDeclaration(member) || member.typeParameters === undefined)) {
+                    for (const param of member.parameters) {
+                        if (param.initializer)
+                            defaultTypeNodes.push(param.initializer);
+                    }
+                }
+            }
+            if (!isJsSourceFile(decl.getSourceFile()))
+                continue;
+            for (const member of decl.members) {
+                if (ts.isConstructorDeclaration(member)) {
+                    for (const param of member.parameters) {
+                        if (param.initializer)
+                            typeNodes.push(param.initializer);
+                    }
+                    for (const stmt of member.body?.statements ?? []) {
+                        if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression))
+                            continue;
+                        if (stmt.expression.operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+                            continue;
+                        const lhs = stmt.expression.left;
+                        if ((ts.isPropertyAccessExpression(lhs) || ts.isElementAccessExpression(lhs)) &&
+                            lhs.expression.kind === ts.SyntaxKind.ThisKeyword) {
+                            symbolRoots.push(lhs);
+                            // Field inference normally uses the symbol's type, but its
+                            // panic/undefined fallback asks for the assignment node too.
+                            typeNodes.push(lhs, stmt.expression.right);
+                        }
+                    }
+                    continue;
+                }
+                if (ts.isMethodDeclaration(member) ||
+                    ts.isGetAccessor(member) ||
+                    ts.isSetAccessor(member)) {
+                    for (const param of member.parameters) {
+                        if (param.initializer)
+                            typeNodes.push(param.initializer);
+                    }
+                    // npm-static implicit-any classification resolves body parameter
+                    // references while collecting the method's shape.
+                    if (implicitMonoFile(decl.getSourceFile()) && member.body) {
+                        symbolRoots.push(member.body);
+                    }
+                }
+            }
+        }
+        if (defaultTypeNodes.length > 0) {
+            this.checker.prefetchCollectionTypes(defaultTypeNodes);
+        }
+        if (typeNodes.length > 0 || symbolRoots.length > 0) {
+            this.checker.prefetchClassCollection(typeNodes, symbolRoots);
+        }
+    }
     collectClassShape(decl) {
         return collectClassShape(this, decl);
     }
     collectClassShapeInner(decl, jsNameOverride, inst, mixin) {
+        // Late class expressions and mixin/generic instances do not participate
+        // in emitReachable's initial declaration wave. Prime their mandatory
+        // shape queries at the collection boundary; initial declarations are
+        // already warm and this is memo-free.
+        this.prefetchClassCollection([decl]);
         return collectClassShapeInner(this, decl, jsNameOverride, inst, mixin);
     }
     lowerClassExpressionInfo(expr) {
@@ -7069,7 +7292,7 @@ export class Lowerer {
             }
             if (d && ts.isVariableDeclaration(d) && d.initializer === undefined) {
                 const t = this.checker.getTypeOfSymbol(symbol);
-                const parts = t.isUnionType() ? t.getTypes() : [t];
+                const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
                 if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => (s.typeParameters?.length ?? 0) > 0))) {
                     this.unsupported("SC1030", node, `the generic-signature binding '${name}' (its type keeps type parameters and the declaration has no initializer — no function body exists to monomorphize, so nothing can pin a concrete signature)`);
                 }
@@ -7364,7 +7587,7 @@ export class Lowerer {
      * node_modules but NOT the standard library (typescript's own lib files
      * live under node_modules too), or inside a registered workspace-linked
      * package (a node_modules symlink whose realpath'd files carry no
-     * node_modules segment — shared.ts). The provenance half of the npm
+     * node_modules segment — workspace-registry.ts). The provenance half of the npm
      * typing rule (package types are island handles) and of the per-package
      * requires-dynamic attribution. */
     isNpmFile = (sf) => sf.isDeclarationFile &&