@scriptc/compiler 0.1.7 → 0.2.1

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,16 @@
+import { pathModuleValue } from "./lower-builtin-values.js";
+import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
+import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
+import { UnregisteredClassTypes } from "./unregistered-class-types.js";
+import { buildUnionNarrow } from "./union-narrow.js";
+import { planUnionRetag, buildUnionRetag, planRecordUnionWrap, buildRecordUnionWrap } from "./union-retag.js";
+import { bindingInContext, captureContextBinding, declareContextLocal, declareContextThis } from "./function-context.js";
+export { newFnCtx } from "./function-context.js";
 import { InternalCompilerError } from "../../errors.js";
+import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
+import { ClassDynamicDispatch } from "./class-dynamic-dispatch.js";
+import { finalizeClassMethodValues } from "./class-method-values.js";
 /* AST + checker → IR.
  *
  * Invariants:
@@ -17,24 +29,29 @@ import { resolve } from "node:path";
 import { bindingSource } from "../binding-source.js";
 import { tsgoPath } from "../dts-paths.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, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
+import { literalValues } from "../literal-values.js";
+import { discriminantOwners, literalUnionArm } from "../union-discriminants.js";
+import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, UNSUPPORTED, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
+import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/ir.js";
+import {} from "../npm.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isCjsJsFile, 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 "../type-mapper.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, jsOpenObjectType, 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, appendForkModules } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.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 { 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, errorConstructorArgs, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
+import { implicitAnyParamSymbolsOf } from "./lower-calls.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { bindingNeverReassigned, bodyReadsArguments, funcTypeFromParamShapes, 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, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn } from "./lower-containers.js";
 import { lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew } from "./containers/bytes.js";
 import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string-and-regexp.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
 import { lowerEmitOverrideSpec } from "./lower-event-emitter.js";
-import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleOf, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerNodeModuleCall, lowerTimersPromisesSetInterval, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, registerPromisifiedBuiltinDecl, 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 { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleOf, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerNodeModuleCall, lowerTimersPromisesSetInterval, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecFileCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, registerPromisifiedBuiltinDecl, 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 } 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, lowerFetchWebNew, 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";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
@@ -49,6 +66,7 @@ import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 import { numLit, varRef } from "../../ir/build.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { lowerTernary } from "./lower-exprs.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";
@@ -62,24 +80,6 @@ export class PoisonError extends Error {
 export function own(table, key) {
     return Object.hasOwn(table, key) ? table[key] : undefined;
 }
-/** 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. */
-const THIS_BINDING = { escapedName: "%this" };
-export function newFnCtx(lifted, selfSymbol, selfType, returnType) {
-    return {
-        locals: [],
-        scopes: [new Map()],
-        localCounters: new Map(),
-        captures: lifted ? [] : null,
-        captureSources: [],
-        captureBySymbol: new Map(),
-        selfSymbol,
-        selfType,
-        returnType,
-        ctl: [],
-    };
-}
 /** IrStmt discriminants — the island walk below must not descend into
  * NESTED statements (each is counted individually by its own lowerStmts
  * visit; descending would attribute a nested island statement to every
@@ -90,10 +90,6 @@ const IR_STMT_KINDS = new Set([
     "arraySet", "arraySetLength", "arraySetUndefined", "arrayDelete", "forOf", "return", "fieldSet", "recordSet", "break",
     "continue", "block", "tryCatch", "throw", "rethrow", "runtimeFence",
 ]);
-/** True when a lowered statement's OWN expressions contain island
- * constructs — a generic JSON walk (like moduleUsesRegex): `kind`
- * discriminants live only on IR objects, so user string values can never
- * false-positive. Nested statements are skipped (counted separately). */
 /** Every identifier a binding name binds: the identifier itself, or all
  * identifiers of a (possibly nested) destructuring pattern in source
  * order. */
@@ -110,31 +106,22 @@ export function boundIdentifiersOf(name) {
     }
     return out;
 }
+/** Inspect executable children directly, without boxing the statement tree
+ * into checked-dynamic storage just to calculate coverage. */
 export function stmtUsesIsland(stmts) {
-    let found = false;
-    const visit = (v, root) => {
-        if (found || v === null || typeof v !== "object")
-            return;
-        if (Array.isArray(v)) {
-            for (const item of v)
-                visit(item, root);
-            return;
-        }
-        const kind = v.kind;
-        if (!root && typeof kind === "string" && IR_STMT_KINDS.has(kind))
-            return;
-        const fn = v.fn;
-        if (kind === "jsOp" || kind === "jsExit" || kind === "jsBridgePromise" ||
-            fn === "island.eval" || fn === "island.import" || fn === "island.importDyn" ||
-            fn === "island.castFail") {
-            found = true;
-            return;
-        }
-        for (const value of Object.values(v))
-            visit(value, false);
+    // Keep the accounting boundary at the source statement: nested statement
+    // lists are counted by their own lowerStmts invocation.
+    const nested = (stmt) => IR_STMT_KINDS.has(stmt.kind) || everyStmtChild(stmt, expr, nested);
+    const expr = (node) => {
+        if (node.kind === "jsOp" || node.kind === "jsExit" || node.kind === "jsBridgePromise" ||
+            (node.kind === "libCall" && (node.fn === "island.eval" || node.fn === "island.import" ||
+                node.fn === "island.importDyn" || node.fn === "island.castFail")))
+            return false;
+        return everyExprChild(node, expr, nested);
     };
-    visit(stmts, true);
-    return found;
+    if (Array.isArray(stmts))
+        return !stmts.every((stmt) => everyStmtChild(stmt, expr, nested));
+    return !everyStmtChild(stmts, expr, nested);
 }
 function directExternalTypeSpecifiersByFile(externalTypes) {
     const out = new Map();
@@ -173,12 +160,14 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         if (!phaseTiming)
             return;
         const now = performance.now();
-        process.stderr.write(`scriptc lowering ${JSON.stringify({
+        const event = {
             phase,
             phase_ms: Math.round((now - phaseLast) * 10) / 10,
             total_ms: Math.round((now - phaseStarted) * 10) / 10,
-            ...detail,
-        })}\n`);
+        };
+        for (const key of Object.keys(detail))
+            event[key] = detail[key];
+        process.stderr.write(`scriptc lowering ${JSON.stringify(event)}\n`);
         phaseLast = now;
     };
     const dynamic = options.dynamic ?? false;
@@ -216,6 +205,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const externalTypeSpecifiersByFile = options.externalTypeSpecifiersByFile ??
         directExternalTypeSpecifiersByFile(externalTypes);
     const validation = new Lowerer(program, entry, moduleOrder, dynamic, {
+        frontendServices: options.frontendServices,
         targetPlatform,
         startupCrash,
         ffiImports,
@@ -234,6 +224,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const reachableEmit = ffiImports.length === 0
         ? validation
         : new Lowerer(program, entry, moduleOrder, dynamic, {
+            frontendServices: options.frontendServices,
             targetPlatform,
             startupCrash,
             ffiImports,
@@ -261,6 +252,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     // without such a settled fence retain checker-backed IR exactly once.
     if (reachableEmit.requiresHistoricalOrderRelower) {
         const emit = new Lowerer(program, entry, moduleOrder, dynamic, {
+            frontendServices: options.frontendServices,
             reachable,
             targetPlatform,
             startupCrash,
@@ -282,6 +274,7 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     if (options.coverage !== true)
         return result;
     const remainder = new Lowerer(program, entry, moduleOrder, dynamic, {
+        frontendServices: options.frontendServices,
         reachable,
         remainder: true,
         alreadyFlushed: resultLowerer.flushedSymbols,
@@ -353,7 +346,7 @@ export function staticImportNamespaceType(lowerer, expr) {
     if (moduleId === null) {
         const symbol = lowerer.checker.getSymbolAtLocation(arg);
         const source = symbol && lowerer.checker.declarationsOf(symbol).find((decl) => ts.isSourceFile(decl) && !decl.isDeclarationFile);
-        if (source && !source.fileName.endsWith(".cts") && !isCjsJsFile(source) &&
+        if (source && !source.fileName.endsWith(".cts") && !isCjsJsFile(source, lowerer.program) &&
             lowerer.moduleOrder.includes(source)) {
             moduleId = `file:${tsgoPath(resolve(source.fileName))}`;
         }
@@ -522,11 +515,38 @@ export function dynFallbackType(lowerer, node, t) {
     if (!isJsSourceFile(node.getSourceFile())) {
         if (t.flags & ts.TypeFlags.Any)
             return DYN;
+        const symbol = t.getSymbol();
+        const args = symbol && lowerer.isStdlibSymbol(symbol) ? lowerer.checker.getTypeArguments(t) : [];
+        if (symbol?.name === "Promise" && args[0] && args[0].flags & ts.TypeFlags.Any)
+            return jsFallbackPromiseType(lowerer, t);
+        if (symbol && ["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) && args.some((arg) => arg.flags & ts.TypeFlags.Any))
+            return jsFallbackGeneratorType(lowerer, t);
+        if (lowerer.checker.isArrayType(t) && ((lowerer.checker.getTypeArguments(t)[0]?.flags ?? 0) & ts.TypeFlags.Any) !== 0)
+            return DYN;
         // 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(lowerer, node, t);
     }
+    const promise = jsFallbackPromiseType(lowerer, t);
+    if (promise)
+        return promise;
+    const generator = jsFallbackGeneratorType(lowerer, t);
+    if (generator)
+        return generator;
+    const symbol = t.getSymbol();
+    if ((symbol?.name === "Map" || symbol?.name === "ReadonlyMap") && lowerer.isStdlibSymbol(symbol)) {
+        const args = lowerer.checker.getTypeArguments(t);
+        if (args.length === 2) {
+            const key = lowerer.mapTypeOf(args[0]);
+            const value = lowerer.mapTypeOf(args[1]);
+            return {
+                kind: "map",
+                key: key && isSupportedMapKey(key, key.kind === "union" ? lowerer.unions.get(key.unionId)?.arms : undefined) ? key : DYN,
+                value: value && isSupportedMapValue(value) ? value : DYN,
+            };
+        }
+    }
     // JS inference commonly spells a callback field initialized to null as
     // `((value: any) => any) | null`. Preserve the callable arm and its
     // checked-dynamic pieces instead of collapsing the whole slot to dyn.
@@ -588,6 +608,32 @@ export function dynFallbackType(lowerer, node, t) {
         return fallbackFunction;
     return DYN;
 }
+/** An inferred JS promise keeps its asynchronous ABI even when its payload
+ * has no fixed shape. The settled value crosses the checked native boundary. */
+function jsFallbackPromiseType(lowerer, t) {
+    const symbol = t.getSymbol();
+    if (symbol?.name !== "Promise" || !lowerer.isStdlibSymbol(symbol))
+        return null;
+    const inner = lowerer.checker.getTypeArguments(t)[0];
+    return inner ? { kind: "promise", inner: lowerer.mapTypeOf(inner) ?? DYN } : null;
+}
+/** An inferred generator with channels outside the typed result union
+ * keeps its fiber ABI and carries yielded/resumed values as checked values. */
+function jsFallbackGeneratorType(lowerer, t) {
+    const symbol = t.getSymbol();
+    if (!symbol || !["Generator", "AsyncGenerator", "IterableIterator"].includes(symbol.name) ||
+        !lowerer.isStdlibSymbol(symbol))
+        return null;
+    const [yielded, returned, resumed] = lowerer.checker.getTypeArguments(t);
+    const unit = ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Never;
+    return {
+        kind: "generator",
+        ...(symbol.name === "AsyncGenerator" ? { async: true } : {}),
+        yieldT: yielded && yielded.flags & ts.TypeFlags.Never ? VOID : DYN,
+        retT: !returned || returned.flags & unit ? VOID : DYN,
+        nextT: !resumed || resumed.flags & unit ? UNDEFINED_T : DYN,
+    };
+}
 function jsFallbackFunctionType(lowerer, node, t) {
     const sig = pureSingleCallSignatureOf(lowerer, t);
     if (!sig)
@@ -602,6 +648,7 @@ function jsFallbackFunctionType(lowerer, node, t) {
         // `enabled = true`) rather than that call-site type, so recover the
         // syntactic optionality from the parameter declaration.
         const decl = lowerer.checker.valueDeclarationOf(p);
+        mapped = jsOpenObjectType(decl, mapped, lowerer.shapes, lowerer.unions);
         const optional = decl !== undefined &&
             ts.isParameter(decl) &&
             (decl.questionToken !== undefined || decl.initializer !== undefined);
@@ -614,12 +661,16 @@ function jsFallbackFunctionType(lowerer, node, t) {
         return mapped;
     });
     const retT = lowerer.checker.getReturnTypeOfSignature(sig);
-    const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
+    const sigDecl = lowerer.checker.signatureDeclaration(sig);
+    const jsUnitReturn = sigDecl !== undefined && isJsSourceFile(sigDecl.getSourceFile()) &&
+        (retT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
+    const ret = jsUnitReturn ? DYN : retT.flags & ts.TypeFlags.Void ? VOID
+        : lowerer.mapTypeOf(retT) ?? jsFallbackPromiseType(lowerer, retT) ?? jsFallbackGeneratorType(lowerer, retT) ?? DYN;
     return { kind: "func", params, ret };
 }
-/** A JavaScript `arguments` reader has the spelled parameters plus a hidden
- * array of all supplied arguments in the native ABI. Recover that ABI from
- * the implementation when the function flows through a value binding. */
+/** Recover a JavaScript variadic callable's native ABI from its declaration.
+ * Rest parameters and an implicit `arguments` array must keep their packing
+ * convention when the function flows through a value or an export. */
 function jsArgumentsFunctionType(lowerer, t) {
     if (!(t.flags & ts.TypeFlags.Object))
         return null;
@@ -627,16 +678,19 @@ function jsArgumentsFunctionType(lowerer, t) {
     if (sigs.length !== 1 || sigs[0].getTypeParameters().length !== 0 || lowerer.checker.getConstructSignatures(t).length !== 0 || lowerer.checker.getPropertiesOfType(t).length !== 0)
         return null;
     const decl = lowerer.checker.signatureDeclaration(sigs[0]);
-    if (decl === undefined || !(ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl)) ||
-        !isJsSourceFile(decl.getSourceFile()) || !isNodeEsmFile(decl.getSourceFile()) ||
-        decl.parameters.length === 0 ||
-        decl.parameters.some((p) => p.dotDotDotToken !== undefined) ||
-        !bodyReadsArguments(decl))
+    if (decl === undefined || !(ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl) || ts.isArrowFunction(decl)) ||
+        !isJsSourceFile(decl.getSourceFile()))
+        return null;
+    const hasRest = decl.parameters.some((p) => p.dotDotDotToken !== undefined);
+    if (!hasRest && (ts.isArrowFunction(decl) || !bodyReadsArguments(decl) ||
+        decl.parameters.length > 0 && !isNodeEsmFile(decl.getSourceFile(), lowerer.program)))
         return null;
     const shapes = paramShapes(lowerer, decl.parameters);
     const retType = lowerer.checker.getReturnTypeOfSignature(sigs[0]);
-    const ret = retType.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retType) ?? DYN;
-    return funcTypeFromParamShapes([...shapes, { type: DYN, mode: "arguments" }], ret);
+    const ret = retType.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)
+        ? DYN
+        : retType.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retType) ?? DYN;
+    return funcTypeFromParamShapes(hasRest ? shapes : [...shapes, { type: DYN, mode: "arguments" }], ret);
 }
 /** The one call signature of a PURE function type — single signature, no
  * properties, no construct signatures, no type parameters, no rest params
@@ -720,6 +774,9 @@ export function jsFuncNameOf(node) {
         if (p && ts.isVariableDeclaration(p) && p.initializer === n && ts.isIdentifier(p.name)) {
             return p.name.text;
         }
+        if (p && ts.isBindingElement(p) && p.initializer === n && ts.isIdentifier(p.name)) {
+            return p.name.text;
+        }
         if (p && ts.isPropertyAssignment(p) && p.initializer === n && ts.isIdentifier(p.name)) {
             return p.name.text;
         }
@@ -731,6 +788,7 @@ export class Lowerer {
     entry;
     moduleOrder;
     dynamic;
+    frontendServices;
     checker;
     diags = [];
     fnSigsBySymbol = new Map();
@@ -935,6 +993,7 @@ export class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings = null;
+    localClassInstantiations = [];
     /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
      * instance body lowers: type-parameter symbol → the bound CHECKER type,
      * consulted where the mapped IrType has already widened away information
@@ -959,10 +1018,23 @@ export class Lowerer {
      * aliases, so this carries the var/let form the checker cannot.
      * Scoped strictly by narrowingAliases (lowerIf / lowerCondition). */
     aliasNarrowTypes = new Map();
+    /** These caches belong to this lowering pass. The program already owns
+     * their symbol/node keys; no module-level cache should retain a pass. */
+    classSymbolKeys = new Map();
+    registeredClassSymbols = new Map();
+    httpClientFnBindings = new Map();
+    streamPropMutatedSyms = null;
+    requestInitPropMutatedSyms = null;
+    emitterEventTable = null;
+    emitterComputedPatterns = [];
     /** Locals widened beyond the checker's type because an inferred indexed
      * read can be absent at runtime. Bare reads preserve that union until a
      * surrounding JavaScript guard/default consumes it. */
-    runtimeOptionalLocals = new Set();
+    runtimeOptionalLocals = new RuntimeOptionalLocals();
+    /** An effectful switch test can change the original binding after the
+     * discriminant was captured. A case match narrows the captured value,
+     * not that mutable binding; preserve its tagged representation on reads. */
+    unstableSwitchBindings = new Set();
     /** All storage slots widened for runtime absence, including slots whose
      * current control-flow branch has temporarily narrowed the value. */
     runtimeOptionalStorageLocals = new Set();
@@ -981,18 +1053,21 @@ export class Lowerer {
     runtimeOptionalBindingTypes = new Map();
     /** Concise callback/lambda returns promoted by the HOF callback prepass;
      * arrows have no declaration symbol to key in fnSigsBySymbol. */
-    runtimeOptionalFunctionReturns = new WeakMap();
+    runtimeOptionalFunctionReturns = new Map();
+    /** Intrinsic callback slots can supply a destination for fresh return
+     * literals, such as a reduce accumulator with recursive union fields. */
+    contextualFunctionReturns = new Map();
     /** Arithmetic over an unchecked string read can answer either NaN or a
      * string. Bindings and returns use this marker to retain that result union
      * through checker-bare string annotations. */
-    runtimeOptionalArithmeticTypes = new WeakMap();
+    runtimeOptionalArithmeticTypes = new Map();
     /** Record fields promoted to an undefined-armed union by an indexed-read
      * value. The key is the concrete emitted shape and field name. */
     runtimeOptionalFields = new Set();
     /** Callback pattern parameters carry an optional source without making
      * every name destructured from a present source optional. */
-    runtimeOptionalPatternTypes = new WeakMap();
-    runtimeOptionalReduceTypes = new WeakMap();
+    runtimeOptionalPatternTypes = new Map();
+    runtimeOptionalReduceTypes = new Map();
     /** Capture entries and their origin share one mutable box. Normalize each
      * entry to the origin so writes and flow proofs stay synchronized. */
     runtimeOptionalRoots = new Map();
@@ -1268,6 +1343,15 @@ export class Lowerer {
     /** Union re-tag helpers (%union.retag.N), interned per (from, to)
      * unionId pair — see unionRetagHelper. */
     retagHelpers = new Map();
+    /** Copy-only routes depend on the two union contracts and discriminator
+     * layouts, without recursive width assumptions or evolving class members. */
+    copyRetagHelpers = new Map();
+    unionLiteralOwners = new Map();
+    strippedUndefinedArms = new Map();
+    stdlibSymbols = new Map();
+    /** Method adapter names are owned by class-method-values. Looking them
+     * up must not scan and retain every unrelated lifted function. */
+    classMethodValueHelpers = new Set();
     /** Callee names of every interned coercion helper whose CALL mints a
      * FRESH closure per evaluation (%fn.width.*, %fn.adapt.*,
      * %fnval.spawnres.*). Registered at the mint site — NOT recovered by
@@ -1352,6 +1436,15 @@ export class Lowerer {
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     classes = new Map();
     classBySymbol = new Map();
+    /** Named method slots observed before class collection need a callable
+     * ABI and shared prototype descriptors instead of call-site specialization. */
+    prototypeMethodAccesses = new Map();
+    /** Inferred JS methods participating in an override chain keep a vtable
+     * ABI instead of call-site specialization. Filled before class collection. */
+    virtualJsMethods = new Set();
+    /** Largest fixed argument list below a JS method, discovered before any
+     * base vtable signature is collected. Unused checked slots carry undefined. */
+    virtualJsMethodArity = new Map();
     /** The class whose members are lowering — `super` binds lexically to it
      * (arrows inside methods lower within this window, so they see it too). */
     currentClass = null;
@@ -1404,6 +1497,7 @@ export class Lowerer {
      * engine handle (a dynamic import's namespace object) — paramShape's
      * early-out. */
     jsvalParamOverrides = new Set();
+    checkedCallbackParams = new Set();
     /** Inline Promise.then parameters whose contextual type is a builtin
      * module namespace anonymous object. The settled native token is the
      * ABI truth even when the checker type has no stable module symbol. */
@@ -1493,27 +1587,19 @@ export class Lowerer {
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
     liftedFns = [];
+    /** One Error-method helper belongs to this lowering session. Its cached
+     * dispatch revision needs no weak-key identity or process-global state. */
+    errorMethodDispatchRevision = null;
+    errorPropertyDispatchRevision = null;
     lambdaCounter = 0;
+    preparedClassFactories = new Map();
+    preparingClassFactories = new Set();
     /** Statement lists currently mid-lowering, innermost last: the forward-
      * capture machinery needs to know which later statements of an OPEN list
      * a symbol's declaration sits in, which scope frame list-level declarations
      * register into, and where to insert predeclarations before closures or
      * earlier source statements need them. */
     activeStmtLists = [];
-    /** Forward-captured consts pre-declared as TDZ boxes, keyed by symbol:
-     * lowerVarDecl consumes the entry when the source declaration arrives and
-     * emits the initializing `assign` instead of a fresh declaration. */
-    tdzPredeclared = new Map();
-    /** Nested function DECLARATIONS lowered eagerly by the forward-hoisting
-     * machinery (predeclareForwardFnDecl — a reference above the declaration
-     * in the same function, JS's function hoisting): the statement loop skips
-     * the source statement when it arrives. */
-    hoistedFnDecls = new Set();
-    /** `var` bindings hoisted to their function root (hoistVarBinding), keyed
-     * by the checker's merged symbol — every same-name `var` in one function
-     * is one symbol, so one slot. Module-scope vars live in globalsBySymbol
-     * instead. */
-    hoistedVars = new Map();
     /** Per-file `var` module globals whose type carries an undefined arm:
      * lowerFileInit assigns them the interned undefined right after the
      * run-once guard — JS hoists module vars to `undefined` at entry, so a
@@ -1602,13 +1688,19 @@ export class Lowerer {
         let s = this.statsByFile.get(file);
         if (!s)
             this.statsByFile.set(file, (s = { total: 0, failed: 0, island: 0 }));
-        s[kind]++;
+        if (kind === "total")
+            s.total += 1;
+        else if (kind === "failed")
+            s.failed += 1;
+        else
+            s.island += 1;
     }
     constructor(program, entry, moduleOrder, dynamic, mode = {}) {
         this.program = program;
         this.entry = entry;
         this.moduleOrder = moduleOrder;
         this.dynamic = dynamic;
+        this.frontendServices = mode.frontendServices;
         this.reachable = mode.reachable ?? null;
         this.remainder = mode.remainder ?? false;
         this.alreadyFlushed = mode.alreadyFlushed ?? new Set();
@@ -1633,10 +1725,46 @@ export class Lowerer {
             classNamer: this.classNamer,
             resolveTypeParam: this.typeParamResolver,
             resolveTypeParamTs: this.typeParamTsResolver,
-            genericClassInstance: (decl, ref) => this.genericClassInstanceType(decl, ref),
+            genericClassInstance: (decl, ref, mapArgument) => this.genericClassInstanceType(decl, ref, mapArgument),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
                 : null,
+            localClassInstance: (decl) => {
+                // Computed heritage can close over parameters of its factory.
+                // A speculative checker query outside that factory must not lower
+                // the extends expression in the caller's lexical scope.
+                if (!this.classes.has(this.classNamer(decl)) && !this.collectingExprClasses.has(decl) &&
+                    decl.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.some((base) => {
+                        const expression = base.expression;
+                        if (ts.isCallExpression(expression))
+                            return true;
+                        if (ts.isIdentifier(expression) && this.isStdlibGlobal(expression, expression.text))
+                            return false;
+                        const symbol = this.checker.getSymbolAtLocation(ts.isPropertyAccessExpression(expression) ? expression.name : expression);
+                        const resolved = symbol && symbol.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(symbol) : symbol;
+                        if (ts.isPropertyAccessExpression(expression) && this.isStdlibGlobal(expression.expression, "globalThis") &&
+                            this.builtinErrorInfoOf(resolved))
+                            return false;
+                        if (resolved && this.classBySymbol.has(resolved))
+                            return false;
+                        const mapped = this.mapTypeOf(this.typeOf(expression));
+                        return mapped?.kind !== "classval" || !this.classes.has(mapped.className);
+                    })))
+                    return null;
+                for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+                    if (!ts.isFunctionDeclaration(parent) && !ts.isFunctionExpression(parent) &&
+                        !ts.isArrowFunction(parent) && !ts.isMethodDeclaration(parent))
+                        continue;
+                    if (this.localClassInstantiations.some((entry) => entry.owner === parent))
+                        break;
+                    if (parent.typeParameters?.length || (implicitMonoFile(parent.getSourceFile()) && implicitAnyParamSymbolsOf(this, parent)))
+                        return null;
+                }
+                const className = this.classNamer(decl);
+                if (!this.collectingExprClasses.has(decl))
+                    this.lowerClassExpressionInfo(decl);
+                return { kind: "object", className };
+            },
             mixinIntersectionInstance: (widened) => mixinIntersectionInstanceType(this, widened),
             isStdlibFile: this.isStdlibFile,
             isNpmFile: this.isNpmFile,
@@ -1678,7 +1806,7 @@ export class Lowerer {
             sym = this.checker.getAliasedSymbol(sym);
         for (const decl of this.checker.declarationsOf(sym)) {
             if (ts.isSourceFile(decl) && !decl.isDeclarationFile &&
-                !decl.fileName.endsWith(".cts") && !isCjsJsFile(decl) &&
+                !decl.fileName.endsWith(".cts") && !isCjsJsFile(decl, this.program) &&
                 this.moduleOrder.includes(decl)) {
                 return `file:${tsgoPath(resolve(decl.fileName))}`;
             }
@@ -1717,9 +1845,25 @@ export class Lowerer {
      * builds (no counter can drift between invocations),
      * program-unique through the file qualifier, and collision-free with
      * user identifiers ('%'). */
-    classNamer = (decl) => ts.isClassExpression(decl)
-        ? this.qualify(decl.getSourceFile(), `%cx${decl.getStart()}.${decl.name?.text ?? ""}`)
-        : this.qualify(decl.getSourceFile(), nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"));
+    classNamer = (decl) => {
+        const name = ts.isClassExpression(decl) || (() => {
+            for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+                if (ts.isFunctionLike(parent))
+                    return true;
+            }
+            return false;
+        })()
+            ? this.qualify(decl.getSourceFile(), `%cx${decl.getStart()}.${decl.name?.text ?? ""}`)
+            : this.qualify(decl.getSourceFile(), nsPathPrefix(decl) + (decl.name ? decl.name.text : "%anon"));
+        for (let index = this.localClassInstantiations.length - 1; index >= 0; index--) {
+            const entry = this.localClassInstantiations[index];
+            for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
+                if (parent === entry.owner)
+                    return `${name}%${entry.name}`;
+            }
+        }
+        return name;
+    };
     /** Follows import aliases to the original declaration's symbol. Every
      * value reference resolves through here, so it doubles as the flush
      * point for deferred collection diagnostics: resolving a reference to a
@@ -1931,7 +2075,7 @@ export class Lowerer {
             : undefined;
         if (namespaceDecl === undefined)
             return null;
-        const importDecl = namespaceDecl.parent.parent;
+        const importDecl = namespaceDecl.parent?.parent;
         if (!ts.isImportDeclaration(importDecl) || !ts.isStringLiteral(importDecl.moduleSpecifier))
             return null;
         if (this.externalTypes.has(importDecl.moduleSpecifier.text))
@@ -1953,7 +2097,7 @@ export class Lowerer {
             let specNode;
             let importedName = null;
             if (ts.isImportSpecifier(decl)) {
-                const importDecl = decl.parent.parent.parent;
+                const importDecl = decl.parent?.parent?.parent;
                 if (ts.isImportDeclaration(importDecl))
                     specNode = importDecl.moduleSpecifier;
                 importedName = (decl.propertyName ?? decl.name).text;
@@ -1964,13 +2108,13 @@ export class Lowerer {
                 importedName = "default";
             }
             else if (ts.isNamespaceImport(decl)) {
-                const importDecl = decl.parent.parent;
+                const importDecl = decl.parent?.parent;
                 if (ts.isImportDeclaration(importDecl))
                     specNode = importDecl.moduleSpecifier;
                 importedName = null;
             }
             else if (ts.isExportSpecifier(decl)) {
-                const exportDecl = decl.parent.parent;
+                const exportDecl = decl.parent?.parent;
                 if (ts.isExportDeclaration(exportDecl))
                     specNode = exportDecl.moduleSpecifier;
                 importedName = (decl.propertyName ?? decl.name).text;
@@ -2031,13 +2175,13 @@ export class Lowerer {
                 name = "default";
             }
             else if (d && ts.isImportSpecifier(d)) {
-                const idecl = d.parent.parent.parent;
+                const idecl = d.parent?.parent?.parent;
                 if (ts.isImportDeclaration(idecl))
                     spec = idecl.moduleSpecifier;
                 name = (d.propertyName ?? d.name).text;
             }
             else if (d && ts.isExportSpecifier(d)) {
-                const edecl = d.parent.parent;
+                const edecl = d.parent?.parent;
                 if (ts.isExportDeclaration(edecl))
                     spec = edecl.moduleSpecifier;
                 name = (d.propertyName ?? d.name).text;
@@ -2150,7 +2294,7 @@ export class Lowerer {
         // relative imports; an opted-in --npm-static package is the fallback.
         const dep = resolveImport(this.program, importDecl.getSourceFile(), spec) ??
             npmStaticDepSf7(this.program, importDecl.getSourceFile(), spec);
-        if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep))
+        if (!dep || !isJsSourceFile(dep) || isNodeEsmFile(dep, this.program))
             return null;
         return dep;
     }
@@ -2170,8 +2314,8 @@ export class Lowerer {
             return null;
         const directSpec = requireSpecOf(decl.initializer);
         if (directSpec !== null) {
-            return resolveImport(this.program, decl.getSourceFile(), directSpec) ??
-                npmStaticDepSf7(this.program, decl.getSourceFile(), directSpec);
+            return resolveImport(this.program, decl.getSourceFile(), directSpec, "require") ??
+                npmStaticDepSf7(this.program, decl.getSourceFile(), directSpec, "require");
         }
         return createRequireProgramModuleOf(this, decl.initializer)?.dep ?? null;
     }
@@ -2382,7 +2526,7 @@ export class Lowerer {
         while (changed) {
             changed = false;
             for (const fp of parts) {
-                if (this.asyncInitFiles.has(fp.sf) || !isNodeEsmFile(fp.sf))
+                if (this.asyncInitFiles.has(fp.sf) || !isNodeEsmFile(fp.sf, this.program))
                     continue;
                 if (orderedImportsOf(this.program, fp.sf).some(({ dep }) => dep !== null && this.asyncInitFiles.has(dep))) {
                     this.asyncInitFiles.add(fp.sf);
@@ -2406,9 +2550,14 @@ export class Lowerer {
         }
         const orderIndex = new Map(parts.map((fp, i) => [fp.sf, i]));
         const partSet = new Set(parts.map((fp) => fp.sf));
-        const staticDeps = (sf) => orderedImportsOf(this.program, sf)
-            .map(({ dep }) => dep)
-            .filter((dep) => dep !== null && dep !== sf && partSet.has(dep));
+        const staticDeps = (sf) => {
+            const dependencies = [];
+            for (const { dep } of orderedImportsOf(this.program, sf)) {
+                if (dep !== null && dep !== sf && partSet.has(dep))
+                    dependencies.push(dep);
+            }
+            return dependencies;
+        };
         // Tarjan SCCs over the same static graph. The last postorder member is
         // a deterministic COMPONENT representative for internal-edge tests
         // and global naming. The runtime evaluation root can differ: a cycle
@@ -2485,8 +2634,8 @@ export class Lowerer {
         // Without the guarded %init call at this position
         // those globals stay uninitialized: the dep's module body would never
         // run.
-        const dep = resolveImport(this.program, node.getSourceFile(), spec) ??
-            npmStaticDepSf7(this.program, node.getSourceFile(), spec);
+        const dep = resolveImport(this.program, node.getSourceFile(), spec, "require") ??
+            npmStaticDepSf7(this.program, node.getSourceFile(), spec, "require");
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
         if (this.asyncInitFiles.has(dep)) {
@@ -2566,6 +2715,9 @@ export class Lowerer {
         };
         const functionDeclBySymbol = new Map();
         const signatureBySymbol = new Map();
+        const methodFamilies = new Map();
+        const familyBySymbol = new Map();
+        const optionalMethodFamilies = new Set();
         for (const [symbol, sig] of this.fnSigsBySymbol)
             signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.returnType, top: sig });
         for (const decl of fnDecls) {
@@ -2589,8 +2741,18 @@ export class Lowerer {
                     continue;
                 const symbol = symbolOf(member.name);
                 const sig = info.methods.get(mName);
-                if (symbol && sig)
+                if (symbol && sig) {
                     signatureBySymbol.set(symbol, { params: sig.params, returnType: sig.ret, method: sig });
+                    let root = info;
+                    for (let base = info.base; base; base = base.base)
+                        if (base.methods.has(mName))
+                            root = base;
+                    const key = `${root.def.name}:${mName}`;
+                    const family = methodFamilies.get(key) ?? [];
+                    family.push(symbol);
+                    methodFamilies.set(key, family);
+                    familyBySymbol.set(symbol, family);
+                }
             }
         }
         const peel = (node) => {
@@ -2600,6 +2762,32 @@ export class Lowerer {
             }
             return e;
         };
+        const callableSymbols = new Map();
+        const callableSymbolOf = (node) => {
+            const cached = callableSymbols.get(node);
+            if (cached !== undefined)
+                return cached;
+            let symbol = symbolOf(ts.isPropertyAccessExpression(node) ? node.name : node);
+            if (symbol === null || signatureBySymbol.has(symbol)) {
+                callableSymbols.set(node, symbol);
+                return symbol;
+            }
+            const seen = new Set();
+            while (symbol && !signatureBySymbol.has(symbol) && !seen.has(symbol)) {
+                seen.add(symbol);
+                const declaration = this.checker.valueDeclarationOf(symbol);
+                if (declaration && ts.isMethodDeclaration(declaration)) {
+                    symbol = symbolOf(declaration.name);
+                }
+                else if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && ts.isIdentifier(peel(declaration.initializer))) {
+                    symbol = symbolOf(peel(declaration.initializer));
+                }
+                else
+                    break;
+            }
+            callableSymbols.set(node, symbol);
+            return symbol;
+        };
         const explicitlyNonNull = (node) => {
             let e = node;
             while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isTypeAssertion(e) || ts.isNonNullExpression(e)) {
@@ -2661,13 +2849,17 @@ export class Lowerer {
                 this.mapTypeOf(this.typeOf(e))?.kind === "union" &&
                 this.armTag(this.mapTypeOf(this.typeOf(e)).unionId, UNDEFINED_T) >= 0)
                 return true;
-            if (ts.isIdentifier(e))
-                return optionalSymbols.has(symbolOf(e) ?? {});
+            if (ts.isIdentifier(e)) {
+                const symbol = symbolOf(e);
+                return symbol !== null && optionalSymbols.has(symbol);
+            }
             if (ts.isCallExpression(e) && ts.isIdentifier(e.expression)) {
-                return optionalReturns.has(symbolOf(e.expression) ?? {});
+                const symbol = callableSymbolOf(e.expression);
+                return symbol !== null && optionalReturns.has(symbol);
             }
             if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression)) {
-                return optionalReturns.has(symbolOf(e.expression.name) ?? {});
+                const symbol = callableSymbolOf(e.expression);
+                return symbol !== null && optionalReturns.has(symbol);
             }
             if (ts.isConditionalExpression(e)) {
                 return mayBeOptional(e.whenTrue) || mayBeOptional(e.whenFalse);
@@ -2680,7 +2872,8 @@ export class Lowerer {
                     return mayBeOptional(e.left) || mayBeOptional(e.right);
             }
             if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression)) {
-                const fields = optionalFields.get(symbolOf(e.expression) ?? {});
+                const symbol = symbolOf(e.expression);
+                const fields = symbol === null ? undefined : optionalFields.get(symbol);
                 return fields?.has(fieldName(e)) ?? false;
             }
             return false;
@@ -2690,9 +2883,11 @@ export class Lowerer {
             if (!ts.isBinaryExpression(e) || e.operatorToken.kind !== ts.SyntaxKind.PlusToken)
                 return null;
             const stringArrayRead = (part) => {
-                const t = this.mapTypeOf(this.typeOf(part));
                 const p = peel(part);
-                if (t?.kind !== "string" || !ts.isElementAccessExpression(p))
+                if (!ts.isElementAccessExpression(p))
+                    return false;
+                const t = this.mapTypeOf(this.typeOf(part));
+                if (t?.kind !== "string")
                     return false;
                 const recv = this.mapTypeOf(this.typeOf(p.expression));
                 return recv?.kind === "array" && recv.elem.kind === "string";
@@ -2767,19 +2962,36 @@ export class Lowerer {
                 return [0];
             return null;
         };
-        const bodyReturnsOptional = (fn) => {
+        // Syntax does not change during the fixed point. Reuse its return sites
+        // while recomputing their optionality from each pass's current bindings.
+        const returnSites = new Map();
+        const returnsOf = (fn) => {
+            const cached = returnSites.get(fn);
+            if (cached !== undefined)
+                return cached;
+            const expressions = [];
+            returnSites.set(fn, expressions);
             if (!fn.body)
-                return false;
-            if (!ts.isBlock(fn.body))
-                return mayBeOptional(fn.body);
-            let found = false;
+                return expressions;
+            if (!ts.isBlock(fn.body)) {
+                expressions.push(fn.body);
+            }
             ts.walkPreorder(fn.body, (node) => {
                 if (node !== fn.body && (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node)))
                     return "skip";
-                if (ts.isReturnStatement(node) && node.expression && mayBeOptional(node.expression))
-                    found = true;
+                if (ts.isReturnStatement(node) && node.expression)
+                    expressions.push(node.expression);
                 return undefined;
             });
+            return expressions;
+        };
+        const bodyReturnsOptional = (fn) => {
+            if (fn.body && !ts.isBlock(fn.body))
+                return mayBeOptional(fn.body);
+            let found = false;
+            for (const expression of returnsOf(fn))
+                if (mayBeOptional(expression))
+                    found = true;
             return found;
         };
         const promoteHofCallback = (callback, parameterIndices, seen = new Set()) => {
@@ -2791,6 +3003,8 @@ export class Lowerer {
             };
             const promoteNode = (fn) => {
                 for (const parameterIndex of parameterIndices) {
+                    if (parameterIndex === undefined)
+                        continue;
                     const parameter = fn.parameters[parameterIndex];
                     if (!parameter)
                         continue;
@@ -2863,6 +3077,8 @@ export class Lowerer {
             const sig = signatureBySymbol.get(symbol);
             if (sig) {
                 for (const parameterIndex of parameterIndices) {
+                    if (parameterIndex === undefined)
+                        continue;
                     if (!sig.params[parameterIndex])
                         continue;
                     const before = sig.params[parameterIndex].type;
@@ -2878,6 +3094,8 @@ export class Lowerer {
             if (valueType?.kind === "func") {
                 const params = valueType.params.slice();
                 for (const parameterIndex of parameterIndices) {
+                    if (parameterIndex === undefined)
+                        continue;
                     if (params[parameterIndex])
                         params[parameterIndex] = this.runtimeOptionalType(params[parameterIndex]);
                 }
@@ -2928,9 +3146,22 @@ export class Lowerer {
             const decl = this.checker.valueDeclarationOf(symbol);
             return !!decl && ts.isVariableDeclaration(decl) && !!decl.initializer && callbackReturnsOptional(decl.initializer, seen);
         };
+        const scanSites = new Map();
+        const sitesOf = (sf) => {
+            const cached = scanSites.get(sf);
+            if (cached !== undefined)
+                return cached;
+            const nodes = [];
+            ts.walkPreorder(sf, (node) => {
+                if (ts.isVariableDeclaration(node) || ts.isBinaryExpression(node) || ts.isCallExpression(node))
+                    nodes.push(node);
+            });
+            scanSites.set(sf, nodes);
+            return nodes;
+        };
         const scanFile = (sf) => {
             let changed = false;
-            ts.walkPreorder(sf, (node) => {
+            const scan = (node) => {
                 if (ts.isVariableDeclaration(node)) {
                     if (node.initializer) {
                         if (ts.isIdentifier(node.name) && isDynamicObjectEntryRead(node.initializer)) {
@@ -3021,102 +3252,137 @@ export class Lowerer {
                 }
                 if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
                     const callbackIndices = hofCallbackIndices(node.expression.name.text, node.arguments.length >= 2);
-                    const receiverNode = node.expression.expression;
-                    const receiverTs = this.typeOf(receiverNode);
-                    let receiver = this.mapTypeOf(receiverTs);
-                    // An array method after an optional-chain guard only runs on the
-                    // present receiver. The checker includes the chain's short-circuit
-                    // undefined in intermediate call types, so use the same narrowed
-                    // receiver the method lowerer sees when promoting HOF callbacks.
-                    if (callbackIndices !== null && receiver?.kind === "union" &&
-                        (node.expression.questionDotToken !== undefined || isOptionalChainTail(this, node))) {
-                        receiver = this.mapTypeOf(this.checker.getNonNullableType(receiverTs));
-                    }
-                    const callback = callbackIndices === null ? undefined : node.arguments[0];
-                    const tuple = receiver?.kind === "record" && this.shapes.get(receiver.shapeId)?.tuple === true;
-                    // A JS/evolving-any array may have acquired a precise FLOW type
-                    // at this call while its actual binding remains a checked-dynamic
-                    // array. Its callback consumes DYN values through runtime method
-                    // dispatch, so widening that callback to the native array value
-                    // ABI makes it impossible to box back into DYN. Judge a simple
-                    // binding by its declaration type, the same storage fact local
-                    // declaration lowering uses.
-                    let nativeArrayReceiver = receiver?.kind === "array" || tuple;
-                    if (nativeArrayReceiver && ts.isIdentifier(receiverNode)) {
-                        const receiverSymbol = symbolOf(receiverNode);
-                        const declaration = receiverSymbol ? this.checker.valueDeclarationOf(receiverSymbol) : undefined;
-                        if (declaration && ts.isVariableDeclaration(declaration)) {
-                            const declared = this.mapTypeOf(this.typeOf(declaration.name));
-                            if (declared?.kind !== "array" && !(declared?.kind === "record" && this.shapes.get(declared.shapeId)?.tuple === true)) {
-                                nativeArrayReceiver = false;
+                    const callback = node.arguments[0];
+                    if (callbackIndices !== null && callback !== undefined && !ts.isSpreadElement(callback)) {
+                        const receiverNode = node.expression.expression;
+                        const receiverTs = this.typeOf(receiverNode);
+                        let receiver = this.mapTypeOf(receiverTs);
+                        // An array method after an optional-chain guard only runs on the
+                        // present receiver. The checker includes the chain's short-circuit
+                        // undefined in intermediate call types, so use the same narrowed
+                        // receiver the method lowerer sees when promoting HOF callbacks.
+                        if (receiver?.kind === "union" &&
+                            (node.expression.questionDotToken !== undefined || isOptionalChainTail(this, node))) {
+                            receiver = this.mapTypeOf(this.checker.getNonNullableType(receiverTs));
+                        }
+                        const tuple = receiver?.kind === "record" && this.shapes.get(receiver.shapeId)?.tuple === true;
+                        // A JS/evolving-any array may have acquired a precise FLOW type
+                        // at this call while its actual binding remains a checked-dynamic
+                        // array. Its callback consumes DYN values through runtime method
+                        // dispatch, so widening that callback to the native array value
+                        // ABI makes it impossible to box back into DYN. Judge a simple
+                        // binding by its declaration type, the same storage fact local
+                        // declaration lowering uses.
+                        let nativeArrayReceiver = receiver?.kind === "array" || tuple;
+                        if (nativeArrayReceiver && ts.isIdentifier(receiverNode)) {
+                            const receiverSymbol = symbolOf(receiverNode);
+                            const declaration = receiverSymbol ? this.checker.valueDeclarationOf(receiverSymbol) : undefined;
+                            if (declaration && ts.isVariableDeclaration(declaration)) {
+                                const declared = this.mapTypeOf(this.typeOf(declaration.name));
+                                if (declared?.kind !== "array" && !(declared?.kind === "record" && this.shapes.get(declared.shapeId)?.tuple === true)) {
+                                    nativeArrayReceiver = false;
+                                }
                             }
                         }
-                    }
-                    if (nativeArrayReceiver && callback && !ts.isSpreadElement(callback)) {
-                        if (promoteHofCallback(callback, callbackIndices))
-                            changed = true;
-                        const method = node.expression.name.text;
-                        if ((method === "reduce" || method === "reduceRight") &&
-                            (node.arguments.length < 2 || callbackReturnsOptional(callback))) {
-                            if (promoteHofCallback(callback, [0, 1]))
-                                changed = true;
-                            const result = this.runtimeOptionalType(this.irTypeOf(node));
-                            const previous = this.runtimeOptionalReduceTypes.get(node);
-                            if (!previous || !typeEquals(previous, result)) {
-                                this.runtimeOptionalReduceTypes.set(node, result);
+                        if (nativeArrayReceiver) {
+                            if (promoteHofCallback(callback, callbackIndices))
                                 changed = true;
+                            const method = node.expression.name.text;
+                            if ((method === "reduce" || method === "reduceRight") &&
+                                (node.arguments.length < 2 || callbackReturnsOptional(callback))) {
+                                if (promoteHofCallback(callback, [0, 1]))
+                                    changed = true;
+                                const result = this.runtimeOptionalType(this.irTypeOf(node));
+                                const previous = this.runtimeOptionalReduceTypes.get(node);
+                                if (!previous || !typeEquals(previous, result)) {
+                                    this.runtimeOptionalReduceTypes.set(node, result);
+                                    changed = true;
+                                }
                             }
                         }
                     }
                 }
                 if (ts.isCallExpression(node) &&
                     (ts.isIdentifier(node.expression) || ts.isPropertyAccessExpression(node.expression))) {
-                    const calleeNode = ts.isIdentifier(node.expression) ? node.expression : node.expression.name;
-                    const symbol = symbolOf(calleeNode);
+                    const symbol = callableSymbolOf(node.expression);
                     if (!symbol)
                         return;
                     const sig = signatureBySymbol.get(symbol);
-                    if (!sig) {
-                        const decl = this.checker.valueDeclarationOf(symbol);
-                        if (decl && ts.isVariableDeclaration(decl) && decl.initializer && ts.isIdentifier(decl.initializer)) {
-                            const source = symbolOf(decl.initializer);
-                            const sourceSig = source ? signatureBySymbol.get(source) : undefined;
-                            if (sourceSig) {
-                                node.arguments.forEach((arg, i) => {
-                                    if (ts.isSpreadElement(arg) || !mayBeOptional(arg) || !sourceSig.params[i])
-                                        return;
-                                    const before = sourceSig.params[i].type;
-                                    sourceSig.params[i].type = this.runtimeOptionalType(before);
-                                    if (!typeEquals(before, sourceSig.params[i].type)) {
-                                        changed = true;
-                                        const sourceFn = functionDeclBySymbol.get(source);
-                                        const parameter = sourceFn?.parameters[i];
-                                        if (parameter) {
-                                            for (const bound of boundIdentifiersOf(parameter.name)) {
-                                                const boundSymbol = symbolOf(bound);
-                                                if (boundSymbol && !optionalSymbols.has(boundSymbol)) {
-                                                    optionalSymbols.add(boundSymbol);
-                                                    changed = true;
-                                                }
-                                            }
+                    if (!sig)
+                        return;
+                    // JSDoc describes the usual value, not a runtime arity check.
+                    // A short JavaScript call still passes undefined. Widen only the
+                    // observed slots before bodies lower so both caller and callee
+                    // agree on that value's representation.
+                    const callee = functionDeclBySymbol.get(symbol);
+                    if (callee && isJsSourceFile(callee.getSourceFile()) && !node.arguments.some(ts.isSpreadElement)) {
+                        for (let i = 0; i < sig.params.length; i++) {
+                            const arg = node.arguments[i];
+                            if (arg && (this.typeOf(arg).flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) === 0)
+                                continue;
+                            const family = familyBySymbol.get(symbol);
+                            if (family)
+                                optionalMethodFamilies.add(family);
+                            for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                const shape = signatureBySymbol.get(target)?.params[i];
+                                if (!shape || shape.mode !== "required")
+                                    continue;
+                                const widened = addUndefined(shape.type);
+                                if (typeEquals(shape.type, widened))
+                                    continue;
+                                shape.type = widened;
+                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                if (parameter) {
+                                    for (const bound of boundIdentifiersOf(parameter.name)) {
+                                        const boundSymbol = symbolOf(bound);
+                                        if (boundSymbol) {
+                                            optionalSymbols.add(boundSymbol);
+                                            if (ts.isIdentifier(parameter.name))
+                                                this.runtimeOptionalBindingTypes.set(boundSymbol, shape.type);
                                         }
                                     }
-                                });
+                                }
+                                changed = true;
                             }
                         }
-                        return;
                     }
-                    node.arguments.forEach((arg, i) => {
-                        const callbackSlot = sig.params[i]?.type;
+                    const restAt = sig.params.findIndex((shape) => shape.mode === "rest" || shape.mode === "dynRest" || shape.mode === "islandRest" || shape.mode === "arguments");
+                    node.arguments.forEach((arg, argumentIndex) => {
+                        const i = restAt >= 0 && argumentIndex >= restAt ? restAt : argumentIndex;
+                        const shape = sig.params[i];
+                        const callbackSlot = shape?.type;
                         if (callbackSlot?.kind === "func" && !ts.isSpreadElement(arg)) {
                             const optionalCallbackParams = callbackSlot.params.flatMap((type, index) => type.kind === "union" && this.armTag(type.unionId, UNDEFINED_T) >= 0 ? [index] : []);
                             if (optionalCallbackParams.length > 0 && promoteHofCallback(arg, optionalCallbackParams)) {
                                 changed = true;
                             }
                         }
-                        if (ts.isSpreadElement(arg) || !mayBeOptional(arg) || !sig.params[i])
+                        if (ts.isSpreadElement(arg) || !mayBeOptional(arg) || !shape)
+                            return;
+                        if (i === restAt) {
+                            // A rest binding always receives an array. An unchecked
+                            // argument can make its elements undefined, not the pack.
+                            // Keep every virtual implementation on the same array ABI.
+                            for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                const rest = signatureBySymbol.get(target)?.params[i];
+                                if (rest?.mode !== "rest" || rest.type.kind !== "array")
+                                    continue;
+                                const widened = arrayOf(addUndefined(rest.type.elem));
+                                if (typeEquals(rest.type, widened))
+                                    continue;
+                                rest.type = widened;
+                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                if (parameter && ts.isIdentifier(parameter.name)) {
+                                    const bound = symbolOf(parameter.name);
+                                    if (bound)
+                                        this.runtimeOptionalBindingTypes.set(bound, widened);
+                                }
+                                changed = true;
+                            }
                             return;
+                        }
                         const set = optionalParams.get(symbol) ?? new Set();
+                        shape.type = addUndefined(shape.type);
                         const before = set.size;
                         set.add(i);
                         optionalParams.set(symbol, set);
@@ -3136,40 +3402,24 @@ export class Lowerer {
                         }
                     });
                 }
-            });
+            };
+            for (const node of sitesOf(sf))
+                scan(node);
             return changed;
         };
         const scanReturns = (symbol, decl) => {
-            if (!decl.body)
-                return false;
             let changed = false;
-            if (!ts.isBlock(decl.body) && mayBeOptional(decl.body) && !optionalReturns.has(symbol)) {
-                optionalReturns.add(symbol);
-                changed = true;
-            }
-            if (!ts.isBlock(decl.body)) {
-                const arithmetic = optionalStringArithmeticType(decl.body);
+            for (const expression of returnsOf(decl)) {
+                if (mayBeOptional(expression) && !optionalReturns.has(symbol)) {
+                    optionalReturns.add(symbol);
+                    changed = true;
+                }
+                const arithmetic = optionalStringArithmeticType(expression);
                 if (arithmetic && !arithmeticReturns.has(symbol)) {
                     arithmeticReturns.set(symbol, arithmetic);
                     changed = true;
                 }
             }
-            ts.walkPreorder(decl.body, (node) => {
-                if (node !== decl.body && (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node)))
-                    return "skip";
-                if (ts.isReturnStatement(node) && node.expression && mayBeOptional(node.expression) && !optionalReturns.has(symbol)) {
-                    optionalReturns.add(symbol);
-                    changed = true;
-                }
-                if (ts.isReturnStatement(node) && node.expression) {
-                    const arithmetic = optionalStringArithmeticType(node.expression);
-                    if (arithmetic && !arithmeticReturns.has(symbol)) {
-                        arithmeticReturns.set(symbol, arithmetic);
-                        changed = true;
-                    }
-                }
-                return undefined;
-            });
             return changed;
         };
         let changed = true;
@@ -3181,6 +3431,18 @@ export class Lowerer {
             for (const [symbol, decl] of functionDeclBySymbol)
                 if (scanReturns(symbol, decl))
                     changed = true;
+            // Every implementation of a virtual slot must retain the same ABI,
+            // including when just one body forwards an omitted parameter.
+            for (const family of optionalMethodFamilies) {
+                if (!family.some((symbol) => optionalReturns.has(symbol)))
+                    continue;
+                for (const symbol of family) {
+                    if (!optionalReturns.has(symbol)) {
+                        optionalReturns.add(symbol);
+                        changed = true;
+                    }
+                }
+            }
         }
         for (const [symbol, sig] of signatureBySymbol) {
             const params = optionalParams.get(symbol);
@@ -3306,7 +3568,7 @@ export class Lowerer {
                     continue;
                 const sig = declSymbol ? this.fnSigsBySymbol.get(declSymbol) : undefined;
                 // A body nothing reaches never lowers: its constructs can't fail
-                // the build and it leaves no trace in the emitted C.
+                // the build and it leaves no trace in the emitted LLVM.
                 if (sig && !this.wantBody(sig.name))
                     continue;
                 const fn = this.lowerFunction(decl);
@@ -3352,7 +3614,10 @@ export class Lowerer {
             let gc = 0;
             let gi = 0;
             let es = 0;
-            while (ec < this.exprClasses.length ||
+            const classDispatch = new ClassDynamicDispatch();
+            let dispatchChanged = !this.remainder;
+            while (dispatchChanged ||
+                ec < this.exprClasses.length ||
                 gc < this.genericClassInstances.length ||
                 gi < this.instantiationQueue.length ||
                 es < this.emitSpecQueue.length) {
@@ -3390,6 +3655,9 @@ export class Lowerer {
                             throw e;
                     }
                 }
+                dispatchChanged = !this.remainder && classDispatch.process(this, [
+                    ...functions, ...this.liftedFns, ...this.implicitFns,
+                ]);
             }
         }
         // Lambdas lifted while lowering any of the above (plus synthetic
@@ -3423,6 +3691,7 @@ export class Lowerer {
     /** Final retention, pruning, and module assembly shared by ordinary emit
      * and the retained reachability worklist. */
     finishModule(functions) {
+        finalizeClassMethodValues(this, functions);
         // Globals typed by a class that never REGISTERED (a JS class whose
         // collection fenced — Symbol-keyed fields, an unsupported base): the
         // declaration statement and every use compiled to runtime fences, but
@@ -3433,8 +3702,9 @@ export class Lowerer {
         // fences), so drop it — guarded by a reference scan, with the
         // validator's registration check as the backstop for anything that
         // does slip through with a live reference.
-        const brokenGlobals = this.globalsList.filter((g) => this.typeNamesUnregisteredClass(g.type));
-        const brokenLocalFns = functions.filter((fn) => fn.locals.some((l) => this.typeNamesUnregisteredClass(l.type)));
+        const unregistered = new UnregisteredClassTypes((id) => this.shapes.get(id), (id) => this.unions.get(id), (name) => this.classes.has(name));
+        const brokenGlobals = this.globalsList.filter((g) => unregistered.has(g.type));
+        const brokenLocalFns = functions.filter((fn) => fn.locals.some((l) => unregistered.has(l.type)));
         if (brokenGlobals.length > 0 || brokenLocalFns.length > 0) {
             const referencedIn = (root) => {
                 const referenced = new Set();
@@ -3455,7 +3725,7 @@ export class Lowerer {
                         referenced.add(catchId);
                     // Closure captures name their source locals as PLAIN STRINGS
                     // (captures: string[]) — a captured broken-class local is live.
-                    if (rec["kind"] === "closure" && Array.isArray(rec["captures"])) {
+                    if ((rec["kind"] === "closure" || rec["kind"] === "classRef") && Array.isArray(rec["captures"])) {
                         for (const c of rec["captures"])
                             if (typeof c === "string")
                                 referenced.add(c);
@@ -3483,8 +3753,8 @@ export class Lowerer {
             for (const fn of brokenLocalFns) {
                 // Params and captures list their locals by id too — never prune
                 // those out from under them.
-                const referenced = referencedIn([fn.body, fn.params, fn.captures ?? []]);
-                fn.locals = fn.locals.filter((l) => referenced.has(l.id) || !this.typeNamesUnregisteredClass(l.type));
+                const referenced = referencedIn([fn.body, fn.params, fn.captures ?? [], fn.classCaptures ?? []]);
+                fn.locals = fn.locals.filter((l) => referenced.has(l.id) || !unregistered.has(l.type));
             }
         }
         // Computed before the module gate: retention resolves every class name
@@ -3502,13 +3772,10 @@ export class Lowerer {
         // slots), uniformly across params/locals/globals/fields/body types so
         // every producer and consumer agrees. Programs with no unregistered
         // reference are untouched — byte-stability holds.
-        if (this.diags.length === 0) {
-            this.sanitizeUnregisteredClassTypes([functions, this.globalsList, artifacts.classes, artifacts.records, artifacts.unions]);
-        }
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 11,
+                irVersion: 13,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,
@@ -3519,6 +3786,8 @@ export class Lowerer {
                 entry: ENTRY_NAME,
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
+        if (module)
+            sanitizeUnregisteredClassTypes(module, (name) => this.classes.has(name));
         return {
             module,
             diagnostics: this.diags,
@@ -3530,45 +3799,6 @@ export class Lowerer {
             ...(this.npmLazyTraps ? { npmLazyTraps: this.npmLazyTraps } : {}),
         };
     }
-    /** The unregistered-class type sweep (run()'s last step before the
-     * module assembles): every `{kind:"object"}` TYPE naming a class with
-     * no registered ClassInfo is rewritten IN PLACE to the f64 dummy.
-     * classval types are exempt (they emit the class-independent
-     * `ScrClassObj *` — inert-but-valid storage, the validator's own
-     * stance), and only type objects rewrite — node-level classNames
-     * (`new`, upcasts) cannot reach here (their lowerings fence without a
-     * registered class), so the validator still backstops those. */
-    sanitizeUnregisteredClassTypes(roots) {
-        const isUnregisteredObjectType = (v) => typeof v === "object" && v !== null &&
-            v.kind === "object" &&
-            typeof v.className === "string" &&
-            !this.classes.has(v.className);
-        const sweep = (node) => {
-            if (node === null || typeof node !== "object")
-                return;
-            if (Array.isArray(node)) {
-                node.forEach((item, i) => {
-                    if (isUnregisteredObjectType(item))
-                        node[i] = F64;
-                    else
-                        sweep(item);
-                });
-                return;
-            }
-            const rec = node;
-            for (const key of Object.keys(rec)) {
-                if (key === "loc")
-                    continue;
-                const v = rec[key];
-                if (isUnregisteredObjectType(v))
-                    rec[key] = F64;
-                else
-                    sweep(v);
-            }
-        };
-        for (const root of roots)
-            sweep(root);
-    }
     /** True when `t` (recursively) names a class instance type with no
      * registered ClassInfo — the shape of a JS class whose collection fenced.
      * Used by run()'s global pruning; shapes/unions recurse with a seen-set
@@ -3650,6 +3880,8 @@ export class Lowerer {
         // before collectProgram visits them one by one; reached body lowering
         // will reuse the same answers later.
         this.prefetchClassCollection(parts.flatMap((fp) => fp.classDecls));
+        const collectionEdges = new Set();
+        this.onEdge = (name) => { collectionEdges.add(name); };
         this.collectProgram(parts);
         this.analyzeRuntimeOptionalArrayReads(parts);
         // Decorated classes analyze post-collection here too: the %init seeds
@@ -3666,11 +3898,16 @@ export class Lowerer {
         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)),
-        ];
+        const classMemberRoots = (info) => {
+            const roots = classCtorRoots(info);
+            for (const { member } of this.classMethodMembers(info))
+                roots.push(...functionRoots(member));
+            if (info.staticMethods) {
+                for (const { member } of info.staticMethods.values())
+                    roots.push(...functionRoots(member));
+            }
+            return roots;
+        };
         let unitOrder = 0;
         for (const fp of parts) {
             for (const decl of fp.fnDecls) {
@@ -3707,13 +3944,13 @@ export class Lowerer {
                 units.set(`%${cName}.constructor`, {
                     order: unitOrder++,
                     roots: classCtorRoots(info),
-                    lower: () => this.lowerClassCtor(info),
+                    lower: () => info.localClass && !info.localClass.ready ? null : this.lowerClassCtor(info),
                 });
                 for (const { mName, member } of this.classMethodMembers(info)) {
                     units.set(`%${cName}.${mName}`, {
                         order: unitOrder++,
                         roots: functionRoots(member),
-                        lower: () => this.lowerClassMethodMember(info, member),
+                        lower: () => info.localClass && !info.localClass.ready ? null : this.lowerClassMethodMember(info, member),
                     });
                 }
                 for (const prop of info.throwingSetters) {
@@ -3724,12 +3961,14 @@ export class Lowerer {
                     });
                 }
             }
-            for (const [name, entry] of info.staticMethods ?? []) {
-                units.set(`%${cName}.static:${name}`, {
-                    order: unitOrder++,
-                    roots: functionRoots(entry.member),
-                    lower: () => lowerStaticMethod(this, info, name),
-                });
+            if (info.staticMethods) {
+                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,
@@ -3764,8 +4003,10 @@ export class Lowerer {
                 rank(`%${cName}.constructor`);
                 for (const { mName } of this.classMethodMembers(info))
                     rank(`%${cName}.${mName}`);
-                for (const name of info.staticMethods?.keys() ?? [])
-                    rank(`%${cName}.static:${name}`);
+                if (info.staticMethods) {
+                    for (const name of info.staticMethods.keys())
+                        rank(`%${cName}.static:${name}`);
+                }
                 for (const prop of info.throwingSetters)
                     rank(`%${cName}.set:${prop}`);
             }
@@ -3805,19 +4046,24 @@ export class Lowerer {
             const cName = info.def.name;
             const register = (name, roots, lower) => {
                 units.set(name, { order: unitOrder++, roots, lower });
+                if (reachable.has(name))
+                    queue.push(name);
                 metadataPriority.set(name, [3, expressionMetadataOrder++]);
             };
-            register(`%${cName}.constructor`, classCtorRoots(info), () => this.lowerClassCtor(info));
+            register(`%${cName}.constructor`, classCtorRoots(info), () => info.localClass && !info.localClass.ready ? null : this.lowerClassCtor(info));
             for (const { mName, member } of this.classMethodMembers(info)) {
-                register(`%${cName}.${mName}`, functionRoots(member), () => this.lowerClassMethodMember(info, member));
-            }
-            for (const [name, entry] of info.staticMethods ?? []) {
-                register(`%${cName}.static:${name}`, functionRoots(entry.member), () => lowerStaticMethod(this, info, name));
+                register(`%${cName}.${mName}`, functionRoots(member), () => info.localClass && !info.localClass.ready ? null : this.lowerClassMethodMember(info, member));
             }
+            if (info.staticMethods)
+                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));
             }
         };
+        for (const name of collectionEdges)
+            this.onEdge(name);
         // Generic instances queued by the bodies above lower here (an instance
         // body fires edges of its own and can queue further instances of
         // either kind — function instances and class instantiations drain to
@@ -3939,9 +4185,13 @@ export class Lowerer {
         // turn queue more instances. Continue to the joint fixpoint; the initial
         // queue above is the only portion whose discovery order differed from
         // historical emit order.
+        const classDispatch = new ClassDynamicDispatch(extraRoots !== undefined);
         for (;;) {
             drainInstances();
-            if (queue.length === 0)
+            const dispatchChanged = classDispatch.process(this, [
+                ...loweredUnits.values(), ...initFunctions, ...instanceFunctions, ...this.liftedFns, ...this.implicitFns,
+            ]);
+            if (queue.length === 0 && !dispatchChanged)
                 break;
             drainUnits();
             this.restoreGenericInstanceOrder(instLowered);
@@ -4027,7 +4277,8 @@ export class Lowerer {
         if (target.kind === "statement")
             return fence;
         const params = target.params ?? [];
-        const name = typeof target.name === "function" ? target.name() : target.name;
+        const targetName = target.name;
+        const name = typeof targetName === "function" ? targetName() : targetName;
         const fn = {
             name,
             params,
@@ -4198,7 +4449,7 @@ export class Lowerer {
         // package-declared generic signature stays the package's story.
         {
             const parts = widened.isUnionType() ? ts.constituentTypes(widened) : [widened];
-            if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => (s.typeParameters?.length ?? 0) > 0))) {
+            if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => s.getTypeParameters().length > 0))) {
                 this.pushDiag(genericSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
                 throw new PoisonError();
             }
@@ -4279,8 +4530,8 @@ export class Lowerer {
                 RelativeTimeFormat: intlHint,
                 Segmenter: intlHint,
                 DisplayNames: intlHint,
-                TextEncoder: "TextEncoder values have no representation — call through a const initialized with new TextEncoder(), or use the composed new TextEncoder().encode(s) form",
-                TextDecoder: "TextDecoder values have no representation — call through a const initialized with a recognized literal label, or use the composed new TextDecoder(<literal label>).decode(bytes) form",
+                TextEncoder: "TextEncoder instances support encode(string) and encode(); other codec operations require a dedicated lowering",
+                TextDecoder: "TextDecoder instances support recognized labels, fatal/ignoreBOM option literals, and streaming UTF-8/UTF-16/single-byte decode; runtime option objects remain unsupported",
             };
             this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node), typeHints[stdlibOwnSym?.name ?? ""]));
             throw new PoisonError();
@@ -4336,6 +4587,12 @@ export class Lowerer {
         return fenceStaticReadableStreamMember(this, access, use);
     }
     typeOf(node) {
+        // A checked JS method receives its actual call-site receiver. Its
+        // declaration's inferred class type must not turn property reads back
+        // into native field loads when the method is borrowed by another object.
+        if (node.kind === ts.SyntaxKind.ThisKeyword && isJsSourceFile(node.getSourceFile()) &&
+            this.fnStack.length > 0 && this.resolveThis()?.type.kind === "dyn")
+            return this.checker.getUnknownType();
         // Inside an optional-chain body the guarded receiver is typed by its
         // NON-NULLISH type (the chain's tag test proved it), so every
         // receiver-kind check downstream sees the narrowed arm.
@@ -4377,6 +4634,11 @@ export class Lowerer {
                     return bound;
                 if (typeEquals(narrowedIr, boundIr))
                     return t;
+                // A checked value can contain any runtime kind. A checker-proven
+                // branch narrow therefore cannot contradict this specialization;
+                // reads still validate the payload through maybeNarrow.
+                if (boundIr.kind === "dyn")
+                    return t;
                 // A union binding narrowed to one of its arms (typeof/equality
                 // guards over string|number bindings) — the narrow is truth.
                 if (boundIr.kind === "union") {
@@ -4397,10 +4659,11 @@ export class Lowerer {
         return t;
     }
     /** mapType with this Lowerer's registries and (while a generic instance
-     * body lowers) type-parameter bindings threaded through. */
-    mapTypeOf(t) {
-        const mapped = mapType(t, this.typeCtx);
-        return mapped?.kind === "func" ? jsArgumentsFunctionType(this, t) ?? mapped : mapped;
+     * body lowers) type-parameter bindings threaded through. A supplied mapper
+     * retains interface-view substitutions while sharing ABI normalization. */
+    mapTypeOf(t, mapper) {
+        const mapped = mapper ? mapper(t) : mapType(t, this.typeCtx);
+        return mapped === null || mapped.kind === "func" ? jsArgumentsFunctionType(this, t) ?? mapped : mapped;
     }
     /** The one position where a contextual UNION must not be adopted over the
      * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
@@ -4555,6 +4818,11 @@ export class Lowerer {
     };
     irTypeOf(node) {
         const t = this.typeOf(node);
+        // JS inference can leave mutable fields, accessor parameters and
+        // locals at null/undefined despite later writes. Keep mutable native
+        // storage instead of a slot restricted to the initializer's unit value.
+        if (isJsSourceFile(node.getSourceFile()) && (t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0)
+            return DYN;
         // A never-tainted JS type (neverTaintedJsType) maps — never rides as
         // f64 — but must not: pre-empt the mapping so the JS fallback below
         // answers instead.
@@ -4577,7 +4845,7 @@ export class Lowerer {
                 return dyn;
             this.badType(node, t);
         }
-        return mapped;
+        return jsOpenObjectType(node, mapped, this.shapes, this.unions);
     }
     /** Exact-shape enforcement (SC2002). Records are monomorphic structs, so
      * everywhere a value flows into a typed slot (call arg, initializer,
@@ -4679,8 +4947,20 @@ export class Lowerer {
      * this is THE tag for that (union, arm) pair program-wide — every wrap,
      * narrow, and tag test agrees by construction. */
     armTag(unionId, arm) {
+        return this.unions.armTag(unionId, arm);
+    }
+    /** Literal ownership depends only on the union contract and record layouts.
+     * Recheck it when recursive placeholders close, not for every literal. */
+    literalUnionArm(unionId, values) {
         const def = this.unions.get(unionId);
-        return def ? def.arms.findIndex((a) => typeEquals(a, arm)) : -1;
+        if (!def || values.length === 0)
+            return null;
+        let cached = this.unionLiteralOwners.get(unionId);
+        if (!cached || cached.shapes !== this.shapes.revision || cached.unions !== this.unions.revision) {
+            cached = { owners: discriminantOwners(def, (id) => this.shapes.get(id)), shapes: this.shapes.revision, unions: this.unions.revision };
+            this.unionLiteralOwners.set(unionId, cached);
+        }
+        return literalUnionArm(def, values, (id) => this.shapes.get(id), cached.owners);
     }
     /** Implicit union construction. Wherever a value flows into a typed slot
      * (initializer, assignment, call argument, return, field write, record
@@ -4795,24 +5075,29 @@ export class Lowerer {
             return { kind: "promiseVoidWiden", value: expr, type: expected, loc: expr.loc };
         }
         if (expected.kind === "dyn" && expr.type.kind !== "dyn") {
-            if (expr.kind === "unitLit" || this.dynConvertible(expr.type)) {
-                return { kind: "dynFrom", value: expr, type: DYN, loc: expr.loc };
-            }
-            // An error-HIERARCHY object (builtin subclass or user `extends
-            // Error` class) upcasts to the %Error root first — the caughtToDyn
-            // encoding (scr_dyn_from_error) carries name/message/code and the
-            // runtime CACHES the identity edge, so `instanceof TypeError` on
-            // the dyn side still answers exactly (dyn.errInstanceof). Only the
-            // root spelling was convertible before; the harness passes typed
-            // errors into untyped helpers constantly.
+            // Native void calls still have a JavaScript value: undefined. Keep
+            // the call's effects before exposing that value to checked JS code.
+            if (expr.type.kind === "void") {
+                return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr, loc: expr.loc }],
+                    result: dynUndefinedExpr(expr.loc), type: DYN, loc: expr.loc };
+            }
+            // Preserve the concrete class so checked property/method dispatch
+            // discovers user Error subclasses. Runtime boxing selects the live
+            // view by vtable even when an error first crosses through its base.
             if (expr.type.kind === "object" && this.errorHierarchyClassOf(expr.type.className)) {
                 return {
                     kind: "dynFrom",
-                    value: this.upcastTo(expr, "%Error"),
+                    value: expr,
                     type: DYN,
                     loc: expr.loc,
                 };
             }
+            if (expr.kind === "unitLit" || this.dynConvertible(expr.type)) {
+                const shape = expr.type.kind === "record" ? this.shapes.get(expr.type.shapeId) : undefined;
+                const liveRef = expr.type.kind === "array" || !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
+                return { kind: "dynFrom", value: expr, type: DYN, loc: expr.loc,
+                    ...(liveRef ? { liveRef: true } : {}) };
+            }
             return expr;
         }
         // A dyn ('unknown') ACTUAL flowing into a typed slot the checker
@@ -4848,7 +5133,7 @@ export class Lowerer {
             const funcOk = expected.kind === "func" &&
                 canAdaptDynFuncTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id));
             const handleOk = DYN_HANDLE_KINDS.has(expected.kind);
-            if (this.jsonSafe(expected) || undefArmedOk || bytesOk || errorOk || classOk || funcOk || handleOk) {
+            if (canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id)) || undefArmedOk || bytesOk || errorOk || classOk || funcOk || handleOk) {
                 return { kind: "dynCheck", value: expr, type: expected, loc: expr.loc };
             }
             return expr;
@@ -5005,6 +5290,11 @@ export class Lowerer {
             return expr;
         }
         const tag = this.armTag(expected.unionId, expr.type);
+        if (tag >= 0 && expr.type.kind === "record" && expr.kind !== "recordLit") {
+            const helper = this.recordUnionWrapHelper(expr.type, expected.unionId, expr.loc);
+            if (helper)
+                return { kind: "call", callee: helper, args: [expr], type: expected, loc: expr.loc };
+        }
         if (tag < 0) {
             // A derived class flowing into a union with a base-class arm widens
             // first (nearest ancestor arm wins), then wraps like any arm value.
@@ -5174,9 +5464,11 @@ export class Lowerer {
      * before any helper exists. The cases, in order:
      *   copy      — exact same type (typeEquals), the field/element moves as is
      *   retag     — union into union, every arm mapped (unionRetagMappable —
-     *               identity arms, trap-less; record/array arms may width-lift
-     *               into exactly one destination arm)
+     *               identity arms and compatible payload conversions; a shared
+     *               discriminant may select different record destinations)
      *   wrap      — a non-unit arm value into a union that contains it
+     *   discriminantWrap — identical recursive layouts distinguished by
+     *               their literal field value rather than their storage id
      *   liftWrap  — a record/array value into a union with NO identical arm
      *               but exactly ONE arm it width-lifts into (the findRoute
      *               rule applied at every level; several candidates are
@@ -5211,25 +5503,55 @@ export class Lowerer {
             if (isUnitType(src))
                 return null;
             const tag = this.armTag(dst.unionId, src);
-            if (tag >= 0)
-                return { how: "wrap", tag };
             const def = this.unions.get(dst.unionId);
             if (!def)
                 return null;
+            if (tag >= 0) {
+                const shape = src.kind === "record" ? this.shapes.get(src.shapeId) : undefined;
+                if (shape && planRecordUnionWrap(shape, def, (id) => this.shapes.get(id)))
+                    return { how: "discriminantWrap" };
+                return { how: "wrap", tag };
+            }
             const candidates = [];
             def.arms.forEach((arm, i) => {
                 if (isUnitType(arm))
                     return;
                 const sameFamily = (src.kind === "record" && arm.kind === "record") ||
                     (src.kind === "array" && arm.kind === "array") ||
+                    (src.kind === "func" && arm.kind === "func") ||
+                    (src.kind === "object" && arm.kind === "object") ||
+                    // Tuples already lift into ordinary array slots. Consider that
+                    // same conversion when the array is an arm of a union too.
+                    (src.kind === "record" && this.shapes.get(src.shapeId)?.tuple === true && arm.kind === "array") ||
                     (src.kind === "object" && arm.kind === "record") ||
                     (src.kind === "record" && arm.kind === "object");
                 if (sameFamily && this.widthLiftPlan(src, arm) !== null)
                     candidates.push({ tag: i, arm });
             });
-            if (candidates.length !== 1)
+            let selected = candidates;
+            if (selected.length > 1 && src.kind === "record") {
+                const source = this.shapes.get(src.shapeId);
+                // An inferred JS union may widen its tag while retaining variants
+                // with and without a value. Prefer the unique layout whose omitted
+                // fields are explicitly undefined, rather than filling an optional
+                // unknown slot and making both variants look equally compatible.
+                const absentOnly = selected.filter(({ arm }) => {
+                    if (!source || arm.kind !== "record")
+                        return false;
+                    const target = this.shapes.get(arm.shapeId);
+                    return target !== undefined && target.fields.every((field) => {
+                        if (source.fields.some((present) => present.name === field.name))
+                            return true;
+                        return isUnitType(field.type) || field.type.kind === "union" &&
+                            this.unions.get(field.type.unionId)?.arms.every(isUnitType) === true;
+                    });
+                });
+                if (absentOnly.length === 1)
+                    selected = absentOnly;
+            }
+            if (selected.length !== 1)
                 return null;
-            return { how: "liftWrap", tag: candidates[0].tag, arm: candidates[0].arm };
+            return { how: "liftWrap", tag: selected[0].tag, arm: selected[0].arm };
         }
         // A UNION source into a slot that is ONE of its arms (a width copy
         // whose target field narrowed — the option-table choices shape:
@@ -5260,6 +5582,25 @@ export class Lowerer {
         if (dst.kind === "record" && src.kind === "record") {
             return this.recordWidthPlan(src.shapeId, dst.shapeId) !== null ? { how: "width" } : null;
         }
+        if (dst.kind === "record" && src.kind === "union") {
+            // A union of records can share a structural destination without
+            // choosing one payload layout in advance. Plan every arm: omitted
+            // destination fields need the ordinary optional-field completion,
+            // and a required field missing from any arm still rejects the pair.
+            const from = this.unions.get(src.unionId);
+            if (!from || from.arms.length === 0 || !from.arms.every((arm) => arm.kind === "record"))
+                return null;
+            const key = `unionWidth:${src.unionId}:${dst.shapeId}`;
+            if (this.widthPlanning.has(key))
+                return { how: "unionWidth" };
+            this.widthPlanning.add(key);
+            try {
+                return from.arms.every((arm) => this.widthLiftPlan(arm, dst) !== null) ? { how: "unionWidth" } : null;
+            }
+            finally {
+                this.widthPlanning.delete(key);
+            }
+        }
         if (dst.kind === "record" && src.kind === "object") {
             return this.objToRecordPlan(src.className, dst.shapeId) !== null ? { how: "objWidth" } : null;
         }
@@ -5313,6 +5654,14 @@ export class Lowerer {
                     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 "discriminantWrap": {
+                if (dst.kind !== "union" || value.type.kind !== "record")
+                    throw new InternalCompilerError("lowerer bug: record discriminator lift shape");
+                const helper = this.recordUnionWrapHelper(value.type, dst.unionId, loc);
+                if (!helper)
+                    throw new InternalCompilerError("lowerer bug: planned record discriminator lift failed to intern");
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
             case "retag": {
                 if (dst.kind !== "union" || value.type.kind !== "union")
                     throw new InternalCompilerError("lowerer bug: retag lift shape");
@@ -5338,6 +5687,12 @@ export class Lowerer {
                     throw new InternalCompilerError("lowerer bug: planned width lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
+            case "unionWidth": {
+                if (dst.kind !== "record" || value.type.kind !== "union")
+                    throw new InternalCompilerError("lowerer bug: union width lift shape");
+                const helper = this.unionRecordWidthHelper(value.type.unionId, dst, loc);
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
             case "arr": {
                 if (dst.kind !== "array" || value.type.kind !== "array")
                     throw new InternalCompilerError("lowerer bug: arr lift shape");
@@ -5409,6 +5764,50 @@ export class Lowerer {
             }
         }
     }
+    /** Dispatch a structural copy from its runtime union tag. Each record
+     * payload has its own field offsets and optional-field completions;
+     * interpreting all arms as the destination layout would corrupt memory.
+     * Intern before descending so recursive record unions can reuse it. */
+    unionRecordWidthHelper(fromId, target, loc) {
+        const key = `unionWidth:${fromId}:${target.shapeId}`;
+        const existing = this.widthHelpers.get(key);
+        if (existing)
+            return existing;
+        const name = `%union.record.${this.widthHelpers.size}`;
+        this.widthHelpers.set(key, name);
+        const type = { kind: "union", unionId: fromId };
+        const value = varRef("value.0", type, loc);
+        const from = this.unions.get(fromId);
+        if (!from)
+            throw new InternalCompilerError("lowerer bug: missing record union");
+        const body = [];
+        from.arms.forEach((arm, tag) => {
+            const lift = this.widthLiftPlan(arm, target);
+            if (!lift || arm.kind !== "record")
+                throw new InternalCompilerError("lowerer bug: invalid union record plan");
+            const narrowed = { kind: "unionNarrow", unionId: fromId, tag, value, type: arm, loc };
+            body.push({
+                kind: "if",
+                cond: { kind: "unionIsTag", unionId: fromId, tag, negated: false, value, type: BOOL, loc },
+                then: [{ kind: "return", value: this.applyWidthLift(lift, narrowed, target, loc), loc }],
+                else_: null, loc,
+            });
+        });
+        body.push({
+            kind: "throw",
+            value: {
+                kind: "libCall", fn: "error.new",
+                args: [{ kind: "strLit", value: "invalid record union tag", type: STRING, loc }],
+                type: { kind: "object", className: "%TypeError" }, loc,
+            },
+            loc,
+        });
+        this.liftedFns.push({
+            name, params: [{ localId: "value.0", name: "value", type }], returnType: target,
+            locals: [{ id: "value.0", name: "value", type, mutable: false }], body, loc,
+        });
+        return name;
+    }
     /** Interned `%rec.width.<n>(r)` — builds the target shape from a source
      * record by copying fields: every target field must exist on the source
      * with the EXACT same type, or with a type that LIFTS under
@@ -6157,6 +6556,7 @@ export class Lowerer {
                             {
                                 kind: "callValue",
                                 callee: { kind: "varRef", localId: "f.0", type: fromT, loc },
+                                receiver: { kind: "libCall", fn: "dyn.this", args: [], type: DYN, loc },
                                 args: [],
                                 type: fromT.ret,
                                 loc,
@@ -6289,9 +6689,33 @@ export class Lowerer {
         //   value — the call runs (a `never` thrower never comes back, so the
         //   trap is unreachable there), then the stranded TypeError.
         let strandParams = false;
+        const narrowedParams = new Map();
+        const partialDynParams = new Map();
         for (let i = 0; i < fromT.params.length; i++) {
-            if (!this.coercibleValue(toT.params[i], fromT.params[i]))
-                strandParams = true;
+            const actual = toT.params[i];
+            const expected = fromT.params[i];
+            if (this.coercibleValue(actual, expected))
+                continue;
+            if (actual.kind === "union" && expected.kind === "dyn") {
+                const arms = this.unions.get(actual.unionId)?.arms.filter((arm) => this.dynConvertible(arm)) ?? [];
+                if (arms.length > 0) {
+                    partialDynParams.set(i, arms.length === 1 ? arms[0] : { kind: "union", unionId: this.unions.intern(arms) });
+                    continue;
+                }
+            }
+            // A stored native builtin can have a narrower supported overload
+            // than its public declaration. Preserve every supported union arm
+            // and reject only an invocation carrying an unsupported arm. This
+            // is the union counterpart of the checked single-arm extraction.
+            if (actual.kind === "union" && expected.kind === "union") {
+                const source = this.unions.get(actual.unionId);
+                const target = this.unions.get(expected.unionId);
+                if (source && target && target.arms.every((arm) => this.armTag(actual.unionId, arm) >= 0)) {
+                    narrowedParams.set(i, new Set(source.arms.flatMap((arm, tag) => this.armTag(expected.unionId, arm) < 0 ? [tag] : [])));
+                    continue;
+                }
+            }
+            strandParams = true;
         }
         let voidRet = null;
         let strandRet = false;
@@ -6339,7 +6763,25 @@ export class Lowerer {
         else {
             const args = fromT.params.map((pt, i) => {
                 const aRef = { kind: "varRef", localId: `a.${i}`, type: toT.params[i], loc };
-                const converted = this.coerceToExpected(aRef, pt);
+                const partial = partialDynParams.get(i);
+                if (partial && aRef.type.kind === "union") {
+                    const source = this.unions.get(aRef.type.unionId);
+                    const supported = partial.kind === "union" ? this.unions.get(partial.unionId).arms : [partial];
+                    const rejected = new Set(source.arms.flatMap((arm, tag) => supported.some((accepted) => typeEquals(accepted, arm)) ? [] : [tag]));
+                    const narrow = partial.kind === "union"
+                        ? this.unionRetagHelper(aRef.type.unionId, partial.unionId, loc, rejected)
+                        : this.narrowedArmHelper(aRef.type.unionId, partial, loc);
+                    if (!narrow)
+                        throw new InternalCompilerError("lowerer bug: partial callable parameter stopped narrowing");
+                    return this.coerceToExpected({ kind: "call", callee: narrow, args: [aRef], type: partial, loc }, pt);
+                }
+                const narrowed = narrowedParams.get(i);
+                const helper = narrowed && aRef.type.kind === "union" && pt.kind === "union"
+                    ? this.unionRetagHelper(aRef.type.unionId, pt.unionId, loc, narrowed)
+                    : null;
+                const converted = helper
+                    ? { kind: "call", callee: helper, args: [aRef], type: pt, loc }
+                    : this.coerceToExpected(aRef, pt);
                 if (!typeEquals(converted.type, pt))
                     throw new InternalCompilerError("lowerer bug: probed fn-adapter param stopped coercing");
                 return converted;
@@ -6347,6 +6789,7 @@ export class Lowerer {
             const call = {
                 kind: "callValue",
                 callee: { kind: "varRef", localId: "f.0", type: fromT, loc },
+                receiver: { kind: "libCall", fn: "dyn.this", args: [], type: DYN, loc },
                 args,
                 type: fromT.ret,
                 loc,
@@ -6508,6 +6951,7 @@ export class Lowerer {
                     init: {
                         kind: "callValue",
                         callee: { kind: "varRef", localId: "f.0", type: fromT, loc },
+                        receiver: { kind: "libCall", fn: "dyn.this", args: [], type: DYN, loc },
                         args: params.map((p) => ({ kind: "varRef", localId: p.localId, type: p.type, loc })),
                         type: fromT.ret,
                         loc,
@@ -6543,44 +6987,20 @@ export class Lowerer {
         });
         return name;
     }
-    /** Interned `%union.retag.<n>(u)` — the runtime re-tag for a value of
-     * union `fromId` flowing into a slot of union `toId`: a switch on the
-     * source tag re-wraps the payload under its tag in the destination
-     * (unionNarrow + unionWrap — the payload pointer moves, no copy, so
-     * ref-arm identity is preserved across the re-tag). Arms map by
-     * canonical type (typeEquals): every non-unit source arm must exist in
-     * the destination, or the pair isn't mappable (null — the caller keeps
-     * the SC2003 fence). A stranded UNIT arm (undefined/null with no
-     * destination arm) is different: it means tsc's picture at the site was
-     * NARROWER than the IR type — control-flow narrowing to a sub-union, or
-     * a non-null assertion, both of which erase at lowering — so the arm is
-     * exactly the possibility the checker proved (or the source asserted)
-     * away. It compiles to a runtime trap case throwing a catchable
-     * TypeError-shaped string, the lying-cast stance (SEMANTICS.md): sound
-     * narrowing never reaches it, a lying `!` throws instead of smuggling
-     * an unrepresentable unit into the destination. */
-    /** True when unionRetagHelper can bridge the pair — every non-unit
-     * source arm exists (typeEquals) in the destination, or width-lifts
-     * into exactly one destination arm (widthLiftPlan — record and array
-     * arms compose the re-tag with the per-arm reshape). Pure: callers that
-     * must validate a WHOLE plan before interning anything (recordWidthHelper)
-     * probe with this so a failed later field never orphans a helper. */
+    /** Validate the complete union conversion before interning helpers.
+     * Recursive width plans close through the same in-progress pair guard;
+     * no optimistic result is memoized after that planning stack unwinds. */
     unionRetagMappable(fromId, toId) {
         const from = this.unions.get(fromId);
-        if (!from || !this.unions.get(toId))
+        const to = this.unions.get(toId);
+        if (!from || !to)
             return false;
-        // The union-pair face of the widthPlanning cycle guard: recursive
-        // aliases can close their cycle through a union without repeating a
-        // record pair (`type Json = Json[] | undefined`) — an in-progress
-        // pair re-entered answers "assume mappable", same greatest-fixed-point
-        // reading as recordWidthPlan's.
         const key = `u:${fromId}:${toId}`;
         if (this.widthPlanning.has(key))
             return true;
         this.widthPlanning.add(key);
         try {
-            const toT = { kind: "union", unionId: toId };
-            return from.arms.every((arm) => isUnitType(arm) || this.widthLiftPlan(arm, toT) !== null);
+            return planUnionRetag(from, to, (id) => this.shapes.get(id), (src, dst) => this.widthLiftPlan(src, dst)) !== null;
         }
         finally {
             this.widthPlanning.delete(key);
@@ -6751,111 +7171,54 @@ export class Lowerer {
         }
         return { kind: "call", callee: name, args: isUnitType(src) ? [] : [expr], type: expected, loc };
     }
+    recordUnionWrapHelper(source, toId, loc) {
+        const shape = this.shapes.get(source.shapeId);
+        const to = this.unions.get(toId);
+        if (!shape || !to)
+            return null;
+        const plan = planRecordUnionWrap(shape, to, (id) => this.shapes.get(id));
+        if (!plan)
+            return null;
+        const key = `recordWrap:${source.shapeId}:${toId}`;
+        const existing = this.retagHelpers.get(key);
+        if (existing)
+            return existing;
+        const name = `%record.wrap.${this.retagHelpers.size}`;
+        this.retagHelpers.set(key, name);
+        this.liftedFns.push(buildRecordUnionWrap(name, source, to, plan, loc, (lift, value, dst) => this.applyWidthLift(lift, value, dst, loc)));
+        return name;
+    }
     unionRetagHelper(fromId, toId, loc, trappable) {
         const from = this.unions.get(fromId);
         const to = this.unions.get(toId);
         if (!from || !to)
             return null;
-        // Per-arm WIDTH LIFTS: a RECORD or ARRAY arm with no identical
-        // destination arm may width-lift into exactly ONE destination arm
-        // (widthLiftPlan's liftWrap — the findRoute pattern: `{hostname, port,
-        // tailscaleUrl?} | undefined` returning as `{hostname, port} |
-        // undefined`; nested width and per-element array reshapes compose).
-        // Planned PURELY first so a failing arm never orphans an interned
-        // width helper; ambiguity (several liftable destination arms) declines
-        // — no honest single mapping exists. A lifted arm is a COPY
-        // (divergence 35's stance), unlike the identity-preserving plain
-        // re-wrap.
-        const toT = { kind: "union", unionId: toId };
-        const lifts = new Map();
-        from.arms.forEach((arm, i) => {
-            if (this.armTag(toId, arm) >= 0 || isUnitType(arm) || (trappable?.has(i) ?? false))
-                return;
-            const lp = this.widthLiftPlan(arm, toT);
-            if (lp && lp.how === "liftWrap")
-                lifts.set(i, lp);
-        });
-        // `trappable` extends the unit-arm rule to arms the CHECKER proved
-        // away at the coercion site (narrowedRetagHelper): those may trap too.
-        const ok = from.arms.every((arm, i) => this.armTag(toId, arm) >= 0 || isUnitType(arm) || (trappable?.has(i) ?? false) || lifts.has(i));
-        if (!ok)
-            return null;
-        const mapping = from.arms.map((arm, i) => {
-            const identity = this.armTag(toId, arm);
-            return identity >= 0 ? identity : (lifts.get(i)?.tag ?? -1);
-        });
-        const stranded = mapping.flatMap((t, i) => (t < 0 ? [i] : []));
-        // Lifts are a pure function of the (from, to) pair, so the historic
-        // key stays sound for them; stranded arms depend on the SITE.
+        const request = `${fromId}:${toId}:${trappable === undefined ? "" : [...trappable].sort((a, b) => a - b).join(".")}`;
+        const cached = this.copyRetagHelpers.get(request);
+        if (cached && cached.shapes === this.shapes.revision && cached.unions === this.unions.revision)
+            return cached.name;
+        const plan = planUnionRetag(from, to, (id) => this.shapes.get(id), (src, dst) => this.widthLiftPlan(src, dst), trappable);
+        if (plan === null)
+            return null;
+        // The registry pair determines every route; only checker-proven
+        // stranded arms vary by site. Publish the name before building widths
+        // so recursive records and arrays can call this same helper.
+        const stranded = [];
+        plan.forEach((arm, tag) => { if (arm.kind === "trap")
+            stranded.push(tag); });
         const key = `${fromId}:${toId}:${stranded.join(".")}`;
         const existing = this.retagHelpers.get(key);
-        if (existing)
-            return existing;
-        const name = `%union.retag.${this.retagHelpers.size}`;
-        this.retagHelpers.set(key, name);
-        const fromT = { kind: "union", unionId: fromId };
-        const u = { kind: "varRef", localId: "u.0", type: fromT, loc };
-        const body = [];
-        from.arms.forEach((arm, i) => {
-            const tag = mapping[i];
-            const cond = { kind: "unionIsTag", unionId: fromId, tag: i, negated: false, value: u, type: BOOL, loc };
-            let then;
-            if (tag < 0) {
-                const what = isUnitType(arm)
-                    ? (arm.kind === "undefinedT" ? "undefined" : "null")
-                    : `a '${this.fmt(arm)}' value`;
-                then = [
-                    {
-                        kind: "throw",
-                        value: {
-                            kind: "libCall",
-                            fn: "error.new",
-                            args: [
-                                {
-                                    kind: "strLit",
-                                    value: `${what} is not representable in the target union (a value narrowed or asserted past it still held it)`,
-                                    type: STRING,
-                                    loc,
-                                },
-                            ],
-                            type: { kind: "object", className: "%TypeError" },
-                            loc,
-                        },
-                        loc,
-                    },
-                ];
-            }
-            else {
-                const value = isUnitType(arm)
-                    ? { kind: "unitLit", unit: arm.kind === "undefinedT" ? "undefined" : "null", type: arm, loc }
-                    : { kind: "unionNarrow", unionId: fromId, tag: i, value: u, type: arm, loc };
-                const lift = lifts.get(i);
-                // Width-lifted arm: the narrowed payload reshapes into the
-                // destination arm and wraps (applyWidthLift — planned above, so
-                // the interns cannot fail here); identity arms re-wrap the same
-                // payload pointer.
-                const wrapped = lift
-                    ? this.applyWidthLift(lift, value, toT, loc)
-                    : { kind: "unionWrap", unionId: toId, tag, value, type: toT, loc };
-                then = [{ kind: "return", value: wrapped, loc }];
-            }
-            body.push({ kind: "if", cond, then, else_: null, loc });
-        });
-        // Unreachable when tags are exhaustive (they are, by construction);
-        // satisfies the all-paths-return rule and keeps a corrupted tag loud.
-        body.push({
-            kind: "throw",
-            value: { kind: "strLit", value: "scriptc: internal error: invalid union tag", type: STRING, loc },
-            loc,
-        });
-        this.liftedFns.push({
-            name,
-            params: [{ localId: "u.0", name: "u", type: fromT }],
-            returnType: toT,
-            locals: [{ id: "u.0", name: "u", type: fromT, mutable: true }],
-            body,
-            loc,
-        });
+        const name = existing ?? `%union.retag.${this.retagHelpers.size}`;
+        if (!existing) {
+            this.retagHelpers.set(key, name);
+            this.liftedFns.push(buildUnionRetag(name, from, to, plan, loc, (lift, value, dst) => this.applyWidthLift(lift, value, dst, loc), (type) => this.fmt(type)));
+        }
+        // Width routes still revalidate on every request. Only a complete plan
+        // of exact payload copies and site-proven traps can bypass planning.
+        if (plan.every((arm) => arm.kind === "trap" || (arm.kind === "direct"
+            ? arm.route.lift.how === "copy" : arm.routes.every((route) => route.lift.how === "copy")))) {
+            this.copyRetagHelpers.set(request, { name, shapes: this.shapes.revision, unions: this.unions.revision });
+        }
         return name;
     }
     /** Interned `%union.narrow.<n>(u)` — the CHECKED single-arm extraction
@@ -6881,55 +7244,10 @@ export class Lowerer {
         const name = `%union.narrow.${this.narrowHelpers.size}`;
         this.narrowHelpers.set(key, name);
         this.checkedNarrowHelpers.add(name);
-        const fromT = { kind: "union", unionId: fromId };
-        const u = { kind: "varRef", localId: "u.0", type: fromT, loc };
-        const body = [];
-        from.arms.forEach((arm, i) => {
-            if (i === tag)
-                return; // the fall-through extraction below
-            const what = isUnitType(arm)
-                ? (arm.kind === "undefinedT" ? "undefined" : "null")
-                : `a '${this.fmt(arm)}' value`;
-            body.push({
-                kind: "if",
-                cond: { kind: "unionIsTag", unionId: fromId, tag: i, negated: false, value: u, type: BOOL, loc },
-                then: [
-                    {
-                        kind: "throw",
-                        value: {
-                            kind: "libCall",
-                            fn: "error.new",
-                            args: [
-                                {
-                                    kind: "strLit",
-                                    value: `${what} is not representable in the target union (a value narrowed or asserted past it still held it)`,
-                                    type: STRING,
-                                    loc,
-                                },
-                            ],
-                            type: { kind: "object", className: "%TypeError" },
-                            loc,
-                        },
-                        loc,
-                    },
-                ],
-                else_: null,
-                loc,
-            });
-        });
-        body.push({
-            kind: "return",
-            value: { kind: "unionNarrow", unionId: fromId, tag, value: u, type: target, loc },
-            loc,
-        });
-        this.liftedFns.push({
-            name,
-            params: [{ localId: "u.0", name: "u", type: fromT }],
-            returnType: target,
-            locals: [{ id: "u.0", name: "u", type: fromT, mutable: true }],
-            body,
-            loc,
-        });
+        const fn = buildUnionNarrow(name, from, target, loc, (type) => this.fmt(type));
+        if (!fn)
+            throw new InternalCompilerError("lowerer bug: invalid checked union extraction");
+        this.liftedFns.push(fn);
         return name;
     }
     /** The DEFERRED-INIT field read (`stream!: T` assigned past the
@@ -6957,32 +7275,13 @@ export class Lowerer {
             return existing;
         const name = `%deferred.read.${this.narrowHelpers.size}`;
         this.narrowHelpers.set(key, name);
-        const fromT = { kind: "union", unionId: fromId };
-        const u = { kind: "varRef", localId: "u.0", type: fromT, loc };
         const dflt = target.kind === "bool"
             ? { kind: "boolLit", value: false, type: BOOL, loc }
             : { kind: "numLit", value: NaN, type: F64, loc };
-        this.liftedFns.push({
-            name,
-            params: [{ localId: "u.0", name: "u", type: fromT }],
-            returnType: target,
-            locals: [{ id: "u.0", name: "u", type: fromT, mutable: true }],
-            body: [
-                {
-                    kind: "if",
-                    cond: { kind: "unionIsTag", unionId: fromId, tag: utag, negated: false, value: u, type: BOOL, loc },
-                    then: [{ kind: "return", value: dflt, loc }],
-                    else_: null,
-                    loc,
-                },
-                {
-                    kind: "return",
-                    value: { kind: "unionNarrow", unionId: fromId, tag, value: u, type: target, loc },
-                    loc,
-                },
-            ],
-            loc,
-        });
+        const fn = buildUnionNarrow(name, from, target, loc, (type) => this.fmt(type), dflt);
+        if (!fn)
+            throw new InternalCompilerError("lowerer bug: invalid deferred union extraction");
+        this.liftedFns.push(fn);
         return name;
     }
     /** True when a static value can become ONE island value: jsval itself,
@@ -7366,7 +7665,68 @@ export class Lowerer {
      * lowering goes through here (via lowerExprExpecting) or calls this
      * directly when the expression was already lowered. */
     coerceInto(node, expr, expected) {
-        let e = this.coerceToExpected(expr, expected);
+        // A union destination can accept the binding's tagged storage directly.
+        // The checker's single-arm flow type can be stale after a callback writes
+        // the binding. Extracting that arm and wrapping it again would discard the
+        // actual tag and could read a different record layout. Retag the stored
+        // value instead; ordinary coercion checks any excluded destination arms.
+        // Explicit assertions keep their own conversion and validation.
+        if (expected.kind === "union" && expr.kind === "unionNarrow") {
+            let source = node;
+            while (ts.isParenthesizedExpression(source) || ts.isSatisfiesExpression(source))
+                source = source.expression;
+            if (ts.isIdentifier(source) || ts.isShorthandPropertyAssignment(source))
+                expr = expr.value;
+        }
+        // A fresh literal can retain a wider runtime-optional field after its
+        // initial contextual layout was chosen. Its known discriminator still
+        // selects the destination arm; validate that payload before wrapping.
+        // Work with the already lowered value so property effects run once.
+        if (expr.type.kind === "record" && expected.kind === "union") {
+            let literal = node;
+            while (ts.isParenthesizedExpression(literal) || ts.isSatisfiesExpression(literal))
+                literal = literal.expression;
+            const def = this.unions.get(expected.unionId);
+            if (def?.discriminant && ts.isObjectLiteralExpression(literal)) {
+                const property = this.checker.getPropertyOfType(this.typeOf(literal), def.discriminant.field);
+                if (property && !(property.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor))) {
+                    const values = literalValues(this.checker.getTypeOfSymbol(property));
+                    const arm = values && this.literalUnionArm(def.id, values);
+                    if (arm)
+                        expr = this.coerceInto(node, expr, arm);
+                }
+            }
+        }
+        if (expected.kind === "dyn") {
+            const contextual = this.checker.getContextualType(node);
+            const parts = contextual?.isUnionType() ? ts.constituentTypes(contextual) : contextual ? [contextual] : [];
+            const errorOptions = parts.some((part) => {
+                const sym = part.getAliasSymbol() ?? part.getSymbol();
+                return sym?.name === "ErrorOptions" && this.isStdlibSymbol(sym);
+            });
+            if (errorOptions) {
+                const actual = this.typeOf(node);
+                for (const part of actual.isUnionType() ? ts.constituentTypes(actual) : [actual]) {
+                    const cause = this.checker.getPropertyOfType(part, "cause");
+                    if (cause && cause.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
+                        this.unsupported("SC1090", node, "Error options with a cause accessor (use a data property)");
+                    }
+                }
+            }
+        }
+        let e = this.dynamic && expr.type.kind === "dyn" && expected.kind === "array" && expected.elem.kind === "jsval"
+            ? { kind: "jsExit", value: this.jsvalIn(expr, node), type: expected, loc: expr.loc }
+            : this.coerceToExpected(expr, expected);
+        // Existing JavaScript arrays retain mutations and identity across checked
+        // slots. Fresh literals have no prior identity and use checked storage
+        // directly, so later writes can change their inferred element type.
+        let literal = node;
+        while (ts.isParenthesizedExpression(literal))
+            literal = literal.expression;
+        if (isJsSourceFile(node.getSourceFile()) && !ts.isArrayLiteralExpression(literal) &&
+            e.kind === "dynFrom" && e.value.type.kind === "array") {
+            e = { ...e, liveRef: true };
+        }
         // An 'any' value PROVABLY null/undefined (the unit literal itself, or
         // a read of a binding nothing ever assigns a non-unit value) flowing
         // implicitly into a primitive slot: the validated exit refuses units
@@ -7401,6 +7761,20 @@ export class Lowerer {
             if (helper) {
                 e = { kind: "call", callee: helper, args: [e], type: expected, loc: e.loc };
             }
+            // Shipped JavaScript can select overloads using runtime brand data
+            // that its JSDoc union does not narrow. Preserve the numeric/string/
+            // boolean destination check, just as for an unknown-typed argument;
+            // never reinterpret an object payload as a scalar union arm.
+            if (e.type.kind === "union" && !typeEquals(e.type, expected) && isJsSourceFile(node.getSourceFile()) &&
+                this.dynConvertible(e.type)) {
+                const sourceArms = this.unions.get(e.type.unionId)?.arms ?? [];
+                const targetArms = this.unions.get(expected.unionId)?.arms ?? [];
+                if (sourceArms.some(isDynTypedRefType) && targetArms.length > 0 &&
+                    targetArms.every((arm) => isUnitType(arm) || arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool") &&
+                    targetArms.some((arm) => !isUnitType(arm) && sourceArms.some((source) => typeEquals(source, arm)))) {
+                    e = this.coerceToExpected(this.coerceToExpected(e, DYN), expected);
+                }
+            }
         }
         // A JS FUNC value outside the island marshal set flowing into a
         // jsval slot (`withPlugins(getSupportInfoWithoutPlugins, 0)` — a
@@ -7414,7 +7788,9 @@ export class Lowerer {
                 this.requireExactShape(node, e.type, expected);
             }
             catch (err) {
-                const fence = islandFuncValueFence(this, err, diagsBefore, node);
+                if (!(err instanceof PoisonError))
+                    throw err;
+                const fence = islandFuncValueFence(this, diagsBefore, node);
                 if (fence)
                     return fence;
                 throw err;
@@ -7492,53 +7868,146 @@ export class Lowerer {
             return null;
         return [...units].sort().join(" or ");
     }
-    /** Lowers an expression that flows into a slot of a known expected type,
-     * then applies the coercion path (coerceInto). An EMPTY array literal
-     * takes the slot's array type directly — the caller-supplied `expected`
-     * lowerArrayLiteral documents, for the positions where tsc's contextual
-     * API answers nothing (binding-element defaults: `{ json = [] }`) and
-     * the literal's own never[] would build the f64 representation. */
+    /** A key conversion may rebox or upcast a reference, but must never copy
+     * its referent. Apply the ordinary checked narrowing to absent arms from
+     * runtime-optional reads; only present reference arms participate here. */
+    lowerCollectionKey(node, expected) {
+        if (expected.kind === "dyn") {
+            const value = this.lowerExprExpecting(node, expected);
+            // An adapting promise changes identity, while the Error boundary
+            // snapshots mutable fields. Neither is a live collection reference.
+            const copiesReference = (type) => (type.kind === "promise" && type.inner.kind !== "dyn") ||
+                (type.kind === "object" && (RUNTIME_ERROR_CLASSES.has(type.className) || this.isSubclassOf(type.className, "%Error"))) ||
+                (type.kind === "union" && (this.unions.get(type.unionId)?.arms.some(copiesReference) ?? false));
+            if (value.kind === "dynFrom" && copiesReference(value.value.type)) {
+                this.noLowering("collection slot conversion requiring an Error snapshot or promise adapter", node, "use a collection with the original reference type; checked collection slots require identity-preserving conversions");
+            }
+            // Collections expose the stored reference again. Preserve records,
+            // arrays and byte views rather than taking the ordinary dyn snapshot.
+            const hasLiveReference = (type) => type.kind === "record" || type.kind === "array" || type.kind === "bytes" ||
+                (type.kind === "union" && (this.unions.get(type.unionId)?.arms.some(hasLiveReference) ?? false));
+            if (value.kind === "dynFrom" && hasLiveReference(value.value.type)) {
+                return { ...value, liveRef: true };
+            }
+            return value;
+        }
+        let literal = node;
+        while (ts.isParenthesizedExpression(literal))
+            literal = literal.expression;
+        // Fresh literals have no previous outer identity to preserve. Build them
+        // for their storage layout, just as ordinary contextual literals do.
+        if (ts.isObjectLiteralExpression(literal) || ts.isArrayLiteralExpression(literal) || expected.kind === "f64" || expected.kind === "string") {
+            return this.lowerExprExpecting(node, expected);
+        }
+        // Assertions can perform their own conversion before slot coercion.
+        // Inspect the assertion chain so a width copy cannot hide behind its
+        // already-converted result type. Union-arm checks only unwrap a box.
+        let asserted = literal;
+        while (ts.isAsExpression(asserted) || ts.isTypeAssertion(asserted) || ts.isNonNullExpression(asserted) || ts.isParenthesizedExpression(asserted)) {
+            if (ts.isAsExpression(asserted) || ts.isTypeAssertion(asserted)) {
+                const from = this.mapTypeOf(this.typeOf(asserted.expression));
+                const to = this.mapTypeOf(this.checker.getTypeFromTypeNode(asserted.type));
+                if (from?.kind === "dyn" || from?.kind === "jsval" || (from?.kind === "record" && to?.kind === "record" && !typeEquals(from, to))) {
+                    this.noLowering("collection key assertion requiring a structural copy or dynamic conversion", asserted, "use the original reference with the same type as the collection key");
+                }
+            }
+            asserted = asserted.expression;
+        }
+        const value = this.lowerExpr(node);
+        const source = (value.type.kind === "union" ? this.unions.get(value.type.unionId)?.arms ?? [] : [value.type]).filter((type) => !isUnitType(type));
+        const target = expected.kind === "union" ? this.unions.get(expected.unionId)?.arms ?? [] : [expected];
+        const preservesIdentity = source.length > 0 && source.every((from) => target.some((to) => typeEquals(from, to) || (from.kind === "object" && to.kind === "object" && this.isSubclassOf(from.className, to.className))));
+        if (!preservesIdentity || value.kind === "dynCheck" || value.kind === "jsExit") {
+            this.noLowering(`collection key conversion from '${this.fmt(value.type)}' to '${this.fmt(expected)}' requiring a structural copy or dynamic conversion`, node, "use the same reference type for the key and collection; copying a key would change its identity");
+        }
+        return this.coerceInto(node, value, expected);
+    }
+    /** Lower for a known destination, then apply ordinary value coercion.
+     * Fresh arrays and records use the destination layout directly. */
     lowerExprExpecting(node, expected) {
+        // These wrappers do not change the value or its inferred type. Keep a
+        // fresh literal visible to destination-directed construction. Assertions
+        // retain their own checked conversion and must not be erased here.
+        while (ts.isParenthesizedExpression(node) || ts.isSatisfiesExpression(node))
+            node = node.expression;
+        if (expected) {
+            if (ts.isConditionalExpression(node))
+                return lowerTernary(this, node, expected);
+            const fresh = this.emptyCollectionFor(node, expected);
+            if (fresh)
+                return this.coerceInto(node, fresh, expected);
+        }
         if (expected?.kind === "array") {
             let x = node;
             while (ts.isParenthesizedExpression(x))
                 x = x.expression;
-            if (ts.isArrayLiteralExpression(x) && x.elements.length === 0) {
+            // Fresh arrays are built for the actual destination, including
+            // nested literals whose checker context names a wider recursive
+            // union. Existing arrays still go through ordinary value coercion.
+            if (ts.isArrayLiteralExpression(x)) {
                 return this.coerceInto(node, this.lowerArrayLiteral(x, expected), expected);
             }
         }
+        if (expected?.kind === "record") {
+            let x = node;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isObjectLiteralExpression(x)) {
+                return this.coerceInto(node, this.lowerObjectLiteral(x, expected), expected);
+            }
+        }
+        if (expected?.kind === "union" && ts.isObjectLiteralExpression(node)) {
+            const def = this.unions.get(expected.unionId);
+            if (def?.discriminant) {
+                const property = this.checker.getPropertyOfType(this.typeOf(node), def.discriminant.field);
+                if (property && !(property.flags & (ts.SymbolFlags.Optional | ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor))) {
+                    const values = literalValues(this.checker.getTypeOfSymbol(property));
+                    const arm = values && this.literalUnionArm(def.id, values);
+                    if (arm)
+                        return this.coerceInto(node, this.lowerObjectLiteral(node, arm), expected);
+                }
+            }
+        }
         // An OBJECT LITERAL against a checked-dynamic slot in a JS file (the
         // getSupportInfo options argument — a dyn-ABI param), or against the
-        // standard RequestInit type in TypeScript: the value's world IS the
+        // standard native option-bag types in TypeScript: the value's world IS the
         // checked-dynamic tree — build the dyn literal directly.
         if (expected?.kind === "dyn") {
             let x = node;
             while (ts.isParenthesizedExpression(x))
                 x = x.expression;
+            // A fresh dense array entering a checked slot has no typed aliases.
+            // Construct its actual storage here so identity and WeakMap lifetime
+            // belong to the array the program keeps, rather than a typed snapshot.
+            if (ts.isArrayLiteralExpression(x) && x.elements.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
+                return { kind: "dynArrLit", elems: x.elements.map((element) => this.lowerExprExpecting(element, DYN)), type: DYN, loc: locOf(x) };
+            }
+            const contextual = this.checker.getContextualType(x);
+            const widened = contextual ? this.checker.getBaseTypeOfLiteralType(contextual) : undefined;
+            const parts = widened?.isUnionType() ? ts.constituentTypes(widened) : widened ? [widened] : [];
+            const builtinOption = (name) => parts.some((part) => {
+                const sym = part.getAliasSymbol() ?? part.getSymbol();
+                return sym?.name === name && this.isStdlibSymbol(sym);
+            });
             if (ts.isObjectLiteralExpression(x)) {
-                const contextual = this.checker.getContextualType(x);
-                const widened = contextual
-                    ? this.checker.getBaseTypeOfLiteralType(contextual)
-                    : undefined;
-                const sym = widened?.getAliasSymbol() ?? widened?.getSymbol();
-                const requestInit = sym?.name === "RequestInit" && this.isStdlibSymbol(sym);
-                if (isJsSourceFile(x.getSourceFile()) || requestInit) {
+                if (isJsSourceFile(x.getSourceFile()) || builtinOption("RequestInit") || builtinOption("ErrorOptions") || builtinOption("SpawnOptions") ||
+                    !this.mapTypeOf(this.typeOf(x))) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
         }
-        // An ARRAY LITERAL against a UNION slot whose own type has no static
-        // home (the JS dyn fallback — the checker gave no usable context):
-        // when the union has exactly ONE array-family arm — an array, or an
-        // arity-matching tuple (the option-table `default: [{ value: [] }]`
-        // shape) — build AS that arm and wrap; the IR-directed twin of
-        // lowerArrayLiteral's contextual-union rule.
+        // A fresh array can use the unique array-family destination inside a
+        // union too. In nullable recursive fields the checker can report the
+        // whole union as context: an identity lift of that context does not
+        // mean the literal's independently inferred element layout fits.
+        // Construct the elements for the selected arm before wrapping it.
+        // When several array arms fit a fresh literal, any complete element
+        // layout is valid: the new array has no existing aliases to preserve.
         if (expected?.kind === "union") {
             let x = node;
             while (ts.isParenthesizedExpression(x))
                 x = x.expression;
             if (ts.isArrayLiteralExpression(x)) {
-                const own = this.mapTypeOf(this.checker.getContextualType(x) ?? this.typeOf(x));
                 // Elements beyond bare null/undefined literals can never live in
                 // a unit-only-element array — a checker type that degraded to one
                 // (`[]`-flavored inference over a populated literal) carries no
@@ -7546,26 +8015,60 @@ export class Lowerer {
                 const nonUnitElems = x.elements.some((el) => !ts.isOmittedExpression(el) &&
                     el.kind !== ts.SyntaxKind.NullKeyword &&
                     !(ts.isIdentifier(el) && el.text === "undefined"));
-                if (own === null || own.kind === "dyn" || own.kind === "jsval" ||
-                    (own.kind === "array" && nonUnitElems && this.unitOnlyElem(own.elem)) ||
-                    this.widthLiftPlan(own, expected) === null) {
-                    const def = this.unions.get(expected.unionId);
-                    const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && this.unitOnlyElem(a.elem))) ||
-                        (a.kind === "record" &&
-                            !!this.shapes.get(a.shapeId)?.tuple &&
-                            this.shapes.get(a.shapeId).fields.length === x.elements.length &&
-                            !x.elements.some(ts.isSpreadElement)));
-                    if (arms.length === 1) {
-                        const arm = arms[0];
-                        const built = this.lowerArrayLiteral(x, arm);
-                        return this.coerceInto(node, built, expected);
+                const def = this.unions.get(expected.unionId);
+                const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && this.unitOnlyElem(a.elem))) ||
+                    (a.kind === "record" &&
+                        !!this.shapes.get(a.shapeId)?.tuple &&
+                        this.shapes.get(a.shapeId).fields.length === x.elements.length &&
+                        !x.elements.some(ts.isSpreadElement)));
+                let arm = arms.length === 1 ? arms[0] : undefined;
+                if (!arm && arms.length > 1 && x.elements.length > 0 &&
+                    x.elements.every((el) => !ts.isSpreadElement(el) && !ts.isOmittedExpression(el))) {
+                    const ownType = this.mapTypeOf(this.typeOf(x));
+                    arm = arms.find((candidate) => ownType !== null && typeEquals(candidate, ownType));
+                    if (!arm) {
+                        const elements = x.elements.map((el) => tryLowerExpression(this, el));
+                        arm = arms.find((candidate) => candidate.kind === "array" &&
+                            elements.every((element) => element !== null && this.widthLiftPlan(element.type, candidate.elem) !== null));
                     }
                 }
+                if (arm) {
+                    const built = this.lowerArrayLiteral(x, arm);
+                    return this.coerceInto(node, built, expected);
+                }
             }
         }
-        const e = this.lowerExpr(node);
+        let e = this.lowerExpr(node);
+        if (expected?.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) {
+            // A destination that accepts undefined must retain an unchecked
+            // read's storage value even when the checker still calls it present.
+            e = this.runtimeOptionalSourceValue(node, e) ?? e;
+        }
         return expected ? this.coerceInto(node, e, expected) : e;
     }
+    /** An unannotated empty collection has no existing elements or aliases
+     * that constrain its layout. An explicit type argument still wins. */
+    emptyCollectionFor(node, expected) {
+        let value = node;
+        while (ts.isParenthesizedExpression(value))
+            value = value.expression;
+        if (!ts.isNewExpression(value) || !ts.isIdentifier(value.expression) || (value.arguments?.length ?? 0) !== 0 ||
+            (value.typeArguments?.length ?? 0) !== 0)
+            return null;
+        const symbol = this.resolveValueSymbol(value.expression);
+        if (!symbol || !this.isStdlibSymbol(symbol))
+            return null;
+        const kind = symbol.name === "Map" ? "map" : symbol.name === "Set" ? "set" : null;
+        if (!kind)
+            return null;
+        const arms = expected.kind === "union" ? this.unions.get(expected.unionId)?.arms ?? [] : [expected];
+        const candidates = arms.filter((arm) => arm.kind === kind);
+        if (candidates.length !== 1)
+            return null;
+        const type = candidates[0];
+        return type.kind === "map" ? { kind: "mapNew", type, loc: locOf(value) }
+            : type.kind === "set" ? { kind: "setNew", type, loc: locOf(value) } : null;
+    }
     /** A value flowing into an index-signature VALUE slot (an overflow
      * literal entry, a dynamic-keyed record write). dyn slots (`unknown`
      * signatures — ModelPricing's) take a dyn conversion: dyn values pass
@@ -7623,6 +8126,22 @@ export class Lowerer {
      * nothing evaluates; unit-typed non-literals keep the fences. */
     lowerReturnValue(node) {
         const expected = this.ctx.returnType;
+        // A return slot supplies the same construction layout as an argument
+        // or initializer. In particular, contextual callbacks can return fresh
+        // arrays of recursive unions and nullable, unannotated collections.
+        // Async returns still resolve a promise before converting its payload.
+        if (!this.ctx.isAsync && expected.kind !== "void")
+            return this.lowerExprExpecting(node, expected);
+        // Fresh JS objects returned through a checked-native ABI use that
+        // storage directly, just like arguments and variable initializers.
+        // Contextual types (such as Proxy descriptors' symbol-valued fields)
+        // must not force an intermediate record with incompatible field slots.
+        let literal = node;
+        while (ts.isParenthesizedExpression(literal))
+            literal = literal.expression;
+        if (expected.kind === "dyn" && isJsSourceFile(node.getSourceFile()) && ts.isObjectLiteralExpression(literal)) {
+            return this.lowerExprExpecting(node, expected);
+        }
         const e = this.lowerExpr(node);
         if (expected.kind === "void" && e.kind === "unitLit")
             return null;
@@ -7683,14 +8202,17 @@ export class Lowerer {
     stripUndefinedArm(t) {
         if (t.kind !== "union")
             return t;
+        const cached = this.strippedUndefinedArms.get(t.unionId);
+        if (cached && cached.unions === this.unions.revision)
+            return cached.type;
         const def = this.unions.get(t.unionId);
-        if (!def || !def.arms.some((a) => a.kind === "undefinedT"))
+        if (!def || this.armTag(t.unionId, UNDEFINED_T) < 0)
             return t;
         const rest = def.arms.filter((a) => a.kind !== "undefinedT");
-        if (rest.length === 1)
-            return rest[0];
         // Removing an arm keeps canonical (typeKey-sorted) order.
-        return { kind: "union", unionId: this.unions.intern(rest) };
+        const type = rest.length === 1 ? rest[0] : { kind: "union", unionId: this.unions.transform(def, rest) };
+        this.strippedUndefinedArms.set(t.unionId, { type, unions: this.unions.revision });
+        return type;
     }
     /** The interned `T | undefined` union over a non-union arm type — the ABI
      * type of a defaulted parameter, and the result type of lookups that may
@@ -7751,13 +8273,14 @@ export class Lowerer {
      * symbol reports eagerly (nothing could ever reference it). */
     collectDeferring(symbolOf, collect) {
         const sink = [];
+        const previousSink = this.diagSink;
         this.diagSink = sink;
         try {
             collect();
             return null;
         }
         catch (e) {
-            this.diagSink = null;
+            this.diagSink = previousSink;
             const symbol = (() => {
                 // symbolOf queries the checker too — a second panic must not
                 // escape the fence that is handling the first.
@@ -7790,7 +8313,7 @@ export class Lowerer {
             return symbol;
         }
         finally {
-            this.diagSink = null;
+            this.diagSink = previousSink;
         }
     }
     /** Pushes a symbol's deferred collection diagnostics: lowering resolved
@@ -7962,7 +8485,7 @@ export class Lowerer {
      * members ride fp.classDecls; expressions register only when their
      * containing statement lowers). */
     exprClasses = [];
-    exprClassInfoByNode = new Map();
+    exprClassInfoByName = new Map();
     /** Class expressions whose collection is IN FLIGHT — the reentrancy
      * guard for heritage-demanded collection (lowerClassExpressionInfo). */
     collectingExprClasses = new Set();
@@ -7971,6 +8494,8 @@ export class Lowerer {
      * BEFORE that statement (JS's order for the supported whole-initializer
      * positions). */
     pendingClassExprInits = [];
+    computedClassBases = new Map();
+    computedCallableBases = new Map();
     /** Discovery hook: registers a just-collected expression class's member
      * bodies as worklist units (the units map is otherwise built before
      * lowering starts). Null in the emit pass. */
@@ -8016,8 +8541,8 @@ export class Lowerer {
      * onExprClassCollected should instantiations ever need eager
      * registration. */
     onLateClassCollected = null;
-    genericClassInstanceType(decl, ref) {
-        return genericClassInstanceType(this, decl, ref);
+    genericClassInstanceType(decl, ref, mapArgument) {
+        return genericClassInstanceType(this, decl, ref, mapArgument);
     }
     findStaticOn(info, name) {
         return findStaticOn(this, info, name);
@@ -8059,11 +8584,7 @@ export class Lowerer {
             // Computed method names resolve exactly like collection did
             // (classMemberNameOf — folded keys and the sym:iterator slot);
             // unresolvable ones never collected, so they skip here too.
-            const baseName = ts.isMethodDeclaration(fnLike)
-                ? classMemberNameOf(this, fnLike.name)
-                : ts.isIdentifier(fnLike.name) || ts.isPrivateIdentifier(fnLike.name)
-                    ? fnLike.name.text
-                    : null;
+            const baseName = classMemberNameOf(this, fnLike.name);
             if (baseName === null)
                 continue;
             const mName = ts.isMethodDeclaration(fnLike) ? baseName : `${ts.isGetAccessor(fnLike) ? "get" : "set"}:${baseName}`;
@@ -8090,14 +8611,10 @@ export class Lowerer {
     superCallStmt(info, thisLocal, args, loc) {
         return superCallStmt(this, info, thisLocal, args, loc);
     }
-    /** Declares the `this` param local, registered under the THIS_BINDING
-     * sentinel so lexical-this capture in arrows uses the normal machinery. */
+    /** Declares the this parameter in the function's dedicated binding slot.
+     * Arrow captures use the same boxing and threading as named bindings. */
     declareThis(type) {
-        const ctx = this.ctx;
-        const local = { id: "this.0", name: "this", type, mutable: false };
-        ctx.locals.push(local);
-        ctx.scopes[ctx.scopes.length - 1].set(THIS_BINDING, local);
-        return local;
+        return declareContextThis(this.ctx, type);
     }
     lowerFunction(decl) {
         return lowerFunction(this, decl);
@@ -8116,26 +8633,13 @@ export class Lowerer {
     }
     /* ── scoping and captures ─────────────────────────────────────────── */
     declareLocal(nameNode, name, type, mutable) {
-        const ctx = this.ctx;
-        const count = ctx.localCounters.get(name) ?? 0;
-        ctx.localCounters.set(name, count + 1);
-        const local = { id: `${name}.${count}`, name, type, mutable, source: bindingSource(nameNode) };
-        ctx.locals.push(local);
-        const symbol = this.checker.getSymbolAtLocation(nameNode);
-        if (symbol)
-            ctx.scopes[ctx.scopes.length - 1].set(symbol, local);
-        return local;
+        return declareContextLocal(this.ctx, name, type, mutable, this.checker.getSymbolAtLocation(nameNode), bindingSource(nameNode));
     }
     /** A function-scope local bound to NO ts.Symbol — the hidden ABI slot of a
      * defaulted parameter (the parameter's symbol binds to the separately-
      * declared body local; nothing in the source can name this one). */
     declareHiddenLocal(name, type) {
-        const ctx = this.ctx;
-        const count = ctx.localCounters.get(name) ?? 0;
-        ctx.localCounters.set(name, count + 1);
-        const local = { id: `${name}.${count}`, name, type, mutable: false };
-        ctx.locals.push(local);
-        return local;
+        return declareContextLocal(this.ctx, name, type, false, undefined, undefined);
     }
     /** Declares a callee's parameter locals from its ParamShapes and builds
      * the DEFAULT-PARAM PROLOGUE. Required/optional/rest params bind their
@@ -8158,6 +8662,13 @@ export class Lowerer {
         const decls = rawDecls.filter((p) => !isThisParameter(p));
         const params = [];
         const prologue = [];
+        const defaultValue = (node, expected) => {
+            const undefinedValue = lowerStaticallyUndefinedArgument(this, node);
+            if (undefinedValue === null)
+                return this.lowerExprExpecting(node, expected);
+            const absent = { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(node) };
+            return defaultAfterUndefined(undefinedValue, this.coerceInto(node, absent, expected));
+        };
         decls.forEach((decl, i) => {
             const shape = shapes[i];
             if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
@@ -8184,7 +8695,7 @@ export class Lowerer {
                         // dynamic dyn): the slot holds its tier's undefined directly,
                         // so the default test is the runtime undefined test — then
                         // the pattern destructures the picked value.
-                        const dflt = this.lowerExprExpecting(decl.initializer, abi);
+                        const dflt = defaultValue(decl.initializer, abi);
                         const src = this.declareHiddenLocal("%psrc", abi);
                         const inRef = () => ({ kind: "varRef", localId: slot.id, type: abi, loc });
                         const isUndef = abi.kind === "jsval"
@@ -8199,6 +8710,16 @@ export class Lowerer {
                         const pickedT = abi;
                         srcType = pickedT;
                         srcRef = () => ({ kind: "varRef", localId: src.id, type: pickedT, loc });
+                        // An empty object pattern still rejects null after applying
+                        // the default. With no property reads, nothing else performs
+                        // RequireObjectCoercible; use V8's default-expression spelling.
+                        if (abi.kind === "dyn" && ts.isObjectBindingPattern(decl.name) && decl.name.elements.length === 0) {
+                            prologue.push({
+                                kind: "exprStmt",
+                                expr: { kind: "dynDestrCheck", value: srcRef(), spelling: "(intermediate value)(intermediate value)(intermediate value)", type: DYN, loc },
+                                loc,
+                            });
+                        }
                         this.lowerBindingPattern(decl.name, srcRef, srcType, true, prologue);
                         return;
                     }
@@ -8228,7 +8749,7 @@ export class Lowerer {
                     }
                     if (!present)
                         this.unsupported("SC1090", decl, "this parameter form"); // defensive: abi = bodyType + undefined by construction
-                    const dflt = this.lowerExprExpecting(decl.initializer, shape.bodyType);
+                    const dflt = defaultValue(decl.initializer, shape.bodyType);
                     const src = this.declareHiddenLocal("%psrc", shape.bodyType);
                     prologue.push({
                         kind: "varDecl",
@@ -8258,7 +8779,7 @@ export class Lowerer {
                     const isUndef = abi.kind === "jsval"
                         ? { kind: "jsOp", op: "eq", args: [inRef(), { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }], type: BOOL, loc }
                         : { kind: "dynTest", test: "undefined", value: inRef(), type: BOOL, loc };
-                    const dflt = this.lowerExprExpecting(decl.initializer, abi);
+                    const dflt = defaultValue(decl.initializer, abi);
                     const body = this.declareLocal(decl.name, name, abi, true);
                     prologue.push({
                         kind: "varDecl",
@@ -8282,7 +8803,7 @@ export class Lowerer {
                     // the body keeps the full `T | undefined` union (tsc's type),
                     // so a present argument passes through unchanged and an omitted
                     // one takes the default AS IS — no narrow on either branch.
-                    const dflt = this.lowerExprExpecting(decl.initializer, abi);
+                    const dflt = defaultValue(decl.initializer, abi);
                     const body = this.declareLocal(decl.name, name, abi, true);
                     prologue.push({
                         kind: "varDecl",
@@ -8308,7 +8829,7 @@ export class Lowerer {
                     const retag = this.unionRetagHelper(abi.unionId, shape.bodyType.unionId, loc);
                     if (!retag)
                         this.unsupported("SC1090", decl, "this parameter form"); // defensive
-                    const dflt = this.lowerExprExpecting(decl.initializer, shape.bodyType);
+                    const dflt = defaultValue(decl.initializer, shape.bodyType);
                     const body = this.declareLocal(decl.name, name, shape.bodyType, true);
                     prologue.push({
                         kind: "varDecl",
@@ -8331,7 +8852,7 @@ export class Lowerer {
                 // The default lowers BEFORE the body local binds, so a same-named
                 // outer binding referenced in it can never resolve to the fresh
                 // local (tsc separately rejects `x = x`).
-                const dflt = this.lowerExprExpecting(decl.initializer, shape.bodyType);
+                const dflt = defaultValue(decl.initializer, shape.bodyType);
                 const body = this.declareLocal(decl.name, name, shape.bodyType, true);
                 prologue.push({
                     kind: "varDecl",
@@ -8364,12 +8885,7 @@ export class Lowerer {
     /** The binding for `symbol` inside context `ctx` — a scoped local or an
      * already-threaded capture entry. */
     bindingIn(ctx, symbol) {
-        for (let i = ctx.scopes.length - 1; i >= 0; i--) {
-            const local = ctx.scopes[i].get(symbol);
-            if (local)
-                return local;
-        }
-        return ctx.captureBySymbol.get(symbol) ?? null;
+        return bindingInContext(ctx, symbol);
     }
     /** Resolves an identifier to a local of the CURRENT function, creating
      * capture entries (and boxing the origin binding) when the name lives in
@@ -8408,7 +8924,7 @@ export class Lowerer {
      * through arrows (function expressions/declarations reset `this` in JS;
      * their bodies never see an enclosing method's binding). */
     resolveThis() {
-        return this.resolveKey(THIS_BINDING);
+        return this.resolveKey(undefined);
     }
     /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
      * the nearest binding entry without boxing, threading, or predeclaring.
@@ -8432,75 +8948,21 @@ export class Lowerer {
         return null;
     }
     resolveKey(symbol, blame) {
-        const direct = this.bindingIn(this.ctx, symbol);
-        if (direct)
-            return direct;
-        // Search enclosing functions, innermost first.
-        for (let depth = this.fnStack.length - 2; depth >= 0; depth--) {
-            const origin = this.bindingIn(this.fnStack[depth], symbol);
-            if (!origin)
-                continue;
-            // dyn captures ride an UNTRACED obj-box (scr_dyn_retain_v/release_v
-            // — boxNewC): the mustCall wrapper closing over its implicit-any
-            // `fn` param. A dyn tree is pure data except the function kind,
-            // whose closure edge the collector never sees — cycles through a
-            // captured dyn are uncollectable (leak, never dangle: trial
-            // deletion treats untraced edges as external roots). SEMANTICS.md.
-            // jsval captures are fine: the box is an obj-box carrying the
-            // island handle's own retain/release (scr_jsval_*_v), untraced like
-            // every jsval container position — engine-side back-references are
-            // the island's documented collection stance, not the box's.
-            if (origin.type.kind === "caught") {
-                // A catch binding never escapes its catch (KEEP NARROW): narrow it
-                // into a typed local and capture THAT.
-                this.unsupported("SC1090", blame ?? this.checker.declarationsOf(symbol)[0] ?? this.entry, "closures capturing catch bindings (narrow into a typed local first)");
-            }
-            // The binding escapes into a nested function: it must live in a box,
-            // shared by everyone (that's what makes mutation visible everywhere).
-            origin.boxed = true;
-            // Thread a capture through every function between origin and here.
-            let parentEntry = origin;
-            for (let j = depth + 1; j < this.fnStack.length; j++) {
-                const ctx = this.fnStack[j];
-                let entry = ctx.captureBySymbol.get(symbol);
-                if (!entry) {
-                    // A context that takes NO captures (a plain declared function —
-                    // monomorphized/implicit instances lower this way) cannot carry
-                    // the binding through: the shape is a module binding whose only
-                    // storage is the init function's LOCAL (a typed-but-unmappable
-                    // const — the file-scope `new Map()` ledger idiom) read from
-                    // inside a nested instance. Fence it — in JS the statement
-                    // defers to its runtime trap like every collection failure;
-                    // asserting here was an ICE on ordinary npm-static JS.
-                    if (ctx.captures === null) {
-                        this.unsupported("SC1090", blame ?? this.checker.declarationsOf(symbol)[0] ?? this.entry, `the binding '${origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`);
-                    }
-                    const count = ctx.localCounters.get(origin.name) ?? 0;
-                    ctx.localCounters.set(origin.name, count + 1);
-                    entry = {
-                        id: `${origin.name}.${count}`,
-                        name: origin.name,
-                        type: origin.type,
-                        mutable: origin.mutable,
-                        boxed: true,
-                        ...(origin.source ? { source: origin.source } : {}),
-                        // TDZ travels with the binding: reads through ANY capture of a
-                        // forward-captured const must trap while the box is empty.
-                        ...(origin.tdz ? { tdz: true } : {}),
-                    };
-                    ctx.locals.push(entry);
-                    ctx.captureBySymbol.set(symbol, entry);
-                    ctx.captures.push({ localId: entry.id, name: entry.name, type: entry.type });
-                    ctx.captureSources.push(parentEntry.id);
-                    const runtimeOptionalRoot = this.runtimeOptionalRootOf(parentEntry);
-                    if (this.runtimeOptionalStorageLocals.has(runtimeOptionalRoot)) {
-                        this.runtimeOptionalRoots.set(entry, runtimeOptionalRoot);
-                    }
-                }
-                parentEntry = entry;
-            }
-            return parentEntry;
-        }
+        const resolved = captureContextBinding(this.fnStack, symbol, (parentEntry, entry) => {
+            const root = this.runtimeOptionalRootOf(parentEntry);
+            if (this.runtimeOptionalStorageLocals.has(root))
+                this.runtimeOptionalRoots.set(entry, root);
+        });
+        if (resolved.error !== null) {
+            const location = blame ?? (symbol === undefined ? undefined : this.checker.declarationsOf(symbol)[0]) ?? this.entry;
+            const message = `the binding '${resolved.origin.name}' captured through a plain nested function (the declaration has no static storage a capture can thread — bind the value through a typed const, or read it in the declaring scope)`;
+            this.unsupported("SC1090", location, message);
+        }
+        if (resolved.local !== null)
+            return resolved.local;
+        // This cannot be forward-declared: its parameter must already exist.
+        if (symbol === undefined)
+            return null;
         // Nothing declared yet anywhere on the stack: the hoisted-handler shape
         // — a function declared BEFORE a const it captures (`const cleanup =
         // () => onSigInt; ...; const onSigInt = ...`). Pre-declare the const as
@@ -8566,21 +9028,10 @@ export class Lowerer {
         // binding-form text.
         if (symbol) {
             const d = this.checker.valueDeclarationOf(symbol);
-            if (d && ts.isVariableDeclaration(d) && ts.isVariableDeclarationList(d.parent) &&
-                (d.parent.flags & ts.NodeFlags.Const) !== 0) {
-                const codec = textCodecBindingClassOf(this, d.name, d.initializer);
-                if (codec !== null) {
-                    const call = codec === "TextEncoder" ? `${name}.encode(s)` : `${name}.decode(bytes)`;
-                    const composed = codec === "TextEncoder"
-                        ? "new TextEncoder().encode(s)"
-                        : "new TextDecoder().decode(bytes)";
-                    this.noLowering(`${codec} instance stored in ${name}`, node, `${call} compiles through this const; the codec object itself has no representation (the composed ${composed} form also compiles)`);
-                }
-            }
             if (d && ts.isVariableDeclaration(d) && d.initializer === undefined) {
                 const t = this.checker.getTypeOfSymbol(symbol);
                 const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
-                if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => (s.typeParameters?.length ?? 0) > 0))) {
+                if (parts.some((p) => this.checker.getCallSignatures(p).some((s) => s.getTypeParameters().length > 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)`);
                 }
             }
@@ -8893,7 +9344,16 @@ export class Lowerer {
         return isStdlibMember(this, access);
     }
     isStdlibSymbol(symbol) {
-        return isStdlibSymbol(this, symbol);
+        if (!symbol)
+            return false;
+        const cached = this.stdlibSymbols.get(symbol);
+        if (cached !== undefined)
+            return cached;
+        // A compilation's checker declarations and library provenance are fixed.
+        // Global alias and narrowing state remain outside this symbol-only cache.
+        const result = isStdlibSymbol(this, symbol);
+        this.stdlibSymbols.set(symbol, result);
+        return result;
     }
     isStdlibGlobal(expr, name) {
         return isStdlibGlobal(this, expr, name);
@@ -8904,8 +9364,8 @@ export class Lowerer {
     lowerArrayLiteral(expr, expected) {
         return lowerArrayLiteral(this, expr, expected);
     }
-    lowerObjectLiteral(expr) {
-        return lowerObjectLiteral(this, expr);
+    lowerObjectLiteral(expr, expected) {
+        return lowerObjectLiteral(this, expr, expected);
     }
     lowerShorthandValue(prop) {
         return lowerShorthandValue(this, prop);
@@ -9203,8 +9663,8 @@ export class Lowerer {
     lowerFieldCompound(access, op, rhsNode, loc) {
         return lowerFieldCompound(this, access, op, rhsNode, loc);
     }
-    errorMessageArg(args, loc, blame) {
-        return errorMessageArg(this, args, loc, blame);
+    errorConstructorArgs(args, loc, blame) {
+        return errorConstructorArgs(this, args, loc, blame);
     }
     inheritsBuiltinErrorCtor(info) {
         return inheritsBuiltinErrorCtor(this, info);
@@ -9235,7 +9695,7 @@ export class Lowerer {
             const arg = this.lowerExpr(expr.arguments[0]);
             return { kind: "jsOp", op: "construct", args: [ctor, arg], type: JSVAL, loc };
         }
-        const builtin = lowerAbortControllerNew(this, expr) ?? lowerResponseNew(this, expr) ?? lowerStaticReadableStreamNew(this, expr);
+        const builtin = lowerAbortControllerNew(this, expr) ?? lowerFetchWebNew(this, expr) ?? lowerResponseNew(this, expr) ?? lowerStaticReadableStreamNew(this, expr);
         return builtin ?? this.withRuntimeOptionalClassValue(expr.expression, () => lowerNew(this, expr));
     }
     lowerFieldRead(expr) {
@@ -9384,7 +9844,7 @@ export class Lowerer {
             }
             if (!ts.isNamespaceImport(decl))
                 return null;
-            const importDecl = decl.parent.parent;
+            const importDecl = decl.parent?.parent;
             if (!ts.isImportDeclaration(importDecl) || !ts.isStringLiteral(importDecl.moduleSpecifier))
                 return null;
             return canonicalBuiltinModule(importDecl.moduleSpecifier.text);
@@ -9404,6 +9864,16 @@ export class Lowerer {
     builtinMemberOf(access) {
         if (access.questionDotToken)
             return null;
+        // Function-owned builtin members still require import provenance. A
+        // user object named realpathSync must retain its ordinary method call.
+        if (access.name.text === "native") {
+            const owner = access.expression;
+            const imported = ts.isIdentifier(owner) ? this.builtinImportOf(owner)
+                : ts.isPropertyAccessExpression(owner) ? this.builtinMemberOf(owner) : null;
+            if (imported?.module === "fs" && imported.member === "realpathSync") {
+                return { module: "fs", member: "realpathSync.native" };
+            }
+        }
         const module = this.builtinNamespaceModuleOf(access.expression);
         if (module !== null)
             return { module, member: access.name.text };
@@ -9507,10 +9977,10 @@ export class Lowerer {
         if (!expr.questionDotToken && ts.isPropertyAccessExpression(expr.expression)) {
             const inner = this.builtinMemberOf(expr.expression);
             if (inner && inner.module === "fs" && inner.member === "constants") {
-                const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4 };
+                const MODES = { F_OK: 0, X_OK: 1, W_OK: 2, R_OK: 4, COPYFILE_EXCL: 1, COPYFILE_FICLONE: 2, COPYFILE_FICLONE_FORCE: 4 };
                 const value = own(MODES, expr.name.text);
                 if (value === undefined) {
-                    this.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+                    this.noLowering(`fs.constants.${expr.name.text}`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
                 }
                 return { kind: "numLit", value, type: F64, loc };
             }
@@ -9518,6 +9988,10 @@ export class Lowerer {
         const bi = this.builtinMemberOf(expr);
         if (!bi)
             return null;
+        if ((bi.module === "path" || bi.module === "path/posix" || bi.module === "path/win32") &&
+            (bi.member === "posix" || bi.member === "win32")) {
+            return pathModuleValue(this, `path/${bi.member}`, loc);
+        }
         // events.defaultMaxListeners READS the process-wide default (its
         // write twin routes through emitter.setDefaultMaxChk).
         if (bi.module === "events" && bi.member === "defaultMaxListeners") {
@@ -9544,17 +10018,16 @@ export class Lowerer {
             if (roots)
                 return roots;
         }
-        // TypeScript builtin values admitted by an explicit surface-table
-        // contract materialize as interned closures. JavaScript sources retain
-        // their established builtin identity-token/fence policy.
-        if (!isJsSourceFile(expr.getSourceFile())) {
+        // Builtin values admitted by an explicit surface-table contract use
+        // the same interned native closures in TypeScript and JavaScript.
+        {
             const callable = this.lowerBuiltinCallableValue(bi, loc);
             if (callable)
                 return callable;
         }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
-            this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");
+            this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, X_OK, and COPYFILE_* are the lowered constants");
         }
         if (builtinModuleFnOf(this, bi.module, bi.member)) {
             this.unsupported("SC1090", expr, `library functions as values (call '${expr.getText()}' directly)`);
@@ -9567,9 +10040,15 @@ export class Lowerer {
      * deliberately narrower than table membership because many table rows
      * are only dispatch sentinels for call-site-specific lowering. */
     lowerBuiltinCallableValue(bi, loc) {
+        if (bi.module === "fs" && builtinModuleFnOf(this, bi.module, bi.member)?.fn === "fs.callbackCall") {
+            return { kind: "libCall", fn: "fs.callbackValue", args: [{ kind: "strLit", value: bi.member, type: STRING, loc }], type: DYN, loc };
+        }
         const fn = builtinModuleFnOf(this, bi.module, bi.member);
-        const valueParams = fn?.valueParams;
-        if (!fn || !valueParams)
+        return fn ? this.lowerNativeCallableValue(fn, `${bi.module}.${bi.member}`, loc) : null;
+    }
+    lowerNativeCallableValue(fn, display, loc) {
+        const valueParams = fn.valueParams;
+        if (!valueParams)
             return null;
         const shapes = valueParams.map((param) => {
             if (param.mode === "rest")
@@ -9593,10 +10072,10 @@ export class Lowerer {
                 name: `arg${index}`,
                 type,
             }));
-            const args = params.map((param, index) => {
-                const valueParam = valueParams[index];
-                if (!valueParam) {
-                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has a missing value parameter`);
+            const args = valueParams.map((valueParam, index) => {
+                const param = params[index];
+                if (!param || !valueParam) {
+                    throw new InternalCompilerError(`builtin callable value '${display}' has a missing value parameter`);
                 }
                 const ref = {
                     kind: "varRef",
@@ -9606,13 +10085,13 @@ export class Lowerer {
                 };
                 if (valueParam.mode !== "optional")
                     return ref;
-                if (valueParam.type.kind !== "string" || param.type.kind !== "union") {
-                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has an unsupported optional default`);
+                if ((valueParam.type.kind !== "string" && valueParam.type.kind !== "f64") || param.type.kind !== "union") {
+                    throw new InternalCompilerError(`builtin callable value '${display}' has an unsupported optional default`);
                 }
                 const undefTag = this.armTag(param.type.unionId, UNDEFINED_T);
                 const valueTag = this.armTag(param.type.unionId, valueParam.type);
                 if (undefTag < 0 || valueTag < 0) {
-                    throw new InternalCompilerError(`builtin callable value '${bi.module}.${bi.member}' has an invalid optional ABI`);
+                    throw new InternalCompilerError(`builtin callable value '${display}' has an invalid optional ABI`);
                 }
                 return {
                     kind: "ternary",
@@ -9625,7 +10104,9 @@ export class Lowerer {
                         type: BOOL,
                         loc,
                     },
-                    then: { kind: "strLit", value: valueParam.defaultValue, type: STRING, loc },
+                    then: typeof valueParam.defaultValue === "string"
+                        ? { kind: "strLit", value: valueParam.defaultValue, type: STRING, loc }
+                        : { kind: "numLit", value: valueParam.defaultValue, type: F64, loc },
                     else_: {
                         kind: "unionNarrow",
                         unionId: param.type.unionId,