@scriptc/compiler 0.2.7 → 0.2.9

package/dist/frontend/lowering/lowerer.js

@@ -1,5 +1,6 @@
 import { checkCycleBindingAccesses, refuseUncheckedCycleReads, } from "./cycle-initialization.js";
 import { identityPreservingWidening } from "./coercions/identity.js";
+import { scanDivergences } from "./divergences.js";
 import { checkedClassAssertion } from "./class-assertions.js";
 import { narrowStoredClassValue, narrowGenericClassValue } from "./class-unions.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
@@ -12,11 +13,17 @@ import { CoercionState } from "./coercions/state.js";
 import { widthLiftPlan, unitOnlyElem, recordWidthPlan, describeRecordWidthBlocker, objToRecordPlan, recordToClassPlan, } from "./coercions/structural-plans.js";
 import { widthCoerce, applyWidthLift, unionRecordWidthHelper, recordWidthHelper, tupleArrayWidthHelper, emptyArrayLiftHelper, arrayWidthHelper, objRecordWidthHelper, recordClassWidthHelper, classStaticsProjection, } from "./coercions/structural.js";
 import { funcReturnWidthAdapter, coercibleValue, cleanFuncAdaptable, funcCoerceAdapter, spawnResFnAdapterPlan, spawnResFnAdapter, } from "./coercions/function-adapters.js";
-import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, deferredReadHelper, } from "./coercions/unions.js";
+import { unionRetagMappable, narrowedRetagHelper, strandedUnitTrap, strandedCoercionTrap, recordUnionWrapHelper, unionRetagHelper, narrowedArmHelper, checkedNarrowCall, checkedNarrowOperand, deferredReadHelper, } from "./coercions/unions.js";
 import { jsvalLiftable, jsvalLiftExpr, unionToJsvalHelper, recordToJsvalHelper, arrayToJsvalHelper, arrayToJsvalArrayHelper, } from "./coercions/island.js";
 import { lowerUtilTypeValue, pathModuleValue, utilTypesModuleValue, } from "./lower-builtin-values.js";
 import { everyExprChild, everyStmtChild, transformStmtList } from "../../ir/traverse.js";
 import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js";
+import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js";
+import { ArrayElementStates } from "./runtime-optional-elements.js";
+import { indexReadInBounds } from "./runtime-optional-bounds.js";
+import { ArrayOwnership } from "./runtime-optional-ownership.js";
+import { StringIndexBounds } from "./string-index-bounds.js";
+import { NanCodedReads } from "./nan-coded-reads.js";
 import { RuntimeOptionalLocals } from "./runtime-optional-locals.js";
 import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js";
 import { UnregisteredClassTypes } from "./unregistered-class-types.js";
@@ -52,7 +59,7 @@ import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, comp
 import { arrayOf, BOOL, canAdaptDynFuncTo, canDynCheckTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, DYN_HANDLE_KINDS, F64, isDynTypedRefType, isJsonSafeType, isJsonStringifySafeType, isPrimitiveCollectionKey, isSupportedMapKey, isSupportedMapValue, isUndefinedArmedUnion, isUnitType, JSVAL, NULL_T, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID, } from "../../ir/ir.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, 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 { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, isWorkerHandleType, jsOpenObjectType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../type-mapper.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, appendWorkerModules, } from "./lower-modules.js";
 import { prepareCjsModuleGraph } from "./lower-node-module.js";
@@ -197,6 +204,39 @@ export function stmtUsesIsland(stmts) {
         return !stmts.every((stmt) => everyStmtChild(stmt, expr, nested));
     return !everyStmtChild(stmts, expr, nested);
 }
+/** Statements a never-lowered body would have contributed to the coverage
+ * totals: every element of a statement list (blocks, case clauses), plus
+ * the single-statement bodies of control flow, nested functions included —
+ * the same accounting lowerStmts applies to bodies that do lower. */
+export function countBodyStatements(root) {
+    let n = 0;
+    const visit = (node) => {
+        if (ts.isBlock(node) || ts.isCaseClause(node) || ts.isDefaultClause(node)) {
+            n += node.statements.length;
+        }
+        else if ((ts.isIfStatement(node) ||
+            ts.isForStatement(node) ||
+            ts.isForInStatement(node) ||
+            ts.isForOfStatement(node) ||
+            ts.isWhileStatement(node) ||
+            ts.isDoStatement(node) ||
+            ts.isLabeledStatement(node)) &&
+            node.parent !== undefined) {
+            const bodies = ts.isIfStatement(node)
+                ? [node.thenStatement, node.elseStatement]
+                : ts.isLabeledStatement(node)
+                    ? [node.statement]
+                    : [node.statement];
+            for (const body of bodies) {
+                if (body !== undefined && !ts.isBlock(body) && !ts.isIfStatement(body))
+                    n++;
+            }
+        }
+    };
+    // Iterative: absurdly deep nesting must not overflow the stack here.
+    ts.walkPreorder(root, visit);
+    return n;
+}
 function directExternalTypeSpecifiersByFile(externalTypes) {
     const out = new Map();
     for (const [specifier, file] of externalTypes) {
@@ -349,6 +389,12 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         resultLowerer = emit;
         timing("historical-order-relower");
     }
+    // Divergence warnings over the program's own modules: computed once,
+    // after lowering, from the same checker (never part of a failure).
+    const divergences = scanDivergences(resultLowerer, moduleOrder);
+    timing("divergence-scan", { found: divergences.length });
+    if (divergences.length > 0)
+        result = { ...result, divergences };
     if (options.coverage !== true)
         return result;
     const remainder = new Lowerer(program, entry, moduleOrder, dynamic, {
@@ -366,7 +412,17 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
         externalTypeSpecifiersByFile,
     });
     const rem = remainder.run();
-    return { ...result, unreached: { diagnostics: rem.diagnostics, stats: rem.stats } };
+    // Unreached JS statements whose fences deferred to runtime count as
+    // failed statements in the remainder's stats, so their diagnostics must
+    // travel with them: a failed statement is never left unexplained.
+    return {
+        ...result,
+        unreached: {
+            diagnostics: rem.diagnostics,
+            stats: rem.stats,
+            ...(rem.runtimeFences.length > 0 ? { runtimeFences: rem.runtimeFences } : {}),
+        },
+    };
 }
 /** The island-handle type a `import(...)` initializer gives a binding
  * whose DECLARED type has no static mapping (`Promise<typeof
@@ -882,6 +938,17 @@ export function jsFuncNameOf(node, lowerer) {
     }
     return null;
 }
+/** Answers `fallback` when a checker query panics inside the type checker. */
+function panicSafe(query, fallback) {
+    try {
+        return query();
+    }
+    catch (e) {
+        if (isCheckerPanic(e))
+            return fallback;
+        throw e;
+    }
+}
 export class Lowerer {
     program;
     entry;
@@ -910,6 +977,18 @@ export class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
+    /** Typed-array element reads whose every consumer treats undefined like
+     * NaN, which lower to plain doubles (see nan-coded-reads.ts). Settled by
+     * analyzeRuntimeOptionalArrayReads before any body lowers. */
+    nanCodedReads = null;
+    stringIndexBoundsCache = null;
+    /** Proofs that a string element read names an existing code unit. The
+     * indexed-read analysis and expression lowering share one instance, so a
+     * read's representation and its callers' signatures always agree. */
+    get stringIndexBounds() {
+        this.stringIndexBoundsCache ??= new StringIndexBounds((node) => this.checker.getSymbolAtLocation(node) ?? null, (symbol) => this.checker.valueDeclarationOf(symbol), (node) => (this.typeOf(node).flags & ts.TypeFlags.StringLike) !== 0);
+        return this.stringIndexBoundsCache;
+    }
     /** Syntactic writes indexed once per JS scope. Symbol and RHS type
      * checks remain contextual to each binding probe. */
     jsBindingWritesByOwner = new Map();
@@ -1156,6 +1235,11 @@ export class Lowerer {
      * prepass. This includes explicit annotations: unchecked TS annotations do
      * not prove that an array property read produced a value. */
     runtimeOptionalBindingTypes = new Map();
+    /** Bindings that receive an unchecked indexed read (or a value derived
+     * from one) through an initializer or assignment. The checker narrows a
+     * declared optional binding to that read's bare type, so presence tests
+     * on these bindings consult the stored tag instead. */
+    runtimeOptionalAssignedSymbols = new Set();
     /** Concise callback/lambda returns promoted by the HOF callback prepass;
      * arrows have no declaration symbol to key in fnSigsBySymbol. */
     runtimeOptionalFunctionReturns = new Map();
@@ -1173,6 +1257,17 @@ export class Lowerer {
      * every name destructured from a present source optional. */
     runtimeOptionalPatternTypes = new Map();
     runtimeOptionalReduceTypes = new Map();
+    /** Non-null assertions whose value is forwarded into a slot promoted to
+     * hold undefined. `x!` has no runtime effect, so these keep the stored
+     * undefined state instead of trapping before any dereference. */
+    runtimeOptionalAssertions = new Set();
+    /** Array callback calls whose receiver the optional-read analysis proved
+     * never holds an explicit undefined (or a hole, for the find family):
+     * their callbacks take the element type itself. */
+    presentElementCalls = new Set();
+    /** for-of loops over arrays that can hold neither holes nor undefined:
+     * each pass reads the element payload directly. */
+    presentElementLoops = new Set();
     /** Capture entries and their origin share one mutable box. Normalize each
      * entry to the origin so writes and flow proofs stay synchronized. */
     runtimeOptionalRoots = new Map();
@@ -1247,6 +1342,9 @@ export class Lowerer {
      * optional-read analysis, so ordinary assertions keep their generic
      * checked-narrow behavior. */
     runtimeOptionalSourceValue(node, value) {
+        const slot = this.deferredFieldSlot(value);
+        if (slot)
+            return slot;
         let origin = node;
         while (ts.isParenthesizedExpression(origin))
             origin = origin.expression;
@@ -1281,12 +1379,9 @@ export class Lowerer {
             value.value.type.kind === "dyn")
             return value.value;
         let source = value;
-        if (value.kind === "call" &&
-            this.coercions.checkedNarrows.has(value.callee) &&
-            value.args.length === 1 &&
-            value.args[0]?.type.kind === "union") {
-            source = value.args[0];
-        }
+        const narrowed = checkedNarrowOperand(this, value);
+        if (narrowed?.type.kind === "union")
+            source = narrowed;
         return source.type.kind === "union" && this.armTag(source.type.unionId, UNDEFINED_T) >= 0
             ? source
             : null;
@@ -1399,6 +1494,41 @@ export class Lowerer {
     runtimeOptionalFunctionReturnType(node, fallback) {
         return this.runtimeOptionalFunctionReturns.get(node) ?? fallback;
     }
+    /** True when `actual` is `declared` with some record fields (directly,
+     * in nested records, or in an array's element records) widened to runtime-optional unions:
+     * fields filled from unchecked indexed reads the checker calls present.
+     * Inferred bindings and destructured parameters keep that layout instead
+     * of narrowing it away. */
+    isRuntimeOptionalRecordVariant(actual, declared) {
+        if (actual.kind === "array" && declared.kind === "array")
+            return this.isRuntimeOptionalRecordVariant(actual.elem, declared.elem);
+        if (actual.kind !== "record" || declared.kind !== "record")
+            return false;
+        if (actual.shapeId === declared.shapeId)
+            return false;
+        const a = this.shapes.get(actual.shapeId);
+        const d = this.shapes.get(declared.shapeId);
+        if (!a || !d || a.fields.length !== d.fields.length || !!a.tuple !== !!d.tuple)
+            return false;
+        if (a.indexValue || d.indexValue)
+            return false;
+        let widened = false;
+        for (const field of d.fields) {
+            const source = a.fields.find((f) => f.name === field.name);
+            if (!source)
+                return false;
+            if (typeEquals(source.type, field.type))
+                continue;
+            if (this.isRuntimeOptionalField(actual.shapeId, field.name) &&
+                (this.runtimeOptionalWidening(source.type, field.type) !== null ||
+                    this.isRuntimeOptionalRecordVariant(source.type, field.type))) {
+                widened = true;
+                continue;
+            }
+            return false;
+        }
+        return widened;
+    }
     /** Promote one field of a record storage shape to the value's runtime
      * type. Shapes are immutable by identity, so this interns a sibling shape
      * and records the field as runtime-optional for property-read narrowing. */
@@ -1699,6 +1829,9 @@ export class Lowerer {
      * and therefore becomes the cycle's evaluation root. Dynamic imports
      * wait on this shared verdict rather than a build-time-selected member. */
     asyncCyclePromiseOf = new Map();
+    /** Modules whose evaluation an import() can request again after it threw,
+     * computed on first use (lower-modules.ts importRetryModules). */
+    importRetryModules = null;
     /** Record-shape interner: canonical (name-sorted) field list → shapeId.
      * Threaded into every mapType call; its `shapes` array becomes
      * IrModule.records. */
@@ -1795,6 +1928,13 @@ export class Lowerer {
      * coverage remainder as alreadyFlushed). */
     flushedSymbols = new Set();
     alreadyFlushed;
+    /** Deferred diagnostics a flush handed to a capture buffer (diagSink)
+     * instead of the build, keyed by the copy in that buffer. A buffer can
+     * be discarded (a declined probe, a collection that succeeded) or
+     * re-deferred under another declaration, so the declaration stays
+     * deferred until one of these copies reaches `diags` (pushDiag commits
+     * it); until then a later flush reports the diagnostics again. */
+    pendingFlushes = new Map();
     /** The build's target platform ("win32" | "darwin" | "linux" | ...):
      * selects the platform-keyed builtin surfaces (builtinModuleFnsOf /
      * builtinModuleConstOf in surfaces.ts). */
@@ -1973,6 +2113,12 @@ export class Lowerer {
         this.classProtocols ??= new ClassProtocols(this.checker, this.moduleOrder);
         return this.classProtocols.usesCheckedIdentity(type);
     }
+    /** Declared class fields may store a DYN value only when its static type
+     * names checked protocol identity or an owned runtime handle (a Worker
+     * or MessagePort); `unknown` and `any` fields stay refused. */
+    classFieldStoresDyn(type) {
+        return this.classImplementedProtocol(type) || isWorkerHandleType(type, this.typeCtx);
+    }
     /** The nominal identity of a checker module-namespace type. Program
      * modules use their normalized absolute source name; supported builtins
      * use the lowering tables' canonical bare name. */
@@ -2992,6 +3138,32 @@ export class Lowerer {
                 }
             }
         }
+        const mappedOrNull = (node) => panicSafe(() => this.mapTypeOf(this.typeOf(node)), null);
+        const nanCoded = new NanCodedReads({
+            symbolOf,
+            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            bytesElemOf: (receiver) => {
+                const t = mappedOrNull(receiver);
+                return t?.kind === "bytes" ? t.elem : null;
+            },
+            isNumber: (node) => mappedOrNull(node)?.kind === "f64",
+            isString: (node) => mappedOrNull(node)?.kind === "string",
+            hasLength: (node) => {
+                const kind = mappedOrNull(node)?.kind;
+                return kind === "array" || kind === "bytes";
+            },
+            isStdlibGlobal: (node, name) => this.isStdlibGlobal(node, name),
+            paramIsNumber: (fn, index) => {
+                const param = signatureBySymbol.get(fn)?.params[index];
+                return (param !== undefined &&
+                    param.type.kind === "f64" &&
+                    (param.mode === "required" || param.mode === "omittable"));
+            },
+            returnIsNumber: (fn) => signatureBySymbol.get(fn)?.returnType.kind === "f64",
+            methodOverridden: (fn) => (familyBySymbol.get(fn)?.length ?? 1) > 1,
+        }, sourceFiles);
+        nanCoded.analyze();
+        this.nanCodedReads = nanCoded;
         const peel = (node) => {
             let e = node;
             while (ts.isParenthesizedExpression(e) ||
@@ -3043,12 +3215,79 @@ export class Lowerer {
             }
             return false;
         };
+        // `parent!` passed to a call or bound to a name forwards the value
+        // without reading it: a callee that never dereferences it observes
+        // undefined, as in JavaScript. Only a class value with one undefined
+        // arm qualifies; element reads keep the established bounds trap.
+        const forwardedAssertion = (node) => {
+            let e = node;
+            while (ts.isParenthesizedExpression(e))
+                e = e.expression;
+            if (!ts.isNonNullExpression(e))
+                return null;
+            let operand = e.expression;
+            while (ts.isParenthesizedExpression(operand))
+                operand = operand.expression;
+            if (ts.isElementAccessExpression(operand) || ts.isNonNullExpression(operand))
+                return null;
+            // A guard that already proves the binding present makes the
+            // assertion true at runtime: nothing is forwarded as undefined.
+            if (ts.isIdentifier(operand)) {
+                const symbol = symbolOf(operand);
+                if (symbol && provenPresent(operand, symbol))
+                    return null;
+            }
+            const stored = this.mapTypeOf(this.typeOf(e.expression));
+            const asserted = this.mapTypeOf(this.typeOf(e));
+            if (stored?.kind !== "union" || asserted?.kind !== "object")
+                return null;
+            const arms = this.unions.get(stored.unionId)?.arms;
+            if (arms?.length !== 2 ||
+                this.armTag(stored.unionId, UNDEFINED_T) < 0 ||
+                !arms.some((arm) => typeEquals(arm, asserted)))
+                return null;
+            return e;
+        };
+        // `decode(xs[i]!)`: a missing element is passed as undefined in
+        // JavaScript, and the callee may never read it.
+        const forwardedElementAssertion = (node) => {
+            let e = node;
+            while (ts.isParenthesizedExpression(e))
+                e = e.expression;
+            if (!ts.isNonNullExpression(e))
+                return null;
+            let read = e.expression;
+            while (ts.isParenthesizedExpression(read))
+                read = read.expression;
+            if (!ts.isElementAccessExpression(read))
+                return null;
+            if (this.mapTypeOf(this.typeOf(read.expression))?.kind !== "array")
+                return null;
+            // An in-bounds read of an array that never holds undefined or holes
+            // always produces a present element.
+            if (indexReadInBounds(read) && elementStates.elementsPresent(read.expression, "find"))
+                return null;
+            const element = this.mapTypeOf(this.typeOf(e));
+            if (!element ||
+                element.kind === "void" ||
+                element.kind === "dyn" ||
+                element.kind === "jsval" ||
+                element.kind === "generator")
+                return null;
+            return e;
+        };
         const isIndexedRead = (node) => {
             const e = peel(node);
             if (!ts.isElementAccessExpression(e))
                 return false;
             const kind = this.mapTypeOf(this.typeOf(e.expression))?.kind;
-            return kind === "array" || kind === "string";
+            if (kind === "string")
+                return !this.stringIndexBounds.inBounds(e);
+            // Typed-array reads answer undefined for an invalid index too, unless
+            // every consumer treats undefined like NaN.
+            if (kind === "bytes")
+                return !nanCoded.isNumericRead(e);
+            return kind === "array";
         };
         const isDynamicObjectEntryRead = (node) => {
             const read = peel(node);
@@ -3076,6 +3315,37 @@ export class Lowerer {
             return this.withUndefinedArm(t);
         };
         const fieldName = (node) => node.name.text;
+        // The precision facts below ask about nodes ordinary lowering may never
+        // query. A checker panic on one of them answers null, and each caller
+        // falls back to its conservative fact.
+        const typeOrNull = (node) => panicSafe(() => this.typeOf(node), null);
+        const contextualOrNull = (node) => panicSafe(() => this.checker.getContextualType(node), null);
+        // Presence proofs only hold for a binding that keeps its one value for
+        // its whole lifetime.
+        const reassigned = reassignedBindings(sourceFiles, symbolOf, isJsSourceFile);
+        const presenceProofs = new Map();
+        const provenPresent = (use, symbol) => {
+            if (reassigned.has(symbol))
+                return false;
+            const cached = presenceProofs.get(use);
+            if (cached !== undefined)
+                return cached;
+            const proven = presentAtUse(use, {
+                sameBinding: (node) => node.text === use.text && symbolOf(node) === symbol,
+                isUndefined: (node) => node.text === "undefined" &&
+                    ((typeOrNull(node)?.flags ?? 0) & ts.TypeFlags.Undefined) !== 0,
+            });
+            presenceProofs.set(use, proven);
+            return proven;
+        };
+        // Bindings of a for-of loop over an array that can hold holes or
+        // undefined. Lowering keeps such a binding's runtime union, so storing
+        // it into another array can store undefined.
+        const iterationSymbols = new Set();
+        // The subset whose iterated array's own facts show a hole or undefined.
+        // Such a binding reads `T | undefined`, so a typed parameter, local or
+        // field it flows into widens like any other missing element read.
+        const holeyIterationSymbols = new Set();
         const mayBeOptional = (node) => {
             // `xs[i]!` is the explicit proven-present form. Its array read keeps
             // the established dense bounds trap and must not promote the enclosing
@@ -3101,9 +3371,18 @@ export class Lowerer {
                 this.mapTypeOf(this.typeOf(e))?.kind === "union" &&
                 this.armTag(this.mapTypeOf(this.typeOf(e)).unionId, UNDEFINED_T) >= 0)
                 return true;
+            // A NaN-coded value that reaches a consumer able to observe undefined
+            // is rebuilt as the ordinary optional value there; every other read
+            // of a NaN-coded slot is a plain number.
+            if (nanCoded.reboxes(e))
+                return true;
+            if (nanCoded.readsNanCodedSlot(e))
+                return false;
             if (ts.isIdentifier(e)) {
                 const symbol = symbolOf(e);
-                return symbol !== null && optionalSymbols.has(symbol);
+                return (symbol !== null &&
+                    (optionalSymbols.has(symbol) || holeyIterationSymbols.has(symbol)) &&
+                    !provenPresent(e, symbol));
             }
             if (ts.isPropertyAccessExpression(e)) {
                 const symbol = symbolOf(e.name);
@@ -3169,7 +3448,9 @@ export class Lowerer {
                 if (t?.kind !== "string")
                     return false;
                 const recv = this.mapTypeOf(this.typeOf(p.expression));
-                return recv?.kind === "string" || (recv?.kind === "array" && recv.elem.kind === "string");
+                if (recv?.kind === "string")
+                    return !this.stringIndexBounds.inBounds(p);
+                return recv?.kind === "array" && recv.elem.kind === "string";
             };
             const primitive = (part) => {
                 const t = this.mapTypeOf(this.typeOf(part));
@@ -3189,6 +3470,25 @@ export class Lowerer {
                 return false;
             return noteFieldSymbol(symbol, name);
         };
+        /** An instance field of a TypeScript class whose declared storage is
+         * exactly `T | undefined`: an assignment from a missing read stores the
+         * undefined arm while the checker narrows later reads to `T`. */
+        const optionalInstanceField = (symbol) => {
+            const decl = this.checker.valueDeclarationOf(symbol);
+            if (!decl || !ts.isPropertyDeclaration(decl) || !ts.isIdentifier(decl.name))
+                return false;
+            if (ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Static)
+                return false;
+            const sf = decl.getSourceFile();
+            if (isJsSourceFile(sf) || sf.isDeclarationFile)
+                return false;
+            const declared = typeOrNull(decl.name);
+            const mapped = declared ? this.mapTypeOf(declared) : null;
+            if (mapped?.kind !== "union" || this.armTag(mapped.unionId, UNDEFINED_T) < 0)
+                return false;
+            const arms = this.unions.get(mapped.unionId)?.arms ?? [];
+            return (arms.length === 2 && arms.every((arm) => arm.kind === "undefinedT" || !isUnitType(arm)));
+        };
         const noteFieldSymbol = (symbol, name) => {
             const set = optionalFields.get(symbol) ?? new Set();
             const before = set.size;
@@ -3196,6 +3496,43 @@ export class Lowerer {
             optionalFields.set(symbol, set);
             return set.size !== before;
         };
+        // Runtime-optional record fields travel with the record value: a copy,
+        // a spread or a parameter receives the source's optional fields.
+        const fieldsOfValue = (node) => {
+            const e = peel(node);
+            if (!ts.isIdentifier(e))
+                return undefined;
+            const symbol = symbolOf(e);
+            return symbol === null ? undefined : optionalFields.get(symbol);
+        };
+        const noteFieldsFrom = (symbol, source) => {
+            const fields = fieldsOfValue(source);
+            if (fields === undefined)
+                return false;
+            let changed = false;
+            for (const field of fields)
+                if (noteFieldSymbol(symbol, field))
+                    changed = true;
+            return changed;
+        };
+        /** Optional fields an object literal takes from its spreads, minus
+         * the properties a later member writes explicitly. */
+        const spreadFieldsOf = (object) => {
+            const out = new Set();
+            for (const prop of object.properties) {
+                if (ts.isSpreadAssignment(prop)) {
+                    const fields = fieldsOfValue(prop.expression);
+                    if (fields !== undefined)
+                        for (const field of fields)
+                            out.add(field);
+                }
+                else if (prop.name !== undefined &&
+                    (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name))) {
+                    out.delete(prop.name.text);
+                }
+            }
+            return out;
+        };
         const scanPattern = (name, init) => {
             if (!ts.isArrayBindingPattern(name))
                 return false;
@@ -3290,14 +3627,31 @@ export class Lowerer {
             return found;
         };
         const jsLambdas = [];
+        // TypeScript lambdas keep the checker's inferred return type, which
+        // spells a missing read as its bare element type and `read ?? "text"`
+        // as a number. Their closures return the runtime result instead.
+        const tsLambdas = [];
         for (const sf of sourceFiles) {
-            if (!isJsSourceFile(sf))
+            const js = isJsSourceFile(sf);
+            if (!js && sf.isDeclarationFile)
                 continue;
             ts.walkPreorder(sf, (node) => {
                 if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
-                    jsLambdas.push(node);
+                    (js ? jsLambdas : tsLambdas).push(node);
             });
         }
+        /** The primitive result union of a lambda's returns (see
+         * optionalPrimitiveResultType), as declared functions record it. */
+        const lambdaArithmeticReturn = (fn) => {
+            if (fn.body && !ts.isBlock(fn.body))
+                return optionalPrimitiveResultType(fn.body);
+            for (const expression of returnsOf(fn)) {
+                const result = optionalPrimitiveResultType(expression);
+                if (result)
+                    return result;
+            }
+            return null;
+        };
         for (const [symbol, signature] of signatureBySymbol) {
             const declaration = functionDeclBySymbol.get(symbol);
             if (!declaration || !isJsSourceFile(declaration.getSourceFile()))
@@ -3462,6 +3816,70 @@ export class Lowerer {
             }
             return changed;
         };
+        // A reduce callback over present elements keeps the reduce helper's
+        // optional element ABI for its parameter storage, so the helper still
+        // splits each visit into a plain-element call. Its value is never
+        // absent, so nothing it flows into is widened.
+        const retypeInlineCallback = (callback, parameterIndices) => {
+            const fn = peel(callback);
+            if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn))
+                return false;
+            let changed = false;
+            for (const parameterIndex of parameterIndices) {
+                const parameter = fn.parameters[parameterIndex];
+                if (!parameter)
+                    continue;
+                const checkerType = this.typeOf(parameter.name);
+                if ((checkerType.flags & ts.TypeFlags.TypeParameter) !== 0)
+                    continue;
+                const current = this.mapTypeOf(checkerType);
+                if (!current)
+                    continue;
+                const widened = this.runtimeOptionalType(current);
+                if (!ts.isIdentifier(parameter.name)) {
+                    const previous = this.runtimeOptionalPatternTypes.get(parameter.name);
+                    this.runtimeOptionalPatternTypes.set(parameter.name, widened);
+                    if (!previous || !typeEquals(previous, widened))
+                        changed = true;
+                    continue;
+                }
+                const symbol = symbolOf(parameter.name);
+                if (!symbol)
+                    continue;
+                const previous = this.runtimeOptionalBindingTypes.get(symbol);
+                this.runtimeOptionalBindingTypes.set(symbol, widened);
+                if (!previous || !typeEquals(previous, widened))
+                    changed = true;
+            }
+            return changed;
+        };
+        // A present-element helper passes the stored element itself, so the
+        // callback must accept that exact value through a mechanical adapter.
+        // A parameter spelled as a structural supertype (`(r: { pos: number })`
+        // over a wider record) only converts through the optional element
+        // ABI's union retag; keep that site on the optional visit. Unannotated
+        // inline parameters take the element's contextual type, and generic
+        // parameters specialize later, so neither restricts the site.
+        const callbackTakesPresentElement = (callback, elem, index) => {
+            const fn = peel(callback);
+            let param;
+            if (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) {
+                const parameter = fn.parameters[index];
+                if (!parameter?.type || parameter.dotDotDotToken)
+                    return true;
+                const checkerType = this.typeOf(parameter.name);
+                if ((checkerType.flags & ts.TypeFlags.TypeParameter) !== 0)
+                    return true;
+                param = this.mapTypeOf(checkerType);
+            }
+            else {
+                const value = this.mapTypeOf(this.typeOf(fn));
+                if (value?.kind !== "func" || value.rest === true)
+                    return true;
+                param = value.params[index] ?? null;
+            }
+            return param === null || this.coercibleValue(elem, param);
+        };
         const callbackReturnsOptional = (callback, seen = new Set()) => {
             const node = peel(callback);
             if (ts.isArrowFunction(node) || ts.isFunctionExpression(node))
@@ -3479,6 +3897,253 @@ export class Lowerer {
                 !!decl.initializer &&
                 callbackReturnsOptional(decl.initializer, seen));
         };
+        // Element ABIs whose own type admits undefined (`(T | undefined)[]`,
+        // or a rest array widened for an absent argument).
+        const optionalElementKeys = new Set();
+        // Checker answers for the fixed point's repeated element-ABI queries.
+        // Only a binding's widened storage can change between passes.
+        const checkerTypes = new Map();
+        const arrayKeysOf = (node) => panicSafe(() => arrayKeysUnsafe(node), null);
+        const arrayKeysUnsafe = (node) => {
+            let checkerType = checkerTypes.get(node);
+            if (checkerType === undefined) {
+                checkerType = this.typeOf(node);
+                checkerTypes.set(node, checkerType);
+            }
+            const e = peel(node);
+            // A binding the prepass widened stores its widened array ABI.
+            const widened = ts.isIdentifier(e)
+                ? (() => {
+                    const symbol = symbolOf(e);
+                    return symbol ? this.runtimeOptionalBindingTypes.get(symbol) : undefined;
+                })()
+                : undefined;
+            let mapped = widened ?? this.mapTypeOf(checkerType);
+            if (mapped?.kind === "promise")
+                mapped = mapped.inner;
+            const anyElements = mapped?.kind === "array"
+                ? mapped.elem.kind === "dyn" || mapped.elem.kind === "jsval"
+                : mapped === null &&
+                    this.checker.isArrayType(checkerType) &&
+                    !this.checker.isTupleType(checkerType) &&
+                    ((this.checker.getTypeArguments(checkerType)[0]?.flags ?? 0) &
+                        (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !==
+                        0;
+            if (anyElements) {
+                // `new Array(n)` has an `any` element type; its storage takes the
+                // ABI of the slot it initializes.
+                const contextual = this.checker.getContextualType(node);
+                const target = contextual ? this.mapTypeOf(contextual) : null;
+                return target?.kind === "array" ? [typeKey(target.elem)] : [];
+            }
+            if (mapped === null) {
+                // An array whose element type is a type parameter: each
+                // instantiation picks its own element ABI.
+                return this.checker.isArrayType(checkerType) ? null : [];
+            }
+            const arms = mapped.kind === "union" ? (this.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
+            const keys = [];
+            for (const arm of arms) {
+                if (arm.kind !== "array")
+                    continue;
+                const key = typeKey(arm.elem);
+                if (arm.elem.kind === "union"
+                    ? this.armTag(arm.elem.unionId, UNDEFINED_T) >= 0
+                    : isUnitType(arm.elem) || arm.elem.kind === "void")
+                    optionalElementKeys.add(key);
+                keys.push(key);
+            }
+            return keys;
+        };
+        const ownership = new ArrayOwnership(sourceFiles, {
+            symbolOf,
+            declarationOf: (symbol) => this.checker.valueDeclarationOf(symbol),
+            typeOf: typeOrNull,
+            instanceAssignableTo: (owner, target) => panicSafe(() => this.checker.isTypeAssignableTo(this.checker.getTypeAtLocation(owner), target), true),
+            isGlobal: (node, name) => this.isStdlibGlobal(node, name),
+            isArray: (node) => {
+                const type = typeOrNull(node);
+                return type !== null && this.checker.isArrayType(type);
+            },
+            fieldKeys: (declaration) => arrayKeysOf(declaration.name) ?? [],
+            dynamicViewKeys: () => (dynamicViews ??= collectDynamicViews()),
+        });
+        let dynamicViews = null;
+        // Element ABIs of the native arrays that an `any` or `unknown` value is
+        // converted to, including arrays nested in the converted value.
+        const collectDynamicViews = () => {
+            const keys = new Set();
+            const dynamicValue = (node) => {
+                // A binding's declared type says whether it holds dynamic data; a
+                // flow type such as `Array.isArray(x)`'s `any[]` only narrows it.
+                const e = peel(node);
+                const symbol = ts.isIdentifier(e) ? symbolOf(e) : null;
+                const declaration = symbol ? this.checker.valueDeclarationOf(symbol) : undefined;
+                const declared = declaration &&
+                    (ts.isVariableDeclaration(declaration) || ts.isParameter(declaration)) &&
+                    ts.isIdentifier(declaration.name)
+                    ? declaration.name
+                    : null;
+                const type = typeOrNull(declared ?? node);
+                if (type === null)
+                    return true;
+                if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)
+                    return true;
+                if (!this.checker.isArrayType(type) || this.checker.isTupleType(type))
+                    return false;
+                const element = this.checker.getTypeArguments(type)[0];
+                return (element !== undefined && (element.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+            };
+            const collect = (type, depth) => {
+                if (!type || depth > 4)
+                    return;
+                if (type.kind === "array") {
+                    keys.add(typeKey(type.elem));
+                    collect(type.elem, depth + 1);
+                }
+                else if (type.kind === "union") {
+                    for (const arm of this.unions.get(type.unionId)?.arms ?? [])
+                        collect(arm, depth + 1);
+                }
+                else if (type.kind === "record") {
+                    for (const field of this.shapes.get(type.shapeId)?.fields ?? [])
+                        collect(field.type, depth + 1);
+                }
+                else if (type.kind === "promise")
+                    collect(type.inner, depth + 1);
+            };
+            const target = (type) => {
+                // An unanswerable target may be any array.
+                if (type === null)
+                    keys.add("*");
+                else if (type)
+                    collect(this.mapTypeOf(type), 0);
+            };
+            const visit = (node) => {
+                if ((ts.isAsExpression(node) || ts.isTypeAssertion(node)) && dynamicValue(node.expression))
+                    target(typeOrNull(node));
+                else if (ts.isVariableDeclaration(node) &&
+                    node.type &&
+                    node.initializer &&
+                    dynamicValue(node.initializer))
+                    target(typeOrNull(node.name));
+                else if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    dynamicValue(node.right))
+                    target(typeOrNull(node.left));
+                else if (ts.isReturnStatement(node) && node.expression && dynamicValue(node.expression))
+                    target(contextualOrNull(node.expression));
+                else if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+                    for (const arg of node.arguments ?? [])
+                        if (!ts.isSpreadElement(arg) && dynamicValue(arg))
+                            target(contextualOrNull(arg));
+                }
+                else if (ts.isPropertyAssignment(node) && dynamicValue(node.initializer))
+                    target(contextualOrNull(node.initializer));
+                else if (ts.isArrayLiteralExpression(node)) {
+                    for (const element of node.elements)
+                        if (!ts.isSpreadElement(element) &&
+                            !ts.isOmittedExpression(element) &&
+                            dynamicValue(element))
+                            target(contextualOrNull(element));
+                }
+                else if (ts.isArrowFunction(node) &&
+                    !ts.isBlock(node.body) &&
+                    dynamicValue(node.body))
+                    target(contextualOrNull(node.body));
+            };
+            for (const sf of sourceFiles)
+                ts.walkPreorder(sf, (node) => {
+                    // A checker panic hides this conversion's target: any array.
+                    if (!panicSafe(() => (visit(node), true), false))
+                        keys.add("*");
+                    return undefined;
+                });
+            return keys;
+        };
+        const elementStates = new ArrayElementStates({
+            elementAdmitsUndefined: (key) => optionalElementKeys.has(key),
+            ownerOf: (node) => ownership.ownerOf(node),
+            allocationOwner: (node) => ownership.allocationOwner(node),
+            arrayKeys: arrayKeysOf,
+            mayBeUndefined: (node) => {
+                if (explicitlyNonNull(node))
+                    return false;
+                if (mayBeOptional(node))
+                    return true;
+                // `undefined as unknown as T` keeps the undefined value.
+                for (let inner = node; ts.isParenthesizedExpression(inner) ||
+                    ts.isAsExpression(inner) ||
+                    ts.isTypeAssertion(inner) ||
+                    ts.isSatisfiesExpression(inner);) {
+                    inner = inner.expression;
+                    const type = typeOrNull(inner);
+                    if (type === null || (type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0)
+                        return true;
+                }
+                const e = peel(node);
+                if (!ts.isIdentifier(e))
+                    return false;
+                const symbol = symbolOf(e);
+                return symbol !== null && iterationSymbols.has(symbol) && !provenPresent(e, symbol);
+            },
+            callbackReturnsUndefined: (node) => callbackReturnsOptional(node),
+            isGlobal: (node, name) => this.isStdlibGlobal(node, name),
+            isString: (node) => {
+                const type = typeOrNull(node);
+                return type !== null && this.mapTypeOf(type)?.kind === "string";
+            },
+            isArrayLikeObject: (node) => {
+                if (ts.isObjectLiteralExpression(peel(node)))
+                    return true;
+                const type = typeOrNull(node);
+                const mapped = type === null ? null : this.mapTypeOf(type);
+                return (mapped === null ||
+                    mapped.kind === "record" ||
+                    mapped.kind === "object" ||
+                    mapped.kind === "dyn" ||
+                    mapped.kind === "jsval" ||
+                    mapped.kind === "union");
+            },
+            restKeys: (call) => {
+                const callee = peel(call.expression);
+                if (!ts.isIdentifier(callee) && !ts.isPropertyAccessExpression(callee))
+                    return null;
+                const symbol = callableSymbolOf(callee);
+                const sig = symbol ? signatureBySymbol.get(symbol) : undefined;
+                if (!sig)
+                    return ts.isPropertyAccessExpression(callee) ? [] : null;
+                const rest = sig.params.find((shape) => shape.mode === "rest");
+                return rest?.type.kind === "array" ? [typeKey(rest.type.elem)] : [];
+            },
+            markIterationBinding: (node, known) => {
+                const symbol = symbolOf(node);
+                if (!symbol)
+                    return false;
+                let changed = false;
+                if (!iterationSymbols.has(symbol)) {
+                    iterationSymbols.add(symbol);
+                    changed = true;
+                }
+                if (known && !holeyIterationSymbols.has(symbol)) {
+                    holeyIterationSymbols.add(symbol);
+                    // `for (name of xs)` assigns an existing binding, whose own
+                    // storage must then hold the loop's undefined too.
+                    if (!ts.isVariableDeclaration(node.parent) && !ts.isBindingElement(node.parent))
+                        optionalSymbols.add(symbol);
+                    changed = true;
+                }
+                return changed;
+            },
+            note: provenance
+                ? (fact, key, site) => provenance.note(`element-${fact}`, site, site, key)
+                : null,
+        });
+        // Each pass revisits every array callback site; the last visit holds
+        // the decision at the fixed point.
+        const presentSites = new Map();
+        // The same for each for-of loop over an array.
+        const presentLoops = new Map();
         const scanSites = new Map();
         const sitesOf = (sf) => {
             const cached = scanSites.get(sf);
@@ -3488,7 +4153,14 @@ export class Lowerer {
             ts.walkPreorder(sf, (node) => {
                 if (ts.isVariableDeclaration(node) ||
                     ts.isBinaryExpression(node) ||
-                    ts.isCallExpression(node))
+                    ts.isCallExpression(node) ||
+                    ts.isNewExpression(node) ||
+                    ts.isArrayLiteralExpression(node) ||
+                    ts.isDeleteExpression(node) ||
+                    ts.isForOfStatement(node) ||
+                    ts.isArrayBindingPattern(node) ||
+                    ts.isPrefixUnaryExpression(node) ||
+                    ts.isPostfixUnaryExpression(node))
                     nodes.push(node);
             });
             scanSites.set(sf, nodes);
@@ -3497,6 +4169,10 @@ export class Lowerer {
         const scanFile = (sf) => {
             let changed = false;
             const scan = (node) => {
+                if (elementStates.scan(node))
+                    changed = true;
+                if (ts.isForOfStatement(node))
+                    presentLoops.set(node, !elementStates.loopMayYieldUndefined(node));
                 if (ts.isVariableDeclaration(node)) {
                     if (node.initializer) {
                         const result = optionalPrimitiveResultType(node.initializer);
@@ -3524,6 +4200,16 @@ export class Lowerer {
                                 changed = true;
                             }
                         }
+                        else if (ts.isIdentifier(node.name)) {
+                            const assertion = forwardedAssertion(node.initializer);
+                            const symbol = assertion ? symbolOf(node.name) : null;
+                            if (assertion && symbol && !optionalSymbols.has(symbol)) {
+                                optionalSymbols.add(symbol);
+                                this.runtimeOptionalAssertions.add(assertion);
+                                provenance?.note("asserted-binding", node.name, node.initializer);
+                                changed = true;
+                            }
+                        }
                         if (ts.isIdentifier(node.name)) {
                             const valueSymbol = ts.isIdentifier(peel(node.initializer))
                                 ? symbolOf(peel(node.initializer))
@@ -3565,6 +4251,22 @@ export class Lowerer {
                         }
                         if (scanPattern(node.name, node.initializer))
                             changed = true;
+                        if (ts.isIdentifier(node.name)) {
+                            const symbol = symbolOf(node.name);
+                            const init = peel(node.initializer);
+                            if (symbol && noteFieldsFrom(symbol, init)) {
+                                provenance?.note("record-copy", node.name, node.initializer);
+                                changed = true;
+                            }
+                            if (symbol && ts.isObjectLiteralExpression(init)) {
+                                for (const field of spreadFieldsOf(init)) {
+                                    if (noteFieldSymbol(symbol, field)) {
+                                        provenance?.note("record-spread", node.name, node.initializer);
+                                        changed = true;
+                                    }
+                                }
+                            }
+                        }
                         if (ts.isIdentifier(node.name) &&
                             ts.isObjectLiteralExpression(peel(node.initializer))) {
                             const object = peel(node.initializer);
@@ -3586,6 +4288,36 @@ export class Lowerer {
                         }
                     }
                 }
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isIdentifier(node.left)) {
+                    const symbol = symbolOf(node.left);
+                    if (symbol && noteFieldsFrom(symbol, node.right)) {
+                        provenance?.note("record-copy", node.left, node.right);
+                        changed = true;
+                    }
+                }
+                if (ts.isBinaryExpression(node) &&
+                    node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    ts.isIdentifier(node.left)) {
+                    const assertion = forwardedAssertion(node.right);
+                    const symbol = assertion ? symbolOf(node.left) : null;
+                    // Only a variable's storage is promoted (see the final pass).
+                    const declaration = symbol ? this.checker.valueDeclarationOf(symbol) : undefined;
+                    if (assertion &&
+                        symbol &&
+                        declaration &&
+                        ts.isVariableDeclaration(declaration) &&
+                        ts.isIdentifier(declaration.name) &&
+                        !this.runtimeOptionalAssertions.has(assertion)) {
+                        this.runtimeOptionalAssertions.add(assertion);
+                        if (!optionalSymbols.has(symbol)) {
+                            optionalSymbols.add(symbol);
+                            provenance?.note("asserted-binding", node.left, node.right);
+                        }
+                        changed = true;
+                    }
+                }
                 if (ts.isBinaryExpression(node) &&
                     (node.operatorToken.kind === ts.SyntaxKind.EqualsToken ||
                         node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionEqualsToken ||
@@ -3607,6 +4339,14 @@ export class Lowerer {
                             provenance?.note("static-field", node.left, node.right);
                             changed = true;
                         }
+                        else if (field && !optionalSymbols.has(field) && optionalInstanceField(field)) {
+                            // The checker narrows the field to the assigned read's bare
+                            // type, but the stored value can be undefined: reads keep the
+                            // stored union (runtimeOptionalClassField).
+                            optionalSymbols.add(field);
+                            provenance?.note("assigned-field", node.left, node.right);
+                            changed = true;
+                        }
                         else if (ts.isIdentifier(node.left.expression)) {
                             const symbol = symbolOf(node.left.expression);
                             if (symbol && noteFieldSymbol(symbol, node.left.name.text)) {
@@ -3655,11 +4395,25 @@ export class Lowerer {
                         }
                         if (nativeArrayReceiver) {
                             provenanceSite = node;
-                            if (promoteHofCallback(callback, callbackIndices))
-                                changed = true;
                             const method = node.expression.name.text;
+                            // Callbacks skip holes (except the find family), so an array
+                            // that never holds undefined only passes present elements.
+                            const reduce = method === "reduce" || method === "reduceRight";
+                            const elementsPresent = receiver?.kind === "array" &&
+                                elementStates.elementsPresent(receiverNode, method) &&
+                                callbackTakesPresentElement(callback, receiver.elem, reduce ? 1 : 0);
+                            // A callback returning a runtime-absent value still needs its
+                            // widened return, whatever its elements.
+                            if (promoteHofCallback(callback, elementsPresent ? [] : callbackIndices))
+                                changed = true;
+                            // Element-typed callback helpers cover every method but
+                            // reduce, whose accumulator keeps the split visit.
+                            presentSites.set(node, elementsPresent && !reduce);
+                            if (elementsPresent && reduce && retypeInlineCallback(callback, callbackIndices))
+                                changed = true;
                             if ((method === "reduce" || method === "reduceRight") &&
-                                (node.arguments.length < 2 || callbackReturnsOptional(callback))) {
+                                ((!elementsPresent && node.arguments.length < 2) ||
+                                    callbackReturnsOptional(callback))) {
                                 if (promoteHofCallback(callback, [0, 1]))
                                     changed = true;
                                 const result = this.runtimeOptionalType(this.irTypeOf(node));
@@ -3678,8 +4432,34 @@ export class Lowerer {
                     if (!symbol)
                         return;
                     const sig = signatureBySymbol.get(symbol);
-                    if (!sig)
+                    if (!sig) {
+                        // A direct call of a function-valued const (`const show = (n:
+                        // number) => ...`): a possibly missing argument widens that
+                        // parameter, as for a callback the same value is passed as.
+                        if (!ts.isIdentifier(node.expression) || reassigned.has(symbol))
+                            return;
+                        const declaration = this.checker.valueDeclarationOf(symbol);
+                        const value = declaration && ts.isVariableDeclaration(declaration) && declaration.initializer
+                            ? peel(declaration.initializer)
+                            : null;
+                        if (!value || !(ts.isArrowFunction(value) || ts.isFunctionExpression(value)))
+                            return;
+                        // Optional, defaulted and rest parameters keep their own ABI.
+                        if (value.parameters.some((parameter) => parameter.questionToken !== undefined ||
+                            parameter.initializer !== undefined ||
+                            parameter.dotDotDotToken !== undefined))
+                            return;
+                        const indices = node.arguments.flatMap((arg, i) => !ts.isSpreadElement(arg) &&
+                            value.parameters[i] !== undefined &&
+                            !value.parameters[i].dotDotDotToken &&
+                            mayBeOptional(arg)
+                            ? [i]
+                            : []);
+                        provenanceSite = node;
+                        if (indices.length > 0 && promoteHofCallback(node.expression, indices))
+                            changed = true;
                         return;
+                    }
                     // JSDoc describes the usual value, not a runtime arity check.
                     // A short JavaScript call still passes undefined. Widen only the
                     // observed slots before bodies lower so both caller and callee
@@ -3736,8 +4516,57 @@ export class Lowerer {
                                 changed = true;
                             }
                         }
-                        if (ts.isSpreadElement(arg) || !mayBeOptional(arg) || !shape)
+                        if (!ts.isSpreadElement(arg) && shape && i !== restAt && fieldsOfValue(arg)) {
+                            const fields = fieldsOfValue(arg);
+                            for (const target of familyBySymbol.get(symbol) ?? [symbol]) {
+                                const parameterShape = signatureBySymbol.get(target)?.params[i];
+                                const parameter = functionDeclBySymbol.get(target)?.parameters[i];
+                                if (!parameterShape || parameterShape.type.kind !== "record")
+                                    continue;
+                                if (!parameter || !ts.isIdentifier(parameter.name))
+                                    continue;
+                                const bound = symbolOf(parameter.name);
+                                if (!bound)
+                                    continue;
+                                let promoted = parameterShape.type;
+                                for (const field of fields) {
+                                    const source = promoted.kind === "record"
+                                        ? this.shapes.get(promoted.shapeId)?.fields.find((f) => f.name === field)
+                                        : undefined;
+                                    if (source) {
+                                        promoted = this.runtimeOptionalRecordField(promoted, field, addUndefined(source.type));
+                                    }
+                                    if (noteFieldSymbol(bound, field))
+                                        changed = true;
+                                }
+                                if (!typeEquals(promoted, parameterShape.type)) {
+                                    parameterShape.type = promoted;
+                                    this.runtimeOptionalBindingTypes.set(bound, promoted);
+                                    provenance?.note("record-parameter", parameter, arg);
+                                    changed = true;
+                                }
+                            }
+                        }
+                        if (ts.isSpreadElement(arg) || !shape)
                             return;
+                        const assertion = forwardedAssertion(arg) ?? forwardedElementAssertion(arg);
+                        if (!assertion && !mayBeOptional(arg))
+                            return;
+                        if (assertion) {
+                            if (i === restAt)
+                                return;
+                            // An omittable slot's ABI already holds undefined (an
+                            // optional or defaulted parameter applies its own default).
+                            if (shape.mode === "omittable") {
+                                if (shape.type.kind === "union" &&
+                                    this.armTag(shape.type.unionId, UNDEFINED_T) >= 0)
+                                    this.runtimeOptionalAssertions.add(assertion);
+                                return;
+                            }
+                            if (shape.mode !== "required")
+                                return;
+                            this.runtimeOptionalAssertions.add(assertion);
+                        }
                         if (i === restAt) {
                             // A rest binding always receives an array. An unchecked
                             // argument can make its elements undefined, not the pack.
@@ -3831,6 +4660,52 @@ export class Lowerer {
             for (const [symbol, decl] of functionDeclBySymbol)
                 if (scanReturns(symbol, decl))
                     changed = true;
+            for (const fn of tsLambdas) {
+                // An annotated return is the author's contract, as for parameters.
+                if (fn.type)
+                    continue;
+                const mapped = this.mapTypeOf(this.typeOf(fn));
+                if (mapped?.kind !== "func")
+                    continue;
+                const previous = this.runtimeOptionalFunctionReturnType(fn, mapped.ret);
+                // Async, generator and void bodies keep their own result shapes.
+                if (previous.kind === "promise" ||
+                    previous.kind === "generator" ||
+                    previous.kind === "void")
+                    continue;
+                const arithmetic = lambdaArithmeticReturn(fn);
+                const next = arithmetic &&
+                    (previous.kind === "f64" || previous.kind === "string" || previous.kind === "bool")
+                    ? arithmetic
+                    : bodyReturnsOptional(fn)
+                        ? this.runtimeOptionalType(previous)
+                        : previous;
+                if (!typeEquals(previous, next)) {
+                    this.runtimeOptionalFunctionReturns.set(fn, next);
+                    provenance?.note("lambda-return", fn, fn.body);
+                    changed = true;
+                }
+                // Calls through the lambda's own binding (`const get = () => xs[i];
+                // get()`) produce the same result as calls of a declared function.
+                const binding = fn.parent;
+                if (next !== previous &&
+                    ts.isVariableDeclaration(binding) &&
+                    binding.initializer === fn &&
+                    !binding.type &&
+                    ts.isIdentifier(binding.name)) {
+                    const symbol = symbolOf(binding.name);
+                    if (symbol && next.kind === "union" && this.armTag(next.unionId, UNDEFINED_T) >= 0) {
+                        if (!optionalReturns.has(symbol)) {
+                            optionalReturns.add(symbol);
+                            changed = true;
+                        }
+                    }
+                    else if (symbol && !arithmeticReturns.has(symbol)) {
+                        arithmeticReturns.set(symbol, next);
+                        changed = true;
+                    }
+                }
+            }
             for (const fn of jsLambdas) {
                 if (!bodyReturnsOptional(fn))
                     continue;
@@ -3862,6 +4737,31 @@ export class Lowerer {
                 }
             }
         }
+        // NaN-coded slots convert optional values on entry instead of holding
+        // the union, so promotion never applies to them.
+        for (const symbol of [...optionalSymbols])
+            if (nanCoded.nanCodedBinding(symbol))
+                optionalSymbols.delete(symbol);
+        for (const symbol of [...optionalReturns])
+            if (nanCoded.nanCodedReturn(symbol))
+                optionalReturns.delete(symbol);
+        for (const [symbol, params] of optionalParams) {
+            const decl = functionDeclBySymbol.get(symbol);
+            for (const index of [...params]) {
+                const name = decl?.parameters[index]?.name;
+                const param = name && ts.isIdentifier(name) ? symbolOf(name) : null;
+                if (param && nanCoded.nanCodedBinding(param))
+                    params.delete(index);
+            }
+            if (params.size === 0)
+                optionalParams.delete(symbol);
+        }
+        for (const [site, present] of presentSites)
+            if (present)
+                this.presentElementCalls.add(site);
+        for (const [loop, present] of presentLoops)
+            if (present)
+                this.presentElementLoops.add(loop);
         const globalsById = new Map(this.globalsList.map((global) => [global.id, global]));
         for (const [symbol, field] of staticFieldsBySymbol) {
             if (!optionalSymbols.has(symbol))
@@ -3928,11 +4828,11 @@ export class Lowerer {
                 const symbol = symbolOf(node.name);
                 if (!symbol)
                     return;
-                if (isJsSourceFile(sf) &&
-                    !node.type &&
+                if (!node.type &&
                     !hasJsTypeAnnotation(node) &&
                     node.initializer &&
-                    (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+                    (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) &&
+                    (isJsSourceFile(sf) || this.runtimeOptionalFunctionReturns.has(node.initializer))) {
                     const global = this.globalsBySymbol.get(symbol);
                     if (global?.type.kind === "func")
                         global.type = {
@@ -4008,6 +4908,35 @@ export class Lowerer {
                 }
             });
         }
+        for (const symbol of optionalSymbols)
+            this.runtimeOptionalAssignedSymbols.add(symbol);
+        // `decode(xs[i]!)` into a parameter whose final ABI already holds
+        // undefined: the assertion has no runtime effect, so a missing element
+        // reaches the callee as undefined instead of trapping at the read.
+        for (const sf of sourceFiles) {
+            for (const node of sitesOf(sf)) {
+                if (!ts.isCallExpression(node))
+                    continue;
+                if (!ts.isIdentifier(node.expression) && !ts.isPropertyAccessExpression(node.expression))
+                    continue;
+                const symbol = callableSymbolOf(node.expression);
+                const sig = symbol ? signatureBySymbol.get(symbol) : undefined;
+                if (!sig || node.arguments.some(ts.isSpreadElement))
+                    continue;
+                node.arguments.forEach((arg, i) => {
+                    let e = arg;
+                    while (ts.isParenthesizedExpression(e))
+                        e = e.expression;
+                    if (!ts.isNonNullExpression(e) || !isIndexedRead(e.expression))
+                        return;
+                    const shape = sig.params[i];
+                    if (shape?.mode !== "required" && shape?.mode !== "omittable")
+                        return;
+                    if (shape.type.kind === "union" && this.armTag(shape.type.unionId, UNDEFINED_T) >= 0)
+                        this.runtimeOptionalAssertions.add(e);
+                });
+            }
+        }
         provenance?.flush();
     }
     run() {
@@ -4058,14 +4987,14 @@ export class Lowerer {
                 if (fn)
                     functions.push(fn);
                 else if (this.countsSkips())
-                    this.stats.functionsSkipped++;
+                    this.countSkippedBody(decl);
             }
             for (const decl of fp.classDecls) {
                 const info = this.classes.get(this.classNamer(decl));
                 if (info)
                     functions.push(...this.lowerClassMembers(info));
                 else if (this.countsSkips())
-                    this.stats.functionsSkipped++;
+                    this.countSkippedBody(decl);
             }
         }
         // Each file's top-level statements form its run-once init function.
@@ -4153,10 +5082,10 @@ export class Lowerer {
             // Deferred collection diagnostics nothing flushed — declarations no
             // reference ever made relevant. They belong to the unreached group
             // (collection order keeps them deterministic).
-            for (const [symbol, diags] of this.deferredDiags) {
+            for (const [symbol, diags] of [...this.deferredDiags]) {
                 if (this.alreadyFlushed.has(symbol))
                     continue;
-                for (const d of diags)
+                for (const d of [...diags])
                     this.pushDiag(d);
             }
             return {
@@ -4277,6 +5206,7 @@ export class Lowerer {
                 ...(this.npmEmbedded ? { embedded: this.npmEmbedded } : {}),
                 entry: ENTRY_NAME,
                 ...(this.usesWorkers ? { workers: true } : {}),
+                ...(isNodeEsmFile(this.entry, this.program) ? {} : { commonJsEntry: true }),
                 ...(this.ffiImports.length > 0 ? { ffiImports: [...this.ffiImports] } : {}),
             };
         if (module)
@@ -4298,41 +5228,72 @@ export class Lowerer {
      * registered ClassInfo — the shape of a JS class whose collection fenced.
      * Used by run()'s global pruning; shapes/unions recurse with a seen-set
      * (interned ids can nest). */
-    typeNamesUnregisteredClass(t, seen = new Set()) {
+    typeNamesUnregisteredClass(t) {
+        return this.unregisteredClassOf(t, new Set()) !== null;
+    }
+    /** The first class name typeNamesUnregisteredClass finds in `t`. */
+    unregisteredClassOf(t, seen) {
+        const first = (types) => {
+            for (const type of types) {
+                const name = this.unregisteredClassOf(type, seen);
+                if (name !== null)
+                    return name;
+            }
+            return null;
+        };
         switch (t.kind) {
             case "object":
-                return !this.classes.has(t.className);
+                return this.classes.has(t.className) ? null : t.className;
             case "array":
             case "set":
-                return this.typeNamesUnregisteredClass(t.elem, seen);
+                return first([t.elem]);
             case "map":
-                return (this.typeNamesUnregisteredClass(t.key, seen) ||
-                    this.typeNamesUnregisteredClass(t.value, seen));
+                return first([t.key, t.value]);
             case "promise":
-                return this.typeNamesUnregisteredClass(t.inner, seen);
+                return first([t.inner]);
             case "func":
-                return (t.params.some((p) => this.typeNamesUnregisteredClass(p, seen)) ||
-                    this.typeNamesUnregisteredClass(t.ret, seen));
+                return first([...t.params, t.ret]);
             case "record": {
                 if (seen.has(t.shapeId))
-                    return false;
+                    return null;
                 seen.add(t.shapeId);
                 const shape = this.shapes.get(t.shapeId);
                 if (!shape)
-                    return false;
-                if (shape.indexValue && this.typeNamesUnregisteredClass(shape.indexValue, seen))
-                    return true;
-                return shape.fields.some((f) => this.typeNamesUnregisteredClass(f.type, seen));
+                    return null;
+                return first([
+                    ...(shape.indexValue ? [shape.indexValue] : []),
+                    ...shape.fields.map((f) => f.type),
+                ]);
             }
             case "union": {
                 if (seen.has(t.unionId))
-                    return false;
+                    return null;
                 seen.add(t.unionId);
                 const def = this.unions.get(t.unionId);
-                return !!def && def.arms.some((a) => this.typeNamesUnregisteredClass(a, seen));
+                return def ? first(def.arms) : null;
             }
             default:
-                return false;
+                return null;
+        }
+    }
+    /** A declaration whose signature blocked never lowers its body, so its
+     * statements would otherwise vanish from the coverage totals and the
+     * percentage would overstate how much of the program compiles. Count
+     * every statement the body holds as attempted and failed, in addition to
+     * the skipped-function tally. */
+    countSkippedBody(decl) {
+        this.stats.functionsSkipped++;
+        if (this.suppressStats)
+            return;
+        const n = countBodyStatements(decl);
+        if (n === 0)
+            return;
+        this.stats.statementsTotal += n;
+        this.stats.statementsFailed += n;
+        const file = decl.getSourceFile().fileName;
+        for (let i = 0; i < n; i++) {
+            this.bumpFileStat(file, "total");
+            this.bumpFileStat(file, "failed");
         }
     }
     /** Whether run() counts a signature-blocked declaration in
@@ -4868,13 +5829,18 @@ export class Lowerer {
         const d = this.instantiationContext
             ? { ...diag, message: `${diag.message} (${this.instantiationContext})` }
             : diag;
+        const pending = this.pendingFlushes.get(diag);
         // Deferred collection: the wrapper decides whether these ever report
         // (a reference flushes them; unreferenced declarations stay silent in
         // builds and report under coverage's unreached group).
         if (this.diagSink) {
+            if (pending && d !== diag)
+                this.pendingFlushes.set(d, pending);
             this.diagSink.push(d);
             return;
         }
+        if (pending)
+            this.commitFlush(pending.symbol, pending.source);
         // One site, one report: some declarations map a type twice (module
         // globals pre-register before their initializers lower) — an exact
         // duplicate (code + span + message) adds noise, not information.
@@ -5518,6 +6484,24 @@ export class Lowerer {
             this.pushDiag(recordShapeMismatchDiag(this.fmt(expected), this.fmt(actual), locOf(node), detail));
             throw new PoisonError();
         }
+        // Instances of two unrelated classes: class identity is nominal here,
+        // so a structurally compatible instance never becomes the other class.
+        // An assertion (`x as Y`) names the mistake most directly.
+        if (actual.kind === "object" &&
+            expected.kind === "object" &&
+            this.classes.has(actual.className) &&
+            this.classes.has(expected.className) &&
+            this.classes.get(actual.className).decl !== this.classes.get(expected.className).decl &&
+            !this.isSubclassOf(actual.className, expected.className) &&
+            !this.isSubclassOf(expected.className, actual.className)) {
+            let site = node;
+            while (ts.isParenthesizedExpression(site))
+                site = site.expression;
+            const assertion = ts.isAsExpression(site) || ts.isTypeAssertion(site);
+            this.unsupported("SC1090", node, `${assertion ? "asserting" : "using"} a '${this.fmt(actual)}' instance as the unrelated class '${this.fmt(expected)}' (neither class extends the other, and class identity is nominal in compiled code)`, assertion
+                ? `narrow with \`instanceof ${this.fmt(expected)}\` where the value can really be one, or declare a shared base class and assert through it`
+                : `make one class extend the other, or construct a '${this.fmt(expected)}' from the value's fields`);
+        }
         // Iterator-typed slots hold generators and built-in collection
         // iterators; any other iterator object (a user class) stays fenced.
         if (expected.kind === "generator" && actual.kind !== "generator") {
@@ -5601,6 +6585,13 @@ export class Lowerer {
      * else (including a DIFFERENT union) is left for requireExactShape, which
      * rejects union mismatches with SC2003. */
     coerceToExpected(expr, expected) {
+        // A destination that holds undefined takes an unassigned deferred-init
+        // field's slot as is (Node passes the undefined along).
+        if (expected.kind === "union" && this.armTag(expected.unionId, UNDEFINED_T) >= 0) {
+            const slot = this.deferredFieldSlot(expr);
+            if (slot)
+                expr = slot;
+        }
         if (expr.type.kind === "void" && expected.kind !== "void" && this.neverValued.has(expr))
             return this.divergentValue(expr, expected);
         // Iterator-typed slots: native iterators and differently typed
@@ -5759,9 +6750,18 @@ export class Lowerer {
                 };
             }
             if (expr.kind === "unitLit" || this.dynConvertible(expr.type)) {
-                const shape = expr.type.kind === "record" ? this.shapes.get(expr.type.shapeId) : undefined;
-                const liveRef = expr.type.kind === "array" ||
-                    (!!shape && (shape.fields.length > 0 || shape.indexValue !== undefined));
+                // Records and arrays keep their identity as untyped values, including
+                // when they arrive through a union, so `unknown` views, weak
+                // collection keys and later typed reads all see the same object.
+                const liveReference = (type) => {
+                    if (type.kind === "array")
+                        return true;
+                    const shape = type.kind === "record" ? this.shapes.get(type.shapeId) : undefined;
+                    return !!shape && (shape.fields.length > 0 || shape.indexValue !== undefined);
+                };
+                const liveRef = liveReference(expr.type) ||
+                    (expr.type.kind === "union" &&
+                        (this.unions.get(expr.type.unionId)?.arms.some(liveReference) ?? false));
                 return {
                     kind: "dynFrom",
                     value: expr,
@@ -5955,7 +6955,7 @@ export class Lowerer {
                 this.armTag(expr.type.unionId, expected) >= 0) {
                 const helper = this.narrowedArmHelper(expr.type.unionId, expected, expr.loc);
                 if (helper) {
-                    return { kind: "call", callee: helper, args: [expr], type: expected, loc: expr.loc };
+                    return this.checkedNarrowCall(helper, expr, expected, expr.loc);
                 }
             }
             if (!typeEquals(expr.type, expected)) {
@@ -6206,6 +7206,9 @@ export class Lowerer {
     narrowedArmHelper(fromId, target, loc) {
         return narrowedArmHelper(this, fromId, target, loc);
     }
+    checkedNarrowCall(helper, value, type, loc) {
+        return checkedNarrowCall(this, helper, value, type, loc);
+    }
     deferredReadHelper(fromId, target, loc) {
         return deferredReadHelper(this, fromId, target, loc);
     }
@@ -7024,15 +8027,47 @@ export class Lowerer {
     flushDeferred(symbol) {
         if (this.collecting)
             return;
+        this.reportDeferred(symbol);
+    }
+    /** flushDeferred without the collection-pass guard: for declarations
+     * whose diagnostics must report eagerly (class statements with
+     * declaration-time code, extended bases — collectClassShapeDeferring). */
+    reportDeferred(symbol) {
         const diags = this.deferredDiags.get(symbol);
         if (!diags)
             return;
-        this.deferredDiags.delete(symbol);
-        if (this.alreadyFlushed.has(symbol))
-            return; // the emit pass reported these
-        this.flushedSymbols.add(symbol);
-        for (const d of diags)
+        if (this.alreadyFlushed.has(symbol)) {
+            this.deferredDiags.delete(symbol); // the emit pass reported these
+            return;
+        }
+        if (this.diagSink === null) {
+            this.deferredDiags.delete(symbol);
+            this.flushedSymbols.add(symbol);
+            for (const d of diags)
+                this.pushDiag(d);
+            return;
+        }
+        // A capture buffer is active (a probe, or another declaration's
+        // deferred collection): the copies ride that buffer, and the
+        // declaration stays deferred until one of them reaches the build.
+        for (const d of diags) {
+            this.pendingFlushes.set(d, { symbol, source: d });
             this.pushDiag(d);
+        }
+    }
+    /** A flushed copy of a deferred diagnostic reached `diags`: that
+     * diagnostic is reported, so it leaves the declaration's deferred list
+     * (the declaration counts as flushed for the coverage remainder). */
+    commitFlush(symbol, source) {
+        this.flushedSymbols.add(symbol);
+        const list = this.deferredDiags.get(symbol);
+        if (!list)
+            return;
+        const index = list.indexOf(source);
+        if (index >= 0)
+            list.splice(index, 1);
+        if (list.length === 0)
+            this.deferredDiags.delete(symbol);
     }
     flushDeferredClass(className) {
         const symbol = this.deferredClassByName.get(className);
@@ -7339,7 +8374,23 @@ export class Lowerer {
     }
     /* ── scoping and captures ─────────────────────────────────────────── */
     declareLocal(nameNode, name, type, mutable) {
-        return declareContextLocal(this.ctx, name, type, mutable, this.checker.getSymbolAtLocation(nameNode), bindingSource(nameNode));
+        const symbol = this.checker.getSymbolAtLocation(nameNode);
+        const local = declareContextLocal(this.ctx, name, type, mutable, symbol, bindingSource(nameNode));
+        // A binding declared `T | undefined` that receives a missing read: the
+        // checker narrows it to `T` after the assignment, but the stored value
+        // can be undefined. Track it like widened storage so bare reads keep
+        // the union until a guard proves presence.
+        if (symbol &&
+            this.runtimeOptionalAssignedSymbols.has(symbol) &&
+            type.kind === "union" &&
+            this.armTag(type.unionId, UNDEFINED_T) >= 0 &&
+            this.unions.get(type.unionId)?.arms.length === 2 &&
+            !isUnitType(this.stripUndefinedArm(type))) {
+            const root = this.runtimeOptionalRootOf(local);
+            this.runtimeOptionalStorageLocals.add(root);
+            this.runtimeOptionalLocals.add(root);
+        }
+        return local;
     }
     /** A never-returning call in a value position of type `expected`: the
      * call runs for its effects (it throws or exits), and the expression ends
@@ -8111,13 +9162,7 @@ export class Lowerer {
         const helper = this.narrowedArmHelper(optional.unionId, optional.present, locOf(stmt.expression));
         if (!helper)
             return lowerForOf(this, stmt);
-        return this.withExpressionOverride(stmt.expression, {
-            kind: "call",
-            callee: helper,
-            args: [optional.value],
-            type: optional.present,
-            loc: locOf(stmt.expression),
-        }, () => lowerForOf(this, stmt));
+        return this.withExpressionOverride(stmt.expression, this.checkedNarrowCall(helper, optional.value, optional.present, locOf(stmt.expression)), () => lowerForOf(this, stmt));
     }
     lowerForStatement(stmt) {
         return lowerForStatement(this, stmt);
@@ -8362,21 +9407,21 @@ export class Lowerer {
             const helper = this.narrowedArmHelper(optionalRight.unionId, optionalRight.present, locOf(expr.right));
             if (!helper)
                 return lower();
-            right = {
-                kind: "call",
-                callee: helper,
-                args: [optionalRight.value],
-                type: optionalRight.present,
-                loc: locOf(expr.right),
-            };
+            right = this.checkedNarrowCall(helper, optionalRight.value, optionalRight.present, locOf(expr.right));
         }
         else {
             right = this.lowerExpr(expr.right);
         }
         if (right.type.kind !== "classval")
             return lower();
-        const stableRight = this.declareHiddenLocal("%instanceofRight", right.type);
-        const rightValue = varRef(stableRight.id, right.type, locOf(expr.right));
+        // A capture-free class reference is the immortal static class object:
+        // re-reading it is pure, so it needs no owned temporary (whose retain
+        // and release would be out-of-line calls on every test).
+        const constantRight = right.kind === "classRef" && right.captures === undefined;
+        const stableRight = constantRight
+            ? null
+            : this.declareHiddenLocal("%instanceofRight", right.type);
+        const rightValue = stableRight ? varRef(stableRight.id, right.type, locOf(expr.right)) : right;
         const body = this.withExpressionOverride(expr.left, {
             kind: "unionNarrow",
             unionId: left.type.unionId,
@@ -8389,7 +9434,16 @@ export class Lowerer {
             kind: "seqExpr",
             stmts: [
                 { kind: "varDecl", localId: stable.id, init: left, loc: locOf(expr.left) },
-                { kind: "varDecl", localId: stableRight.id, init: right, loc: locOf(expr.right) },
+                ...(stableRight
+                    ? [
+                        {
+                            kind: "varDecl",
+                            localId: stableRight.id,
+                            init: right,
+                            loc: locOf(expr.right),
+                        },
+                    ]
+                    : []),
             ],
             result: {
                 kind: "ternary",
@@ -8420,13 +9474,7 @@ export class Lowerer {
         const helper = this.narrowedArmHelper(optional.unionId, optional.present, locOf(node));
         if (!helper)
             return lower();
-        return this.withExpressionOverride(node, {
-            kind: "call",
-            callee: helper,
-            args: [optional.value],
-            type: optional.present,
-            loc: locOf(node),
-        }, lower);
+        return this.withExpressionOverride(node, this.checkedNarrowCall(helper, optional.value, optional.present, locOf(node)), lower);
     }
     withExpressionOverride(node, value, lower) {
         const previous = this.chainRecvByNode.get(node);
@@ -8535,6 +9583,37 @@ export class Lowerer {
     fieldGetExpr(target, loc, blame) {
         return fieldGetExpr(this, target, loc, blame);
     }
+    /** The undefined-armed slot read behind a checked deferred-init field
+     * read, or null. Consumers that observe undefined itself (equality,
+     * typeof, truthiness, nullish defaults) test the slot instead of the
+     * checked extraction, which throws for an unassigned field. */
+    deferredFieldSlot(value) {
+        // The inline form: `slot is undefined ? throw : narrow(slot)`.
+        if (value.kind === "ternary" &&
+            value.cond.kind === "unionIsTag" &&
+            value.else_.kind === "unionNarrow" &&
+            value.else_.value === value.cond.value &&
+            value.then.kind === "libCall" &&
+            value.then.fn === "error.nodeThrow") {
+            const read = value.cond.value;
+            return read.kind === "fieldGet" &&
+                read.type.kind === "union" &&
+                this.classes.get(read.className)?.deferredInitFields?.has(read.field) === true
+                ? read
+                : null;
+        }
+        if (value.kind !== "call" || value.args.length !== 1)
+            return null;
+        const read = value.args[0];
+        if (read.kind !== "fieldGet" || read.type.kind !== "union")
+            return null;
+        if (this.classes.get(read.className)?.deferredInitFields?.has(read.field) !== true)
+            return null;
+        return this.coercions.checkedNarrows.has(value.callee) ||
+            value.callee.startsWith("%deferred.read.")
+            ? read
+            : null;
+    }
     fieldSetStmt(target, value, loc, blame) {
         return fieldSetStmt(this, target, value, loc, blame);
     }
@@ -9218,8 +10297,8 @@ export class Lowerer {
         return lowerNumberStaticProperty(this, expr);
     }
     /* ── the island-backed ambient surface (ISLAND_SURFACE) ───────────── */
-    requireDynamicApi(feature, node) {
-        return requireDynamicApi(this, feature, node);
+    requireDynamicApi(feature, node, hint) {
+        return requireDynamicApi(this, feature, node, hint);
     }
     lowerMathProperty(expr) {
         return lowerMathProperty(this, expr);