@scriptc/compiler 0.2.1 → 0.2.3

package/dist/frontend/lowering/lowerer.js

@@ -1,5 +1,5 @@
-import { pathModuleValue } from "./lower-builtin-values.js";
-import { everyExprChild, everyStmtChild } from "../../ir/traverse.js";
+import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue } 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";
@@ -9,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.
  *
@@ -37,7 +38,7 @@ 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";
@@ -57,8 +58,9 @@ 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 { lowerSystemErrorMapValue } from "./lower-system-errors.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";
@@ -751,18 +753,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))
@@ -811,6 +829,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
@@ -1090,7 +1111,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;
@@ -1124,14 +1145,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;
@@ -1143,6 +1164,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) &&
@@ -1348,10 +1373,12 @@ export class Lowerer {
     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
@@ -1442,9 +1469,15 @@ export class Lowerer {
     /** 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;
@@ -1583,6 +1616,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 = [];
@@ -1621,6 +1655,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;
@@ -2467,8 +2510,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)
@@ -2713,6 +2759,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();
@@ -2736,7 +2790,7 @@ export class Lowerer {
             });
         }
         for (const info of this.classes.values()) {
-            for (const { mName, member } of this.classMethodMembers(info)) {
+            for (const { mName, member } of this.classMethodMembers(info, true)) {
                 if (!member.name || !(ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)))
                     continue;
                 const symbol = symbolOf(member.name);
@@ -2866,9 +2920,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)) {
@@ -2994,6 +3050,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) => {
@@ -3381,21 +3460,32 @@ export class Lowerer {
                             }
                             return;
                         }
-                        const set = optionalParams.get(symbol) ?? new Set();
-                        shape.type = addUndefined(shape.type);
-                        const before = set.size;
-                        set.add(i);
-                        optionalParams.set(symbol, set);
-                        if (set.size !== before) {
-                            changed = true;
-                            const callee = functionDeclBySymbol.get(symbol);
-                            const parameter = callee?.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;
+                        // A virtual slot has one argument representation, even when
+                        // the unchecked read reaches only a base-typed call site.
+                        // Promote every implementation and its parameter bindings so
+                        // downstream calls and returns see the same optional value.
+                        const family = familyBySymbol.get(symbol);
+                        if (family)
+                            optionalMethodFamilies.add(family);
+                        for (const target of family ?? [symbol]) {
+                            const parameterShape = signatureBySymbol.get(target)?.params[i];
+                            if (!parameterShape)
+                                continue;
+                            parameterShape.type = addUndefined(parameterShape.type);
+                            const set = optionalParams.get(target) ?? new Set();
+                            const before = set.size;
+                            set.add(i);
+                            optionalParams.set(target, set);
+                            if (set.size !== before) {
+                                changed = true;
+                                const parameter = functionDeclBySymbol.get(target)?.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;
+                                        }
                                     }
                                 }
                             }
@@ -3431,6 +3521,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) {
@@ -3475,6 +3582,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))
@@ -3482,6 +3597,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;
@@ -3492,7 +3624,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,
@@ -3692,6 +3824,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
@@ -3862,6 +3995,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
@@ -4028,6 +4162,7 @@ export class Lowerer {
             return owner;
         };
         const reachable = new Set();
+        this.constructedClasses = new Set();
         const queue = [];
         const loweredUnits = new Map();
         const initFunctions = [];
@@ -4038,6 +4173,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
@@ -4188,10 +4329,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);
@@ -4214,6 +4358,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) };
     }
@@ -4231,12 +4389,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);
             }
@@ -4587,6 +4750,16 @@ 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.
@@ -4637,8 +4810,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") {
@@ -5063,7 +5243,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,
@@ -7749,7 +7936,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 };
         }
@@ -8039,7 +8226,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;
@@ -8100,7 +8287,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
@@ -8562,9 +8761,10 @@ export class Lowerer {
     lowerStaticFieldInits(info) {
         return lowerStaticFieldInits(this, info);
     }
-    /** The method-like members (methods and accessors) of a class that have
-     * lowerable bodies, with their collected method-map names. */
-    *classMethodMembers(info) {
+    /** Method-like members with their collected method-map names. Body
+     * lowering omits abstract declarations; ABI analysis must include them
+     * because an abstract-typed call selects the same virtual slot. */
+    *classMethodMembers(info, includeAbstract = false) {
         if (!info.decl)
             return; // builtin error classes: runtime-provided bodies
         for (const member of info.decl.members) {
@@ -8588,7 +8788,8 @@ export class Lowerer {
             if (baseName === null)
                 continue;
             const mName = ts.isMethodDeclaration(fnLike) ? baseName : `${ts.isGetAccessor(fnLike) ? "get" : "set"}:${baseName}`;
-            if (!info.methods.get(mName) || !fnLike.body)
+            const signature = info.methods.get(mName);
+            if (!signature || (!fnLike.body && !(includeAbstract && signature.abstract)))
                 continue;
             yield { mName, member: fnLike };
         }
@@ -9755,6 +9956,13 @@ 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 imported = ts.isIdentifier(expr) ? this.builtinImportOf(expr) : null;
+        if (imported?.module === "util" && imported.member === "types")
+            return "util/types";
         const stored = ts.isIdentifier(expr)
             ? (this.peekLocal(expr)?.type ?? this.globalOf(expr)?.type)
             : undefined;
@@ -10040,6 +10248,12 @@ 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 === "util" && bi.member === "types")
+            return utilTypesModuleValue(this, loc);
+        if (bi.module === "util/types" && builtinModuleFnOf(this, bi.module, bi.member))
+            return lowerUtilTypeValue(this, bi.member, loc);
+        if (bi.module === "util" && bi.member === "getSystemErrorMap")
+            return lowerSystemErrorMapValue(this, 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 };
         }
@@ -10054,6 +10268,8 @@ export class Lowerer {
             if (param.mode === "rest")
                 return { mode: "rest", type: arrayOf(param.type) };
             if (param.mode === "optional") {
+                if (param.type.kind === "dyn" && param.defaultValue === undefined)
+                    return { mode: "omittable", type: DYN };
                 return { mode: "omittable", type: this.withUndefinedArm(param.type), bodyType: param.type };
             }
             return { mode: "required", type: param.type };
@@ -10085,7 +10301,10 @@ export class Lowerer {
                 };
                 if (valueParam.mode !== "optional")
                     return ref;
-                if ((valueParam.type.kind !== "string" && valueParam.type.kind !== "f64") || param.type.kind !== "union") {
+                // Checked runtime APIs consume undefined directly for omitted options.
+                if (valueParam.type.kind === "dyn" && valueParam.defaultValue === undefined)
+                    return ref;
+                if (valueParam.defaultValue === undefined || (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);