@scriptc/compiler 0.2.0 → 0.2.2

package/dist/frontend/lowering/lowerer.js

@@ -1,4 +1,5 @@
-import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { pathModuleValue } from "./lower-builtin-values.js";
+import { everyExprChild, everyStmtChild, transformStmtList } 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";
@@ -8,7 +9,8 @@ import { bindingInContext, captureContextBinding, declareContextLocal, declareCo
 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 { ClassDynamicDispatch, trackClassFieldCreation } from "./class-dynamic-dispatch.js";
+import { DeferredModuleInitializers } from "./deferred-module-initializers.js";
 import { finalizeClassMethodValues } from "./class-method-values.js";
 /* AST + checker → IR.
  *
@@ -29,14 +31,14 @@ import { bindingSource } from "../binding-source.js";
 import { tsgoPath } from "../dts-paths.js";
 import * as ts from "../ts7/adapter.js";
 import { literalValues } from "../literal-values.js";
-import { literalUnionArm } from "../union-discriminants.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, 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 { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalNameOf, 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, errorConstructorArgs, lowerNew, accessorCall } from "./lower-classes.js";
@@ -50,14 +52,14 @@ import { lowerRegexMethodCall, lowerStringMethodCall } from "./containers/string
 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 } 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 { 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";
 import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js";
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr } from "./lower-comptime.js";
-import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
+import { lowerStmts, hasJsTypeAnnotation, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, isParseArgsDynCheckerType, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
 import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf } from "./lower-exprs.js";
 import { finishOptionalChain, isOptionalChainTail, lowerOptionalChain } from "./expressions/optional-chains.js";
 import { foldedStringKeyOf, lowerDynObjectLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod } from "./expressions/object-literals.js";
@@ -514,6 +516,14 @@ 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.
@@ -742,18 +752,34 @@ function anyPiecedFuncType(lowerer, node, t) {
         return null;
     return { kind: "func", params, ret };
 }
-/** The best-effort JS `Function.prototype.name` of an expression flowing
- * into a dyn slot (the boxed function kind's inspect/error name):
- * identifier and property reads answer the referenced NAME (a
- * REFERENCE-SITE approximation of JS's creation-site naming — an aliased
- * binding reports the alias; SEMANTICS.md), named function expressions
+/** The JS `Function.prototype.name` of an expression flowing into a dyn
+ * slot. Immutable identifier aliases retain their creation-site name; property
+ * reads answer the referenced name. Named function expressions
  * their own name, anonymous function/arrow expressions their
  * NamedEvaluation home (a variable initializer or property assignment).
  * Null when nothing names the value (the box stays anonymous). */
-export function jsFuncNameOf(node) {
+export function jsFuncNameOf(node, lowerer) {
     let n = node;
     while (ts.isParenthesizedExpression(n))
         n = n.expression;
+    const seen = new Set();
+    while (lowerer && ts.isIdentifier(n)) {
+        const symbol = lowerer.resolveValueSymbol(n);
+        if (!symbol || seen.has(symbol))
+            break;
+        seen.add(symbol);
+        const declaration = lowerer.checker.valueDeclarationOf(symbol);
+        if (declaration && ts.isFunctionDeclaration(declaration)) {
+            n = declaration;
+            break;
+        }
+        if (!declaration || !ts.isVariableDeclaration(declaration) || !declaration.initializer ||
+            (ts.getCombinedNodeFlags(declaration) & ts.NodeFlags.Const) === 0)
+            break;
+        n = declaration.initializer;
+        while (ts.isParenthesizedExpression(n))
+            n = n.expression;
+    }
     if (ts.isIdentifier(n))
         return n.text;
     if (ts.isPropertyAccessExpression(n))
@@ -765,6 +791,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;
         }
@@ -799,6 +828,9 @@ export class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
+    /** Syntactic writes indexed once per JS scope. Symbol and RHS type
+     * checks remain contextual to each binding probe. */
+    jsBindingWritesByOwner = new Map();
     /** TRAP bindings: declarations whose initializer provably throws before
      * producing a value (its chain roots at an ambient-undefined name —
      * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
@@ -1078,7 +1110,7 @@ export class Lowerer {
         // the initializer cannot fall back to a narrowing adapter.
         if (ts.isIdentifier(node) && fallback?.kind === "func") {
             const decl = this.checker.valueDeclarationOf(symbol);
-            if (decl && ts.isVariableDeclaration(decl) && decl.initializer) {
+            if (decl && ts.isVariableDeclaration(decl) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer) {
                 let init = decl.initializer;
                 while (ts.isParenthesizedExpression(init))
                     init = init.expression;
@@ -1112,14 +1144,14 @@ export class Lowerer {
     }
     /** Recover the original optional union when a checked single-arm helper
      * was installed before a strict property consumer could name its member.
-     * Recovery is limited to array element reads and storage roots marked by
-     * the optional-read analysis, so ordinary assertions keep their generic
+     * Recovery covers member reads and storage roots marked by the
+     * optional-read analysis, so ordinary assertions keep their generic
      * checked-narrow behavior. */
     runtimeOptionalSourceValue(node, value) {
         let origin = node;
         while (ts.isParenthesizedExpression(origin))
             origin = origin.expression;
-        let optionalOrigin = ts.isElementAccessExpression(origin);
+        let optionalOrigin = ts.isElementAccessExpression(origin) || ts.isPropertyAccessExpression(origin);
         if (ts.isIdentifier(origin)) {
             const local = this.resolveLocal(origin);
             const root = local ? this.runtimeOptionalRootOf(local) : null;
@@ -1131,6 +1163,10 @@ export class Lowerer {
         }
         if (!optionalOrigin)
             return null;
+        // A checked JavaScript indexed read can already be boxed. The checker
+        // calls the element present, but that inference is not a runtime guard.
+        if (isJsSourceFile(node.getSourceFile()) && value.kind === "dynCheck" && value.value.type.kind === "dyn")
+            return value.value;
         let source = value;
         if (value.kind === "call" &&
             this.checkedNarrowHelpers.has(value.callee) &&
@@ -1331,6 +1367,17 @@ 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();
+    addedUndefinedArms = 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();
+    classMethodValueSelections = new Map();
     /** 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
@@ -1415,12 +1462,21 @@ 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();
+    /** Descendant writes must widen the original JS field before collecting
+     * any class layout; base and derived instances share its storage ABI. */
+    inheritedJsFieldWrites = new Map();
     /** Largest fixed argument list below a JS method, discovered before any
      * base vtable signature is collected. Unused checked slots carry undefined. */
     virtualJsMethodArity = new Map();
+    checkedVirtualJsMethods = new Set();
+    checkedVirtualJsAccessors = new Set();
+    checkedVirtualJsValueReturns = new Set();
     /** 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;
@@ -1559,6 +1615,7 @@ export class Lowerer {
      * a reference to a lowerable body reports its name here — recorded even
      * when the enclosing statement later poisons. */
     onEdge = null;
+    deferredModuleInitializers = null;
     // Stack of function contexts (bottom = the function being declared at
     // top level, top = the innermost nested function currently lowering).
     fnStack = [];
@@ -1566,7 +1623,10 @@ export class Lowerer {
     /** 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
@@ -1594,6 +1654,15 @@ export class Lowerer {
      * is assembled directly. The configured reachable set remains null so
      * demand-driven instance lowering keeps its existing gates. */
     reachableForArtifacts = null;
+    /** Constructors retained by the active worklist. A boxed base receiver
+     * can contain any retained descendant, but importing its declaration
+     * alone does not make every descendant constructible. */
+    constructedClasses = null;
+    virtualEdges = new Map();
+    classCanBeConstructed(info) {
+        return this.constructedClasses === null || this.constructedClasses.has(info.def.name) ||
+            info.genericInstance !== undefined || info.mixinInstance !== undefined;
+    }
     /** Coverage remainder mode: the reachability gate inverts (see wantBody)
      * and no module is built. */
     remainder;
@@ -1703,6 +1772,27 @@ export class Lowerer {
                 ? { 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))
@@ -2266,7 +2356,7 @@ export class Lowerer {
             return null;
         const directSpec = requireSpecOf(decl.initializer);
         if (directSpec !== null) {
-            return resolveImport(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;
@@ -2419,8 +2509,11 @@ export class Lowerer {
         if (!symbol)
             return null;
         const g = this.globalsBySymbol.get(symbol);
-        if (g)
+        if (g) {
+            if (g.type.kind === "func")
+                g.type = this.runtimeOptionalBindingType(ident, g.type);
             return g;
+        }
         for (const d of this.checker.declarationsOf(symbol)) {
             const byDecl = this.globalsByDeclNode.get(d);
             if (byDecl)
@@ -2586,7 +2679,7 @@ 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) ??
+        const dep = resolveImport(this.program, node.getSourceFile(), spec, "require") ??
             npmStaticDepSf7(this.program, node.getSourceFile(), spec, "require");
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
@@ -2665,6 +2758,14 @@ export class Lowerer {
                 return null;
             return s.flags & ts.SymbolFlags.Alias ? this.checker.getAliasedSymbol(s) : s;
         };
+        const signatureOf = (node) => {
+            const symbol = symbolOf(node);
+            if (!symbol)
+                return null;
+            const projection = this.staticCallables.get(symbol);
+            return this.fnSigsBySymbol.get(symbol) ??
+                (projection?.kind === "declared-function" ? projection.signature : null);
+        };
         const functionDeclBySymbol = new Map();
         const signatureBySymbol = new Map();
         const methodFamilies = new Map();
@@ -2818,9 +2919,11 @@ export class Lowerer {
             }
             if (ts.isBinaryExpression(e)) {
                 const op = e.operatorToken.kind;
-                if (op === ts.SyntaxKind.AmpersandAmpersandToken ||
-                    op === ts.SyntaxKind.BarBarToken ||
-                    op === ts.SyntaxKind.QuestionQuestionToken)
+                // Nullish/falsy left values select the fallback, so only that
+                // fallback can make the whole expression undefined.
+                if (op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken)
+                    return mayBeOptional(e.right);
+                if (op === ts.SyntaxKind.AmpersandAmpersandToken)
                     return mayBeOptional(e.left) || mayBeOptional(e.right);
             }
             if (ts.isPropertyAccessExpression(e) && ts.isIdentifier(e.expression)) {
@@ -2946,6 +3049,29 @@ export class Lowerer {
                     found = true;
             return found;
         };
+        const jsLambdas = [];
+        for (const sf of sourceFiles) {
+            if (!isJsSourceFile(sf))
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
+                    jsLambdas.push(node);
+            });
+        }
+        for (const [symbol, signature] of signatureBySymbol) {
+            const declaration = functionDeclBySymbol.get(symbol);
+            if (!declaration || !isJsSourceFile(declaration.getSourceFile()))
+                continue;
+            const checked = this.checker.getSignatureFromDeclaration(declaration);
+            const checkedReturn = checked ? this.checker.getReturnTypeOfSignature(checked) : null;
+            // Checker-known optional results already narrow at each use. Only
+            // propagate undefined that JavaScript's runtime ABI adds beyond them.
+            if (checkedReturn && ((checkedReturn.flags & ts.TypeFlags.Undefined) !== 0 ||
+                checkedReturn.isUnionType() && ts.constituentTypes(checkedReturn).some((arm) => (arm.flags & ts.TypeFlags.Undefined) !== 0)))
+                continue;
+            if (signature.returnType.kind === "union" && this.armTag(signature.returnType.unionId, UNDEFINED_T) >= 0)
+                optionalReturns.add(symbol);
+        }
         const promoteHofCallback = (callback, parameterIndices, seen = new Set()) => {
             let changed = false;
             const checkerTypeContainsTypeParameter = (type) => {
@@ -3383,6 +3509,23 @@ export class Lowerer {
             for (const [symbol, decl] of functionDeclBySymbol)
                 if (scanReturns(symbol, decl))
                     changed = true;
+            for (const fn of jsLambdas) {
+                if (!bodyReturnsOptional(fn))
+                    continue;
+                const mapped = this.mapTypeOf(this.typeOf(fn));
+                if (mapped?.kind !== "func")
+                    continue;
+                const previous = this.runtimeOptionalFunctionReturnType(fn, mapped.ret);
+                if (previous.kind === "generator")
+                    continue;
+                const next = previous.kind === "promise"
+                    ? { ...previous, inner: this.runtimeOptionalType(previous.inner) }
+                    : this.runtimeOptionalType(previous);
+                if (!typeEquals(previous, next)) {
+                    this.runtimeOptionalFunctionReturns.set(fn, next);
+                    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) {
@@ -3427,6 +3570,14 @@ export class Lowerer {
                     this.runtimeOptionalFunctionReturns.set(decl, arithmetic);
             }
         }
+        for (const [declaration, global] of this.globalsByDeclNode) {
+            if (global.type.kind !== "func" || !ts.isBinaryExpression(declaration) || !isJsSourceFile(declaration.getSourceFile()))
+                continue;
+            const value = peel(declaration.right);
+            if (!ts.isFunctionExpression(value) && !ts.isArrowFunction(value))
+                continue;
+            global.type = { ...global.type, ret: this.runtimeOptionalFunctionReturnType(value, global.type.ret) };
+        }
         for (const sf of sourceFiles) {
             ts.walkPreorder(sf, (node) => {
                 if (!ts.isVariableDeclaration(node) || !ts.isIdentifier(node.name))
@@ -3434,6 +3585,23 @@ export class Lowerer {
                 const symbol = symbolOf(node.name);
                 if (!symbol)
                     return;
+                if (isJsSourceFile(sf) && !node.type && !hasJsTypeAnnotation(node) && node.initializer &&
+                    (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+                    const global = this.globalsBySymbol.get(symbol);
+                    if (global?.type.kind === "func")
+                        global.type = { ...global.type, ret: this.runtimeOptionalFunctionReturnType(node.initializer, global.type.ret) };
+                }
+                if (!node.type && !hasJsTypeAnnotation(node) && node.initializer && ts.isIdentifier(node.initializer)) {
+                    const global = this.globalsBySymbol.get(symbol);
+                    const current = global?.type ?? this.mapTypeOf(this.typeOf(node.name));
+                    const source = current?.kind === "func" ? signatureOf(node.initializer) : null;
+                    if (source && current?.kind === "func") {
+                        const promoted = { ...current, params: source.params.filter((param) => param.mode !== "dynRest" && param.mode !== "arguments").map((param) => param.type), ret: source.returnType };
+                        this.runtimeOptionalBindingTypes.set(symbol, promoted);
+                        if (global)
+                            global.type = promoted;
+                    }
+                }
                 const fields = optionalFields.get(symbol);
                 if (!dynamicObjectEntryRows.has(symbol) && !optionalSymbols.has(symbol) && !fields)
                     return;
@@ -3444,7 +3612,7 @@ export class Lowerer {
                 if (!dynamicObjectEntryRows.has(symbol) && optionalSymbols.has(symbol))
                     promoted = addUndefined(promoted);
                 if (promoted.kind === "func" && node.initializer && ts.isIdentifier(node.initializer)) {
-                    const sourceSig = this.fnSigOf(node.initializer);
+                    const sourceSig = signatureOf(node.initializer);
                     if (sourceSig) {
                         promoted = {
                             ...promoted,
@@ -3644,6 +3812,7 @@ export class Lowerer {
      * and the retained reachability worklist. */
     finishModule(functions) {
         finalizeClassMethodValues(this, functions);
+        trackClassFieldCreation(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
@@ -3814,6 +3983,7 @@ export class Lowerer {
      * body; both fire edges through the same hooks and are not units
      * themselves. */
     emitReachable(extraRoots) {
+        this.deferredModuleInitializers = new DeferredModuleInitializers();
         const parts = this.splitFiles();
         // Direct lowering callers do not necessarily run program preflight.
         // Establish the same managed header/top-level batch here before
@@ -3832,6 +4002,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
@@ -3894,13 +4066,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) {
@@ -3978,6 +4150,7 @@ export class Lowerer {
             return owner;
         };
         const reachable = new Set();
+        this.constructedClasses = new Set();
         const queue = [];
         const loweredUnits = new Map();
         const initFunctions = [];
@@ -3988,6 +4161,12 @@ export class Lowerer {
             reachable.add(name);
             if (units.has(name))
                 queue.push(name);
+            if (this.constructedClasses && name.endsWith(".constructor")) {
+                this.constructedClasses.add(name.slice(1, -".constructor".length));
+                for (const [owner, methods] of this.virtualEdges)
+                    for (const method of methods)
+                        this.noteVirtualEdge(owner, method);
+            }
         };
         // Class EXPRESSIONS collect while init bodies lower (below): their
         // member units register the moment collection finishes — before any
@@ -3996,11 +4175,13 @@ 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));
+                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) {
@@ -4010,6 +4191,8 @@ export class Lowerer {
                 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
@@ -4134,10 +4317,13 @@ export class Lowerer {
         const classDispatch = new ClassDynamicDispatch(extraRoots !== undefined);
         for (;;) {
             drainInstances();
+            const initializerChanged = this.deferredModuleInitializers.process(this, [
+                ...loweredUnits.values(), ...initFunctions, ...instanceFunctions, ...this.liftedFns, ...this.implicitFns,
+            ]);
             const dispatchChanged = classDispatch.process(this, [
                 ...loweredUnits.values(), ...initFunctions, ...instanceFunctions, ...this.liftedFns, ...this.implicitFns,
             ]);
-            if (queue.length === 0 && !dispatchChanged)
+            if (queue.length === 0 && !dispatchChanged && !initializerChanged)
                 break;
             drainUnits();
             this.restoreGenericInstanceOrder(instLowered);
@@ -4160,6 +4346,20 @@ export class Lowerer {
             ...this.liftedFns,
             ...this.implicitFns,
         ];
+        // The worklist can leave a virtual site with only its base method.
+        // Devirtualize after construction/override reachability has settled.
+        for (const fn of functions)
+            fn.body = transformStmtList(fn.body, { stmt: (statement) => statement, expr: (expression) => {
+                    if (expression.kind !== "virtualCall")
+                        return expression;
+                    const info = this.classes.get(expression.className);
+                    const method = info && this.findMethodOn(info, expression.method);
+                    if (!method || method.sig.abstract || [...this.classes.values()].some((candidate) => this.isSubclassOf(candidate.def.name, expression.className) && candidate.def.name !== expression.className &&
+                        candidate.methods.has(expression.method) && reachable.has(`%${candidate.def.name}.${expression.method}`)))
+                        return expression;
+                    return { kind: "call", callee: `%${method.declarer.def.name}.${expression.method}`,
+                        args: [this.upcastTo(expression.args[0], method.declarer.def.name), ...expression.args.slice(1)], type: expression.type, loc: expression.loc };
+                } });
         this.reachableForArtifacts = reachable;
         return { reachable, result: this.finishModule(functions) };
     }
@@ -4177,12 +4377,17 @@ export class Lowerer {
     noteVirtualEdge(info, method) {
         if (!this.onEdge)
             return;
+        if (this.constructedClasses) {
+            const methods = this.virtualEdges.get(info) ?? new Set();
+            methods.add(method);
+            this.virtualEdges.set(info, methods);
+        }
         const above = this.findMethodOn(info, method);
         if (above)
             this.noteEdge(`%${above.declarer.def.name}.${method}`);
         const below = (c) => {
             for (const s of c.subclasses) {
-                if (s.methods.has(method))
+                if (this.classCanBeConstructed(s) && s.methods.has(method))
                     this.noteEdge(`%${s.def.name}.${method}`);
                 below(s);
             }
@@ -4477,7 +4682,7 @@ export class Lowerer {
                 Segmenter: intlHint,
                 DisplayNames: intlHint,
                 TextEncoder: "TextEncoder instances support encode(string) and encode(); other codec operations require a dedicated lowering",
-                TextDecoder: "TextDecoder instances support recognized literal labels with default options and whole-buffer decode(Uint8Array); runtime labels and options remain unsupported",
+                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();
@@ -4533,6 +4738,22 @@ export class Lowerer {
         return fenceStaticReadableStreamMember(this, access, use);
     }
     typeOf(node) {
+        if (ts.isPropertyAccessExpression(node) && isJsSourceFile(node.getSourceFile())) {
+            const receiver = node.expression.kind === ts.SyntaxKind.ThisKeyword && this.fnStack.length > 0
+                ? this.resolveThis()?.type : this.mapTypeOf(this.checker.getTypeAtLocation(node.expression));
+            const checkedThis = node.expression.kind === ts.SyntaxKind.ThisKeyword && this.fnStack.length > 0 && receiver?.kind === "dyn"
+                ? this.currentClass : null;
+            if (receiver?.kind === "object" && this.classes.get(receiver.className)?.fields.get(node.name.text)?.kind === "dyn" ||
+                checkedThis?.fields.get(node.name.text)?.kind === "dyn") {
+                return this.checker.getUnknownType();
+            }
+        }
+        // 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.
@@ -4577,8 +4798,15 @@ export class Lowerer {
                 // 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;
+                if (boundIr.kind === "dyn") {
+                    // JSDoc and initializer inference are declaration types, not flow
+                    // proofs. A checked specialization must not reinstate those
+                    // stale layouts (mutable/null slots and heterogeneous JS arrays).
+                    const declaration = sym && this.checker.valueDeclarationOf(sym);
+                    const declared = declaration && ts.isParameter(declaration)
+                        ? this.mapTypeOf(this.checker.getTypeAtLocation(declaration.name)) : null;
+                    return declared && typeEquals(declared, narrowedIr) ? bound : 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") {
@@ -4887,8 +5115,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
@@ -4991,7 +5231,14 @@ export class Lowerer {
         // undefined/null literals store the dyn unit values. Types outside the
         // dyn's domain (bytes, classes, Maps, ...) fall through to
         // requireExactShape's SC1101 fence.
-        // A promise flowing into a VOID-promise slot (an inferred
+        // Promise payloads may widen at a checked return boundary, including
+        // arrays inferred as tuple results by Promise.all. Keep both payload
+        // ABIs explicit: box settlement, then validate the destination payload.
+        if (expected.kind === "promise" && expected.inner.kind !== "void" && expr.type.kind === "promise" &&
+            !typeEquals(expected, expr.type) && this.dynConvertible(expr.type) &&
+            canDynCheckTo(expected, (id) => this.shapes.get(id), (id) => this.unions.get(id))) {
+            return { kind: "dynCheck", value: this.coerceToExpected(expr, DYN), type: expected, loc: expr.loc };
+        }
         // Promise<never> return holding a `return Promise.reject(value)` the
         // dyn arm typed promise<dyn>): awaiting through the slot ignores the
         // fulfillment payload (scr_await_void) and rejections flow untyped,
@@ -5009,23 +5256,22 @@ export class Lowerer {
                 return { kind: "seqExpr", stmts: [{ kind: "exprStmt", expr, loc: expr.loc }],
                     result: dynUndefinedExpr(expr.loc), 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.
+            // 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)) {
-                return { kind: "dynFrom", value: expr, type: DYN, loc: expr.loc };
+                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;
         }
@@ -5447,6 +5693,7 @@ export class Lowerer {
                     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.
@@ -5456,9 +5703,30 @@ export class Lowerer {
                 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:
@@ -7100,6 +7368,10 @@ export class Lowerer {
         const to = this.unions.get(toId);
         if (!from || !to)
             return null;
+        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;
@@ -7111,11 +7383,17 @@ export class Lowerer {
             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);
-        this.liftedFns.push(buildUnionRetag(name, from, to, plan, loc, (lift, value, dst) => this.applyWidthLift(lift, value, dst, loc), (type) => this.fmt(type)));
+        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
@@ -7588,7 +7866,7 @@ export class Lowerer {
                 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 && literalUnionArm(def, values, (id) => this.shapes.get(id));
+                    const arm = values && this.literalUnionArm(def.id, values);
                     if (arm)
                         expr = this.coerceInto(node, expr, arm);
                 }
@@ -7611,7 +7889,9 @@ export class Lowerer {
                 }
             }
         }
-        let e = this.coerceToExpected(expr, expected);
+        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.
@@ -7644,7 +7924,7 @@ export class Lowerer {
         // NamedEvaluation through a variable initializer) — inspect prints
         // [Function: name] and call errors spell it, like Node.
         if (e.kind === "dynFrom" && e.value.type.kind === "func" && e.fnName === undefined) {
-            const name = jsFuncNameOf(node);
+            const name = jsFuncNameOf(node, this);
             if (name !== null)
                 e = { ...e, fnName: name };
         }
@@ -7857,7 +8137,7 @@ export class Lowerer {
                 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 && literalUnionArm(def, values, (id) => this.shapes.get(id));
+                    const arm = values && this.literalUnionArm(def.id, values);
                     if (arm)
                         return this.coerceInto(node, this.lowerObjectLiteral(node, arm), expected);
                 }
@@ -7865,7 +8145,7 @@ export class Lowerer {
         }
         // 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/ErrorOptions types 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;
@@ -7885,7 +8165,8 @@ export class Lowerer {
                 return sym?.name === name && this.isStdlibSymbol(sym);
             });
             if (ts.isObjectLiteralExpression(x)) {
-                if (isJsSourceFile(x.getSourceFile()) || builtinOption("RequestInit") || builtinOption("ErrorOptions")) {
+                if (isJsSourceFile(x.getSourceFile()) || builtinOption("RequestInit") || builtinOption("ErrorOptions") || builtinOption("SpawnOptions") ||
+                    !this.mapTypeOf(this.typeOf(x))) {
                     return lowerDynObjectLiteral(this, x);
                 }
             }
@@ -7933,7 +8214,7 @@ export class Lowerer {
             }
         }
         let e = this.lowerExpr(node);
-        if (expected?.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) {
+        if (expected?.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0 || expected?.kind === "dyn" && isJsSourceFile(node.getSourceFile())) {
             // 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;
@@ -7994,7 +8275,19 @@ export class Lowerer {
      * declared result type of an index-signature read under
      * noUncheckedIndexedAccess. Null when the type cannot take the arm. */
     withUndefinedArmOf(t) {
-        return withUndefinedArmCanonical(t, this.unions);
+        if (t.kind !== "union")
+            return withUndefinedArmCanonical(t, this.unions);
+        const cached = this.addedUndefinedArms.get(t.unionId);
+        if (cached && cached.unions === this.unions.revision)
+            return cached.type;
+        // As with removing undefined, repeated optional-read propagation can
+        // reuse the exact union transformation until a recursive contract closes.
+        // An unknown id is not cached: a later interning can create it.
+        if (!this.unions.get(t.unionId))
+            return null;
+        const type = withUndefinedArmCanonical(t, this.unions);
+        this.addedUndefinedArms.set(t.unionId, { type, unions: this.unions.revision });
+        return type;
     }
     /** True when a static type converts to a dyn value (the dynFrom
      * walker's domain): JSON-safe, bytes<u8> (Uint8Array/Buffer — the checked-dynamic tree's
@@ -8096,14 +8389,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.transform(def, 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
@@ -8164,13 +8460,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.
@@ -8203,7 +8500,7 @@ export class Lowerer {
             return symbol;
         }
         finally {
-            this.diagSink = null;
+            this.diagSink = previousSink;
         }
     }
     /** Pushes a symbol's deferred collection diagnostics: lowering resolved
@@ -8384,6 +8681,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. */
@@ -8472,11 +8771,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}`;
@@ -8847,9 +9142,7 @@ export class Lowerer {
         });
         if (resolved.error !== null) {
             const location = blame ?? (symbol === undefined ? undefined : this.checker.declarationsOf(symbol)[0]) ?? this.entry;
-            const message = resolved.error === "caught"
-                ? "closures capturing catch bindings (narrow into a typed local first)"
-                : `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)`;
+            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)
@@ -9238,7 +9531,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);
@@ -9580,7 +9882,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) {
@@ -9640,6 +9942,10 @@ export class Lowerer {
      * member access that IS a module in its own right (`fs.promises` — the
      * same object as node:fs/promises, Node's rule). Null otherwise. */
     builtinNamespaceModuleOf(expr) {
+        // Default and CommonJS process bindings alias the global object, whose
+        // methods and properties keep their existing process lowerings.
+        if (stdlibGlobalNameOf(this, expr) === "process")
+            return null;
         const stored = ts.isIdentifier(expr)
             ? (this.peekLocal(expr)?.type ?? this.globalOf(expr)?.type)
             : undefined;
@@ -9862,10 +10168,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 };
             }
@@ -9873,6 +10179,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") {
@@ -9908,7 +10218,7 @@ export class Lowerer {
         }
         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)`);
@@ -9921,6 +10231,9 @@ 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);
         return fn ? this.lowerNativeCallableValue(fn, `${bi.module}.${bi.member}`, loc) : null;
     }