@scriptc/compiler 0.1.1 → 0.1.3

package/dist/frontend/lowering/lower-exprs.js

@@ -9,12 +9,12 @@ import * as ts from "../ts7/adapter.js";
 import { dirname, posix } from "node:path";
 import { pathToFileURL } from "node:url";
 import { wasiGuestPath } from "../../wasi-paths.js";
-import { BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, canDynCheckTo, funcOf, isJsonSafeType, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionFuncSetArmsOk } from "../../ir/ir.js";
+import { BIGINT_T, BOOL, CAUGHT, DYN, DYN_HANDLE_KINDS, F64, JSVAL, NULL_T, REF_TRUTHY_KINDS, REGEX, RUNTIME_ERROR_CLASSES, SEARCH_PARAMS_T, STRING, UNDEFINED_T, VOID, arrayOf, canAdaptDynFuncTo, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isJsonSafeType, isSupportedArrayElem, isUnitType, jsOpResultKind, shapeHasAccessorSlots, typeEquals, typeKey, unionFuncSetArmsOk } from "../../ir/ir.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf } from "../program.js";
 import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstOf, builtinModulesArrayLit, builtinModuleFnOf, ISLAND_SURFACE, isChildSurfaceMember, MAP_METHODS, NARROW_FIRST, SET_METHODS, STR_METHODS, UNSUPPORTED_EXPR, sideEffectFreeOptionValue, stdlibGlobalNameOf } from "./surfaces.js";
-import { blockedBindingUseDiag, recordShapeMismatchDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
+import { blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { PoisonError, dynUndefinedExpr, jsFuncNameOf, neverTaintedJsType, nodeThrowExpr, own } from "./lowerer.js";
-import { lowerIndexMergeHelper, lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall } from "./lower-containers.js";
+import { lowerNpmStaticSafeIndexRead, lowerSafeIndexRead, strCharsCall } from "./lower-containers.js";
 import { arrayValueStore } from "./array-values.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { unsupportedModuleFeatureOf } from "../builtin-modules.js";
@@ -29,6 +29,11 @@ import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTy
 import { lowerYield } from "./lower-generators.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
 import { countedFor, numLit, varRef } from "../../ir/build.js";
+import { isSafeToDiscard, isSafeToMoveConditionEarlier, isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { hasOptionalChainGuard, isOptionalChainTail, isRequireMainFilename } from "./expressions/optional-chains.js";
+import { conditionalSpreadOf, foldedStringKeyOf } from "./expressions/object-literals.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
+import { fenceNodeModuleMutation, isNodeModuleValue, lowerNodeModuleIdentifier, lowerNodeModuleProperty, lowerRequireCacheElement, lowerRequireCacheHas, lowerRequireMainProperty } from "./lower-node-module.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
  * declares it; the serialized node data omits it), so the raw span comes
@@ -138,6 +143,16 @@ function lowerExprInner(lowerer, expr) {
         }
         return { kind: "numLit", value, type: F64, loc };
     }
+    if (ts.isBigIntLiteral(expr)) {
+        const spelling = expr.getText().replace(/_/g, "").replace(/n$/i, "");
+        return {
+            kind: "libCall",
+            fn: "bigint.parse",
+            args: [{ kind: "strLit", value: spelling, type: STRING, loc }],
+            type: BIGINT_T,
+            loc,
+        };
+    }
     if (expr.kind === ts.SyntaxKind.TrueKeyword) {
         return { kind: "boolLit", value: true, type: BOOL, loc };
     }
@@ -405,7 +420,7 @@ function lowerExprInner(lowerer, expr) {
                             lowerer.unsupported("SC1090", prop, "a conditional spread mixed with plain spreads in an 'any'-typed object literal");
                         }
                         const cond = lowerer.lowerCondition(cs.cond);
-                        if (!pureCondExpr(cond)) {
+                        if (!isSafeToMoveConditionEarlier(cond)) {
                             lowerer.unsupported("SC1090", prop, "conditional spreads with effectful conditions in an 'any'-typed object literal (bind the condition to a const first)");
                         }
                         spread = { cond, whenTrue: cs.whenTrue };
@@ -533,6 +548,14 @@ function lowerExprInner(lowerer, expr) {
         return { kind: "jsOp", op: "arrLit", args, type: JSVAL, loc };
     }
     if (ts.isTypeOfExpression(expr)) {
+        if (isNodeModuleValue(lowerer, expr.expression)) {
+            return { kind: "strLit", value: "object", type: STRING, loc };
+        }
+        if (ts.isPropertyAccessExpression(expr.expression)) {
+            const presence = lowerPromiseThenPresence(lowerer, expr.expression, { kind: "strLit", value: "function", type: STRING, loc });
+            if (presence !== null)
+                return presence;
+        }
         // `typeof queueMicrotask` / `typeof DOMException` on a STDLIB global
         // whose declared type is callable or constructable: folds to
         // "function" BEFORE the operand lowers — the identity-token story
@@ -570,7 +593,7 @@ function lowerExprInner(lowerer, expr) {
             operand = operand.value;
         }
         const FOLD = {
-            f64: "number", string: "string", bool: "boolean", func: "function",
+            f64: "number", bigint: "bigint", string: "string", bool: "boolean", func: "function",
             array: "object", object: "object", record: "object",
             symbol: "symbol",
             map: "object", set: "object", promise: "object", bytes: "object",
@@ -578,7 +601,7 @@ function lowerExprInner(lowerer, expr) {
             undefinedT: "undefined", nullT: "object",
         };
         const folded = FOLD[operand.type.kind];
-        if (folded && droppableStatic(operand)) {
+        if (folded && isSafeToDiscard(operand)) {
             return { kind: "strLit", value: folded, type: STRING, loc };
         }
         // A union operand: every arm's typeof answer is static, so the value
@@ -587,7 +610,7 @@ function lowerExprInner(lowerer, expr) {
         // tests, so only side-effect-free reads compose — and when every arm
         // agrees the whole expression folds to that one string (dropping only
         // the pure read, the trust-the-checker bet lowerUnitComparison makes).
-        if (operand.type.kind === "union" && pureReemittable(operand)) {
+        if (operand.type.kind === "union" && isSafeToRepeat(operand)) {
             const def = lowerer.unions.get(operand.type.unionId);
             const answers = def?.arms.map(typeofAnswer);
             if (def && answers && answers.every((s) => s !== null)) {
@@ -614,6 +637,9 @@ function lowerExprInner(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, "typeof expressions on statically-typed values");
     }
     if (ts.isIdentifier(expr)) {
+        const moduleValue = lowerNodeModuleIdentifier(lowerer, expr);
+        if (moduleValue)
+            return moduleValue;
         if (lowerer.isSelfReference(expr)) {
             return { kind: "selfRef", type: lowerer.ctx.selfType, loc };
         }
@@ -944,7 +970,6 @@ function lowerExprInner(lowerer, expr) {
                 // The families with a WHY: each hint states what makes the
                 // surface genuinely non-static (or what to use instead).
                 const globalHints = {
-                    BigInt: "arbitrary-precision integers have no static representation — f64 is the one number type (Number.MAX_SAFE_INTEGER bounds exact integers)",
                     Proxy: "property-access metaprogramming has no static lowering (every property read must resolve at compile time)",
                     Reflect: "reflective property access has no static lowering — read and call members directly",
                     Intl: "locale- and ICU-backed behavior lives outside the static runtime (the localeCompare stance: code-unit order, no collation/locale data) — what lowers: the composed new Intl.NumberFormat(\"en-US\").format(x) and x.toLocaleString(\"en-US\") with default options",
@@ -1276,8 +1301,8 @@ function lowerExprInner(lowerer, expr) {
         // The tail of an optional chain whose `?.` sits deeper
         // (`x?.trim().toLowerCase()`): the whole tail short-circuits with
         // the guard, so it lowers as one chain (dyn/island receivers keep
-        // their own undefined-propagating reads — see chainTailClaimed).
-        if (chainTailClaimed(lowerer, expr))
+        // their own undefined-propagating reads — see isOptionalChainTail).
+        if (isOptionalChainTail(lowerer, expr))
             return lowerer.lowerOptionalChain(expr);
         return lowerer.lowerCall(expr);
     }
@@ -1325,6 +1350,17 @@ function lowerExprInner(lowerer, expr) {
         if (isRequireMainFilename(lowerer, expr)) {
             return { kind: "strLit", value: lowerer.entry.fileName, type: STRING, loc };
         }
+        const requireMain = lowerRequireMainProperty(lowerer, expr);
+        if (requireMain)
+            return requireMain;
+        const moduleProperty = lowerNodeModuleProperty(lowerer, expr);
+        if (moduleProperty)
+            return moduleProperty;
+        if (expr.questionDotToken && expr.name.text === "electron") {
+            const processProperty = lowerer.lowerProcessProperty(expr);
+            if (processProperty)
+                return processProperty;
+        }
         // Optional chaining `a?.b`: the guard lowers here (a tag test around
         // the plain property lowering below); the handled marker keeps this
         // re-entrant dispatch from looping.
@@ -1333,7 +1369,7 @@ function lowerExprInner(lowerer, expr) {
         }
         // `a?.b.c` — the tail of a chain whose token sits deeper: the whole
         // tail short-circuits with the guard.
-        if (!expr.questionDotToken && chainTailClaimed(lowerer, expr)) {
+        if (!expr.questionDotToken && isOptionalChainTail(lowerer, expr)) {
             return lowerer.lowerOptionalChain(expr);
         }
         // Island receiver: o.x is an engine property read (getProp may throw
@@ -1662,7 +1698,7 @@ function lowerExprInner(lowerer, expr) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
-                const opt = chainGuardedByQuestionDot(expr.expression);
+                const opt = hasOptionalChainGuard(expr.expression);
                 return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: recv, type: DYN, loc }, expr);
             }
         }
@@ -1676,7 +1712,7 @@ function lowerExprInner(lowerer, expr) {
         // `f.call` as a value). JS files only; TS keeps the fence.
         if (!["apply", "bind", "call", "toString", "constructor", "prototype", "caller", "arguments"].includes(expr.name.text) &&
             isJsSourceFile(expr.getSourceFile())) {
-            const probed = probeLower(lowerer, expr.expression);
+            const probed = tryLowerExpression(lowerer, expr.expression);
             if (probed?.type.kind === "func" &&
                 canBoxFuncIntoDyn(probed.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
                 const fnName = jsFuncNameOf(expr.expression);
@@ -1741,7 +1777,7 @@ function lowerExprInner(lowerer, expr) {
                     type: STRING,
                     loc: locOf(expr.name),
                 };
-                const opt = chainGuardedByQuestionDot(expr.expression);
+                const opt = hasOptionalChainGuard(expr.expression);
                 return lowerer.maybeNarrow({
                     kind: "dynKeyGet",
                     key,
@@ -1801,7 +1837,7 @@ function lowerExprInner(lowerer, expr) {
         // validated dynCheck as usual.
         if (recvLowered.type.kind === "dyn") {
             const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
-            const opt = chainGuardedByQuestionDot(expr.expression);
+            const opt = hasOptionalChainGuard(expr.expression);
             return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: recvLowered, type: DYN, loc }, expr);
         }
         // The lowered receiver is a RECORD the checker spelled wider —
@@ -1868,9 +1904,6 @@ function importMetaProperty(lowerer, expr) {
         return null;
     const sf = expr.getSourceFile();
     const fileName = moduleFileName(lowerer, sf);
-    if (lowerer.dynamic) {
-        lowerer.unsupported("SC1090", expr, `'import.meta.${expr.name.text}' in a dynamic island (module-loader metadata is supported only in static ESM)`);
-    }
     switch (expr.name.text) {
         case "url":
             return {
@@ -2437,7 +2470,7 @@ export function lowerUnitComparison(lowerer, left, right, negated, loc) {
             // callback's effects are observable) rides one throwaway tag
             // test; droppable reads fold to the bare literal.
             const answer = { kind: "boolLit", value: negated, type: BOOL, loc };
-            if (droppableStatic(other))
+            if (isSafeToDiscard(other))
                 return answer;
             const evalOnce = {
                 kind: "unionIsTag", unionId: other.type.unionId, tag: 0, negated: false, value: other, type: BOOL, loc,
@@ -2545,7 +2578,7 @@ function lowerLooseNullCompare(lowerer, expr, loc) {
         // backend emits it per test — restricted to re-emittable pure reads;
         // anything effectful gets its own actionable fence (the generic
         // SC1040 hint would wrongly suggest `== null` as the fix).
-        if (!pureReemittable(other)) {
+        if (!isSafeToRepeat(other)) {
             lowerer.unsupported("SC1090", expr, `'== null' / '!= null' on a '${lowerer.fmt(ut)}' value that isn't a plain read ` +
                 `(both unit arms need the operand twice — bind it to a const first)`);
         }
@@ -2575,88 +2608,6 @@ function lowerLooseNullCompare(lowerer, expr, loc) {
     // `== null` is statically false, `!= null` statically true.
     return { kind: "boolLit", value: negated, type: BOOL, loc };
 }
-/** Safe to EMIT twice: plain reads with no side effects — local/global
-   * reads and record/class field reads over such (accessor properties
-   * lower to getter CALLS, so they never appear as field reads). Used by
-   * the two-unit-arm `== null` composition, the union `typeof` forms, and
-   * the union-switch desugar, whose operands ride several tests. */
-/** A static expression whose evaluation is unobservable — safe to DROP
- * (typeof's constant fold: JS evaluates the operand, but when nothing in
- * it can throw, call, write, or allocate observably, folding it away
- * changes nothing). Strictly wider than pureReemittable: numeric
- * arithmetic (f64 ops never throw — division by zero is Infinity),
- * string concatenation, logical/ternary composition, and unit/literal
- * leaves compose; anything with a call, an island op, an index read (can
- * trap), or an unknown kind answers false. */
-export function droppableStatic(e) {
-    switch (e.kind) {
-        case "numLit":
-        case "strLit":
-        case "boolLit":
-        case "unitLit":
-            return true;
-        case "bin":
-            return droppableStatic(e.left) && droppableStatic(e.right);
-        case "unary":
-            return droppableStatic(e.operand);
-        case "logical":
-            return droppableStatic(e.left) && droppableStatic(e.right);
-        case "ternary":
-            return droppableStatic(e.cond) && droppableStatic(e.then) && droppableStatic(e.else_);
-        case "strConcat":
-            return droppableStatic(e.left) && droppableStatic(e.right);
-        case "toBool":
-            return droppableStatic(e.operand);
-        case "unionIsTag":
-            return droppableStatic(e.value);
-        case "unionWrap":
-            return droppableStatic(e.value);
-        // Fresh allocations are unobservable too — only their PIECES can
-        // carry effects (a spread re-reads its source: pure; element and
-        // field initializers recurse).
-        case "arrayLit":
-            return e.elems.every(droppableStatic);
-        case "recordLit":
-            return e.fields.every((f) => droppableStatic(f.value));
-        case "recordClone":
-            return droppableStatic(e.source) && e.overrides.every((f) => droppableStatic(f.value));
-        case "closure":
-            return true;
-        default:
-            return pureReemittable(e);
-    }
-}
-export function pureReemittable(e) {
-    if (e.kind === "varRef")
-        return true;
-    if (e.kind === "recordGet" || e.kind === "fieldGet")
-        return pureReemittable(e.obj);
-    // The trust-the-checker narrowing bridges over a pure read: extraction
-    // and downcast are reads too (the +1 on ref payloads is RC bookkeeping,
-    // not an observable effect — each emission owns its own copy).
-    if (e.kind === "unionNarrow" || e.kind === "downcast")
-        return pureReemittable(e.value);
-    return false;
-}
-/** A side-effect-free CONDITION: the ToBoolean/test wrappers lowerCondition
-   * builds over pure reads (evaluating one early or twice changes nothing
-   * observable). Used by the island-literal conditional spread, whose
-   * desugar hoists the condition ahead of the properties. */
-function pureCondExpr(e) {
-    if (e.kind === "boolLit")
-        return true;
-    if (e.kind === "toBool")
-        return pureReemittable(e.operand);
-    if (e.kind === "unionIsTag" || e.kind === "dynTest")
-        return pureReemittable(e.value);
-    if (e.kind === "unary" && e.op === "!")
-        return pureCondExpr(e.operand);
-    if (e.kind === "logical")
-        return pureCondExpr(e.left) && pureCondExpr(e.right);
-    if (e.kind === "jsOp" && (e.op === "truthy" || e.op === "not"))
-        return e.args.every(pureReemittable);
-    return pureReemittable(e);
-}
 /** `a ?? b` — JS-exact nullish coalescing: ONLY null/undefined take the
    * default (0, "", and false do not), and the right side evaluates lazily.
    * On a unit-armed union left this is the `nullish` node (a runtime tag
@@ -2705,6 +2656,42 @@ export function lowerNullishCoalesce(lowerer, expr, loc) {
         const right = lowerer.lowerExprExpecting(expr.right, type);
         return { kind: "nullish", left, right, type, loc };
     }
+    if (type.kind !== "union" && rest.length > 1 && rest.some((arm) => typeEquals(arm, type))) {
+        const helper = lowerer.narrowedArmHelper(left.type.unionId, type, loc);
+        if (helper !== null) {
+            const stmts = [];
+            let stable = left;
+            if (!isSafeToRepeat(left)) {
+                const local = lowerer.declareHiddenLocal("%nullish", left.type);
+                stmts.push({ kind: "varDecl", localId: local.id, init: left, loc });
+                stable = varRef(local.id, left.type, loc);
+            }
+            const unitTags = def.arms
+                .map((arm, tag) => ({ arm, tag }))
+                .filter(({ arm }) => isUnitType(arm))
+                .map(({ tag }) => tag);
+            let isNullish = { kind: "unionIsTag", unionId: left.type.unionId, tag: unitTags[0], negated: false, value: stable, type: BOOL, loc };
+            for (const tag of unitTags.slice(1)) {
+                isNullish = {
+                    kind: "logical",
+                    op: "||",
+                    left: isNullish,
+                    right: { kind: "unionIsTag", unionId: left.type.unionId, tag, negated: false, value: stable, type: BOOL, loc },
+                    type: BOOL,
+                    loc,
+                };
+            }
+            const result = {
+                kind: "ternary",
+                cond: isNullish,
+                then: lowerer.lowerExprExpecting(expr.right, type),
+                else_: { kind: "call", callee: helper, args: [stable], type, loc },
+                type,
+                loc,
+            };
+            return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type, loc };
+        }
+    }
     // The RETAGGED shape — the default changes the result union (`s ??
     // null` over `string | undefined` answers `null | string`): every
     // non-unit arm of the left has a home in the result, so an interned
@@ -2715,9 +2702,72 @@ export function lowerNullishCoalesce(lowerer, expr, loc) {
     if (type.kind === "union") {
         const leftT = left.type;
         const armPairs = rest.map((a) => ({ arm: a, src: lowerer.armTag(leftT.unionId, a), dst: lowerer.armTag(type.unionId, a) }));
+        if (rest.length > 0 && armPairs.every((pair) => pair.src >= 0 && pair.dst >= 0)) {
+            const stmts = [];
+            let stable = left;
+            if (!isSafeToRepeat(left)) {
+                const local = lowerer.declareHiddenLocal("%nullish", leftT);
+                stmts.push({ kind: "varDecl", localId: local.id, init: left, loc });
+                stable = varRef(local.id, leftT, loc);
+            }
+            const unitTags = def.arms
+                .map((arm, tag) => ({ arm, tag }))
+                .filter(({ arm }) => isUnitType(arm))
+                .map(({ tag }) => tag);
+            let isNullish = {
+                kind: "unionIsTag",
+                unionId: leftT.unionId,
+                tag: unitTags[0],
+                negated: false,
+                value: stable,
+                type: BOOL,
+                loc,
+            };
+            for (const tag of unitTags.slice(1)) {
+                isNullish = {
+                    kind: "logical",
+                    op: "||",
+                    left: isNullish,
+                    right: { kind: "unionIsTag", unionId: leftT.unionId, tag, negated: false, value: stable, type: BOOL, loc },
+                    type: BOOL,
+                    loc,
+                };
+            }
+            let present = null;
+            for (let i = armPairs.length - 1; i >= 0; i--) {
+                const pair = armPairs[i];
+                const wrapped = {
+                    kind: "unionWrap",
+                    unionId: type.unionId,
+                    tag: pair.dst,
+                    value: { kind: "unionNarrow", unionId: leftT.unionId, tag: pair.src, value: stable, type: pair.arm, loc },
+                    type,
+                    loc,
+                };
+                present = present === null
+                    ? wrapped
+                    : {
+                        kind: "ternary",
+                        cond: { kind: "unionIsTag", unionId: leftT.unionId, tag: pair.src, negated: false, value: stable, type: BOOL, loc },
+                        then: wrapped,
+                        else_: present,
+                        type,
+                        loc,
+                    };
+            }
+            const result = {
+                kind: "ternary",
+                cond: isNullish,
+                then: lowerer.lowerExprExpecting(expr.right, type),
+                else_: present,
+                type,
+                loc,
+            };
+            return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type, loc };
+        }
         if (armPairs.every((p) => p.src >= 0 && p.dst >= 0)) {
             const right = lowerer.lowerExprExpecting(expr.right, type);
-            if (droppableStatic(right)) {
+            if (isSafeToDiscard(right)) {
                 const helper = nullishRetagHelper(lowerer, leftT, type, loc);
                 return { kind: "call", callee: helper, args: [left, right], type, loc };
             }
@@ -2784,384 +2834,6 @@ function nullishRetagHelper(lowerer, leftT, resT, loc) {
     });
     return name;
 }
-/** One optional-chain STEP: `a?.b`, `a?.m(...)`, `a?.[i]` (the token on
-   * the member access) and `f?.()` (the token on the call). The receiver
-   * lowers once; when it is a unit-armed union with ONE non-unit arm, the
-   * member/call lowers exactly as its non-optional spelling would — the
-   * receiver node reads back as the chain's bound narrowed value
-   * (chainRecv) and types as its non-nullish type — and the whole thing
-   * becomes an optChain node: tag test, undefined on the unit path (JS:
-   * null receivers still yield undefined), the body lazily otherwise,
-   * argument side effects included. A receiver the checker types
-   * never-nullish makes `?.` behave exactly like `.` — the guard folds
-   * away and the plain lowering is the value (trust-the-checker, like
-   * ??'s fold). Multi-step TAILS (`a?.b.c`, `x?.trim().toLowerCase()`)
-   * short-circuit whole: the guarded member step is the chain's dot and
-   * every later step lowers inside the guard, checker-narrowed non-nullish
-   * (see chainTailDot); sub-union receivers are fenced with rewrite
-   * hints. */
-/** The unhandled `?.`-carrying MEMBER step in this node's receiver
- * spine, when the node is the TAIL of an optional chain whose token sits
- * deeper — `x?.trim().toLowerCase()` reads nothing past the guard when x
- * is nullish, so the whole tail must lower inside it. Walks
- * property/element accesses and call steps only (parens and `!` break
- * the chain per the grammar: `(a?.b).c` throws on undefined in JS);
- * the node's OWN token — and a call's immediate callee token — are the
- * plain entries' cases, not tails, and handled markers make the chain
- * lowering's re-dispatch walk past its own step. `f?.()` steps stay out
- * (a call carrying the token has no member step to re-enter — the
- * split-it fence keeps them). */
-function chainTailDot(lowerer, expr) {
-    let cur = expr;
-    for (;;) {
-        // An active chain's bound receiver read is a LEAF — its own token
-        // was consumed by the chain that bound it.
-        if (lowerer.chainRecvByNode.has(cur))
-            return null;
-        if (ts.isCallExpression(cur)) {
-            // `f?.()` steps route through their own entry (or are being
-            // handled); a deeper token under one is that chain's business.
-            if (cur.questionDotToken)
-                return null;
-            cur = cur.expression;
-            continue;
-        }
-        if (ts.isPropertyAccessExpression(cur) || ts.isElementAccessExpression(cur)) {
-            if (cur.questionDotToken) {
-                // The node's own token and a call's immediate callee token are
-                // the plain entries' cases; a handled one is mid-re-dispatch
-                // (its receiver read, further down, ends the walk). The walk
-                // NEVER continues past an unhandled deeper token: that guard is
-                // where this tail's chain enters — anything below it belongs to
-                // the receiver's own (nested) chain.
-                if (cur === expr || lowerer.chainHandled.has(cur)) {
-                    cur = cur.expression;
-                    continue;
-                }
-                if (ts.isCallExpression(expr) && expr.expression === cur)
-                    return null;
-                return cur;
-            }
-            cur = cur.expression;
-            continue;
-        }
-        return null;
-    }
-}
-/** True when `expr` is `require.main.filename` (either dot optional) on
- * the AMBIENT CommonJS require — the entry-module identity read. The
- * value is the ENTRY file's path, a compile-time constant like
- * __filename; ESM files stay out (Node never defines require there —
- * the ambient symbol would not resolve anyway). Shared by the property
- * lowering (the fold) and lowerStringMethodCall's receiver gate (the
- * checker types the chain `string | undefined`, but the folded receiver
- * IS a string). */
-export function isRequireMainFilename(lowerer, expr) {
-    if (!ts.isPropertyAccessExpression(expr) || expr.name.text !== "filename")
-        return false;
-    const main = expr.expression;
-    if (!ts.isPropertyAccessExpression(main) || main.name.text !== "main")
-        return false;
-    if (!lowerer.isStdlibGlobal(main.expression, "require"))
-        return false;
-    return !isNodeEsmFile(expr.getSourceFile());
-}
-/** True when `expr` is the tail of an optional chain the STATIC chain
- * machinery should short-circuit whole: an unhandled deeper `?.` whose
- * guarded receiver lowers as a unit-armed union. Dyn ('unknown') and
- * island ('any') receivers answer their tails through their own
- * undefined-propagating reads and stay out; never-nullish receivers fold
- * at the token's own entry. */
-function chainTailClaimed(lowerer, expr) {
-    const tail = chainTailDot(lowerer, expr);
-    if (!tail)
-        return false;
-    const recvT = lowerer.mapTypeOf(lowerer.typeOf(tail.expression));
-    if (recvT?.kind !== "union")
-        return false;
-    const def = lowerer.unions.get(recvT.unionId);
-    return !!def && def.arms.some(isUnitType);
-}
-/** True when an EARLIER step of this access chain carries `?.` — JS
- * short-circuits the whole tail (`a?.b.c` reads nothing when a is
- * nullish), so a dyn tail read must answer undefined instead of
- * throwing. Walks the receiver spine only; the argument of the access
- * itself is not part of the guard. */
-function chainGuardedByQuestionDot(expr) {
-    let cur = expr;
-    for (;;) {
-        if (ts.isParenthesizedExpression(cur) || ts.isNonNullExpression(cur)) {
-            cur = cur.expression;
-            continue;
-        }
-        if (ts.isPropertyAccessExpression(cur) ||
-            ts.isElementAccessExpression(cur) ||
-            ts.isCallExpression(cur)) {
-            if (cur.questionDotToken)
-                return true;
-            cur = cur.expression;
-            continue;
-        }
-        return false;
-    }
-}
-export function lowerOptionalChain(lowerer, expr) {
-    const loc = locOf(expr);
-    // The node CARRYING the ?. token and the receiver expression it guards.
-    let dotNode;
-    let recvNode;
-    if (ts.isCallExpression(expr) && expr.questionDotToken) {
-        dotNode = expr; // f?.()
-        recvNode = expr.expression;
-    }
-    else if (ts.isCallExpression(expr) &&
-        ts.isPropertyAccessExpression(expr.expression) &&
-        expr.expression.questionDotToken) {
-        dotNode = expr.expression; // a?.m()
-        recvNode = expr.expression.expression;
-    }
-    else if ((ts.isPropertyAccessExpression(expr) || ts.isElementAccessExpression(expr)) &&
-        expr.questionDotToken) {
-        dotNode = expr; // a?.b / a?.[i]
-        recvNode = expr.expression;
-    }
-    else {
-        // TAIL entry: the token sits deeper in the receiver spine and JS
-        // short-circuits the WHOLE tail with it (`x?.trim().toLowerCase()`
-        // reads nothing when x is nullish). The guarded member step becomes
-        // the chain's dot; every step above it lowers inside the guard, its
-        // checker type narrowed non-nullish below (the tag test proved it).
-        const tail = chainTailDot(lowerer, expr);
-        if (!tail) {
-            // A `f?.()` step under a member tail, or no token at all (a
-            // dispatch bug): short-circuiting those is not modeled.
-            lowerer.unsupported("SC1090", expr, "multi-step optional chains (split them: const v = a?.b; then use v?.c)");
-        }
-        dotNode = tail;
-        recvNode = tail.expression;
-    }
-    const loweredReceiver = lowerer.lowerExpr(recvNode);
-    const receiver = lowerer.runtimeOptionalSourceValue(recvNode, loweredReceiver) ?? loweredReceiver;
-    if (receiver.type.kind === "dyn") {
-        // `pkg?.name` / `pkg?.scripts?.[k]` on a JSON.parse result: dyn
-        // represents undefined directly, so the chain step IS the keyed
-        // read with the optional (unit-answers-undefined) policy — no
-        // optChain wrapper needed; nested steps compose the same way.
-        if (dotNode === expr && ts.isPropertyAccessExpression(expr)) {
-            const key = { kind: "strLit", value: expr.name.text, type: STRING, loc: locOf(expr.name) };
-            return lowerer.maybeNarrow({ kind: "dynKeyGet", key, optional: true, value: receiver, type: DYN, loc }, expr);
-        }
-        if (dotNode === expr && ts.isElementAccessExpression(expr)) {
-            const key = lowerer.lowerExpr(expr.argumentExpression);
-            if (key.type.kind === "string") {
-                return lowerer.maybeNarrow({ kind: "dynKeyGet", key, optional: true, value: receiver, type: DYN, loc }, expr);
-            }
-            // NUMBER-typed indices (`entries?.[0]`): the property key is
-            // ToString(i), exactly JS — the canonical number text answers
-            // array indices in the dyn helper, anything else (fractions,
-            // negatives, NaN) reads as an absent key.
-            if (key.type.kind === "f64") {
-                const skey = { kind: "toString", operand: key, type: STRING, loc: key.loc };
-                return lowerer.maybeNarrow({ kind: "dynKeyGet", key: skey, optional: true, value: receiver, type: DYN, loc }, expr);
-            }
-        }
-        // The METHOD-call step (`rawName?.match(re)` on a dyn value): a
-        // nullish receiver short-circuits to the undefined dyn singleton
-        // (dyn represents undefined directly); anything else runs the
-        // VALIDATED dynamic dispatch — the same one the truthy-guarded
-        // spelling (`v ? v.match(...) : null`) compiles to, Node-shaped
-        // TypeError on a kind mismatch included. The dispatch's static
-        // result converts back into the checked-dynamic tree (the chain's checker type is
-        // the error-any world's `any`, so dyn IS its representation).
-        if (ts.isCallExpression(expr) &&
-            ts.isPropertyAccessExpression(dotNode) &&
-            dotNode === expr.expression) {
-            const m = dotNode.name.text;
-            const id = `chain.${lowerer.chainCounter++}`;
-            const recvRef = { kind: "chainRecv", id, type: DYN, loc: locOf(recvNode) };
-            lowerer.chainRecvByNode.set(recvNode, recvRef);
-            lowerer.chainHandled.add(dotNode);
-            let body;
-            try {
-                body = lowerer.lowerExpr(expr);
-            }
-            finally {
-                lowerer.chainRecvByNode.delete(recvNode);
-                lowerer.chainHandled.delete(dotNode);
-            }
-            if (body.type.kind !== "dyn") {
-                if (body.type.kind !== "void" && !lowerer.dynConvertible(body.type)) {
-                    lowerer.unsupported("SC1100", expr, `optional METHOD calls on 'unknown' values where the result ('${lowerer.fmt(body.type)}' ` +
-                        `from '.${m}(...)') has no dynamic representation`);
-                }
-                if (body.type.kind === "void") {
-                    return { kind: "optChain", id, receiver, body, type: VOID, loc };
-                }
-                body = { kind: "dynFrom", value: body, type: DYN, loc };
-            }
-            return { kind: "optChain", id, receiver, body, type: DYN, loc };
-        }
-        lowerer.unsupported("SC1100", expr, "optional chaining on 'unknown' values");
-    }
-    // An 'any' (island-handle) receiver: the nullish test asks the ENGINE
-    // value at runtime — null/undefined short-circuit to the engine's
-    // undefined (JS: null receivers yield undefined too), anything else
-    // proceeds as the plain island operation with the receiver evaluated
-    // once (argument side effects stay lazy, like every optChain). The
-    // result is an island value again ('any' in, 'any' out).
-    if (receiver.type.kind === "jsval") {
-        const id = `chain.${lowerer.chainCounter++}`;
-        const recvRef = { kind: "chainRecv", id, type: JSVAL, loc: locOf(recvNode) };
-        if (dotNode === expr && ts.isCallExpression(expr)) {
-            // `a.b?.(...)` — a MEMBER callee: JS calls it with `this` bound to
-            // `a` and short-circuits a nullish member — exactly the engine's
-            // own `o.name?.()` (optCallMethod: the RECEIVER is `a`, evaluated
-            // once through the chain; a nullish `a` itself short-circuits
-            // earlier like any optional chain). Computed members keep a fence.
-            if (ts.isPropertyAccessExpression(recvNode) || ts.isElementAccessExpression(recvNode)) {
-                if (ts.isPropertyAccessExpression(recvNode) &&
-                    !recvNode.questionDotToken) {
-                    const obj = lowerer.lowerExpr(recvNode.expression);
-                    if (obj.type.kind !== "jsval")
-                        lowerer.badType(recvNode.expression, lowerer.typeOf(recvNode.expression));
-                    const args = expr.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-                    return { kind: "jsOp", op: "optCallMethod", name: recvNode.name.text, args: [obj, ...args], type: JSVAL, loc };
-                }
-                lowerer.unsupported("SC1090", expr, "optional calls of computed 'any' member values (a[k]?.() — bind the member to a const first)");
-            }
-            const args = expr.arguments.map((a) => lowerer.jsvalIn(lowerer.lowerExpr(a), a));
-            const body = { kind: "jsOp", op: "callFn", args: [recvRef, ...args], type: JSVAL, loc };
-            return { kind: "optChain", id, receiver, body, type: JSVAL, loc };
-        }
-        // Member forms (`x?.y`, `x?.y(...)`, `x?.[i]`): re-dispatch the plain
-        // island lowering with the receiver node bound to the chain.
-        lowerer.chainRecvByNode.set(recvNode, recvRef);
-        lowerer.chainHandled.add(dotNode);
-        let body;
-        try {
-            body = lowerer.lowerExpr(expr);
-        }
-        finally {
-            lowerer.chainRecvByNode.delete(recvNode);
-            lowerer.chainHandled.delete(dotNode);
-        }
-        if (body.type.kind !== "jsval")
-            lowerer.badType(expr, lowerer.typeOf(expr));
-        return { kind: "optChain", id, receiver, body, type: JSVAL, loc };
-    }
-    const def = receiver.type.kind === "union" ? lowerer.unions.get(receiver.type.unionId) : undefined;
-    if (!def || !def.arms.some(isUnitType)) {
-        // Never nullish: `?.` IS `.` — re-dispatch the plain lowering. The
-        // receiver subtree above is discarded (lowering is pure IR
-        // construction); the fresh dispatch lowers it again in place. The
-        // checker may still SPELL the receiver nullable while the lowering
-        // answers the plain value (`process.getuid?.()` is the POSIX
-        // number), so narrow the node too — downstream receiver-typed
-        // dispatch must agree with the lowered value, not the spelling.
-        lowerer.chainHandled.add(dotNode);
-        const hadNarrow = lowerer.chainNarrowedType.has(recvNode);
-        if (!hadNarrow) {
-            lowerer.chainNarrowedType.set(recvNode, lowerer.checker.getNonNullableType(lowerer.checker.getTypeAtLocation(recvNode)));
-        }
-        try {
-            return lowerer.lowerExpr(expr);
-        }
-        finally {
-            lowerer.chainHandled.delete(dotNode);
-            if (!hadNarrow)
-                lowerer.chainNarrowedType.delete(recvNode);
-        }
-    }
-    const rest = def.arms.filter((a) => !isUnitType(a));
-    if (rest.length !== 1) {
-        lowerer.unsupported("SC1090", expr, `'?.' on '${lowerer.fmt(receiver.type)}' (the guarded receiver is a sub-union; check a discriminant field first)`);
-    }
-    const narrowed = rest[0];
-    const id = `chain.${lowerer.chainCounter++}`;
-    const recvRef = { kind: "chainRecv", id, type: narrowed, loc: locOf(recvNode) };
-    // `f?.()`: the callee IS the guarded value — build the indirect call
-    // directly (no member dispatch exists to re-enter).
-    if (dotNode === expr && ts.isCallExpression(expr)) {
-        if (narrowed.kind !== "func")
-            lowerer.badType(recvNode, lowerer.typeOf(recvNode));
-        const params = narrowed.params;
-        const args = expr.arguments.map((a, i) => lowerer.lowerExprExpecting(a, params[i]));
-        const body = { kind: "callValue", callee: recvRef, args, type: narrowed.ret, loc };
-        return lowerer.finishOptionalChain(expr, id, receiver, body, loc);
-    }
-    // Member forms: re-dispatch the normal lowering with the receiver node
-    // bound to the chain (reads as chainRecv, types as non-nullish).
-    const narrowedTs = lowerer.checker.getNonNullableType(lowerer.checker.getTypeAtLocation(recvNode));
-    lowerer.chainRecvByNode.set(recvNode, recvRef);
-    lowerer.chainNarrowedType.set(recvNode, narrowedTs);
-    lowerer.chainHandled.add(dotNode);
-    // A TAIL entry's intermediate steps (`x?.trim()` inside
-    // `x?.trim().toLowerCase()`) checker-type with the chain's `|
-    // undefined` even though inside the guard they are proven non-nullish
-    // — narrow each so the downstream method/member dispatch rides the
-    // real receiver kind. Only nodes this chain registers are cleaned up.
-    const tailSteps = [];
-    if (dotNode !== expr && !(ts.isCallExpression(expr) && expr.expression === dotNode)) {
-        for (let cur = expr; cur !== dotNode;) {
-            const next = ts.isCallExpression(cur)
-                ? cur.expression
-                : cur.expression;
-            if (next === dotNode)
-                break;
-            if (!lowerer.chainNarrowedType.has(next)) {
-                lowerer.chainNarrowedType.set(next, lowerer.checker.getNonNullableType(lowerer.checker.getTypeAtLocation(next)));
-                tailSteps.push(next);
-            }
-            cur = next;
-        }
-        if (!lowerer.chainNarrowedType.has(dotNode)) {
-            lowerer.chainNarrowedType.set(dotNode, lowerer.checker.getNonNullableType(lowerer.checker.getTypeAtLocation(dotNode)));
-            tailSteps.push(dotNode);
-        }
-    }
-    let body;
-    try {
-        body = lowerer.lowerExpr(expr);
-    }
-    finally {
-        lowerer.chainRecvByNode.delete(recvNode);
-        lowerer.chainNarrowedType.delete(recvNode);
-        lowerer.chainHandled.delete(dotNode);
-        for (const n of tailSteps)
-            lowerer.chainNarrowedType.delete(n);
-    }
-    return lowerer.finishOptionalChain(expr, id, receiver, body, loc);
-}
-/** The optChain node around a lowered chain body: void bodies keep the
-   * statement form (`cb?.();` — the checker's `void | undefined` result IS
-   * void here); value bodies wrap into the checker's undefined-armed
-   * result union. */
-export function finishOptionalChain(lowerer, expr, id, receiver, body, loc) {
-    if (body.type.kind === "void") {
-        return { kind: "optChain", id, receiver, body, type: VOID, loc };
-    }
-    // A dyn body (`pricing?.[key]` — an unknown-valued index-signature
-    // read) stays dyn: `unknown | undefined` IS unknown, and dyn represents
-    // undefined directly (the unit path yields the undefined dyn value).
-    if (body.type.kind === "dyn") {
-        return { kind: "optChain", id, receiver, body, type: DYN, loc };
-    }
-    let type = lowerer.irTypeOf(expr);
-    const hiddenOptionalResult = (type.kind !== "union" || lowerer.armTag(type.unionId, UNDEFINED_T) < 0) &&
-        receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0 &&
-        body.type.kind !== "generator" && body.type.kind !== "jsval"
-        ? lowerer.withUndefinedArmOf(body.type)
-        : null;
-    if (hiddenOptionalResult)
-        type = hiddenOptionalResult;
-    if (type.kind !== "union" || lowerer.armTag(type.unionId, UNDEFINED_T) < 0) {
-        lowerer.unsupported("SC1090", expr, `'?.' where the result '${lowerer.fmt(type)}' has no undefined arm (narrow the receiver with 'if (x !== undefined)' instead)`);
-    }
-    const wrapped = lowerer.coerceToExpected(body, type);
-    if (!typeEquals(wrapped.type, type))
-        lowerer.badType(expr, lowerer.typeOf(expr));
-    return { kind: "optChain", id, receiver, body: wrapped, type, loc };
-}
 /** A CONDITION-position expression: the result is consumed as a bool
    * only, so `&&`/`||` descend recursively over ToBoolean'd operands —
    * JS-exact (`ToBoolean(a && b)` ≡ `ToBoolean(a) && ToBoolean(b)`), still
@@ -3171,6 +2843,11 @@ export function lowerCondition(lowerer, expr) {
     let e = expr;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
+    if (ts.isPropertyAccessExpression(e)) {
+        const presence = lowerPromiseThenPresence(lowerer, e, { kind: "boolLit", value: true, type: BOOL, loc: locOf(e) });
+        if (presence !== null)
+            return presence;
+    }
     if (ts.isBinaryExpression(e)) {
         const op = e.operatorToken.kind;
         if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
@@ -3204,6 +2881,47 @@ export function lowerCondition(lowerer, expr) {
     }
     return lowerer.ensureBool(lowerAbsenceProbe(lowerer, expr) ?? lowerer.lowerExpr(expr), expr);
 }
+function lowerPromiseThenPresence(lowerer, access, result) {
+    if (access.name.text !== "then")
+        return null;
+    const mapped = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const promiseType = mapped?.kind === "promise"
+        ? mapped
+        : mapped?.kind === "union"
+            ? (() => {
+                const arms = lowerer.unions.get(mapped.unionId)?.arms ?? [];
+                const promises = arms.filter((arm) => arm.kind === "promise");
+                return promises.length === 1 && arms.every((arm) => arm.kind === "promise" || isUnitType(arm))
+                    ? promises[0]
+                    : null;
+            })()
+            : null;
+    if (promiseType === null)
+        return null;
+    let receiver = lowerer.lowerExpr(access.expression);
+    if (receiver.type.kind === "union") {
+        const optional = lowerer.runtimeOptionalPropertyReceiver(access.expression, receiver, promiseType, access.name.text);
+        if (optional !== null)
+            receiver = optional;
+        else {
+            const helper = lowerer.narrowedArmHelper(receiver.type.unionId, promiseType, receiver.loc);
+            if (helper === null)
+                return null;
+            receiver = { kind: "call", callee: helper, args: [receiver], type: promiseType, loc: receiver.loc };
+        }
+    }
+    if (receiver.type.kind !== "promise")
+        return null;
+    if (isSafeToDiscard(receiver))
+        return result;
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: receiver, loc: receiver.loc }],
+        result,
+        type: result.type,
+        loc: result.loc,
+    };
+}
 function runtimeOptionalLocalOf(lowerer, node) {
     let expr = node;
     while (ts.isParenthesizedExpression(expr))
@@ -3248,6 +2966,9 @@ export function ensureBool(lowerer, e, node) {
     if (e.type.kind === "f64" || e.type.kind === "string") {
         return { kind: "toBool", operand: e, type: BOOL, loc: e.loc };
     }
+    if (e.type.kind === "bigint") {
+        return { kind: "libCall", fn: "bigint.truthy", args: [e], type: BOOL, loc: e.loc };
+    }
     if (e.type.kind === "dyn") {
         // ToBoolean over the checked-dynamic tree (`if (pkg)` on a JSON.parse result): every
         // dyn kind has a JS-exact answer — the truthy dynTest reads the kind
@@ -3729,6 +3450,27 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
             }
         }
     }
+    // An array literal inside an npm-static implicit-any instance can
+    // inherit the checker's poisoned any[] context even after the
+    // active binding gives every element one concrete lowering. Recover a
+    // static array only when every spelled element lowers to the same
+    // supported type. An explicit checked-dynamic destination still owns
+    // the later slot coercion; heterogeneous literals, holes, and spreads
+    // keep the checked-dynamic fallback below.
+    if (lowerer.implicitParamTypes !== null &&
+        npmStaticPackageOfPath(expr.getSourceFile().fileName) !== null &&
+        (mapped === null || mapped.kind === "dyn" ||
+            (mapped.kind === "array" && mapped.elem.kind === "dyn")) &&
+        expr.elements.length > 0 &&
+        expr.elements.every((element) => !ts.isSpreadElement(element) && !ts.isOmittedExpression(element))) {
+        const elements = expr.elements.map((element) => tryLowerExpression(lowerer, element));
+        const first = elements[0];
+        if (first !== undefined && first !== null &&
+            isSupportedArrayElem(first.type) &&
+            elements.every((element) => element !== null && typeEquals(element.type, first.type))) {
+            mapped = arrayOf(first.type);
+        }
+    }
     // An EMPTY literal under a CONST ASSERTION whose type queries panicked
     // (tsgo's readonly-[] TupleType conversion — the facade answers `any`,
     // which maps to nothing statically and to an island value under
@@ -3810,7 +3552,7 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         }
         lowerer.badType(expr, tsType);
     }
-    let type = mapped;
+    const type = mapped;
     // Keep the array payload type fixed. Optional reads are stored through
     // arrayValueStore, which records UNDEFINED in the state byte while the
     // payload remains number/string/etc.; widening the array element here
@@ -3823,7 +3565,7 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         const candidate = expr.elements[i];
         if (ts.isSpreadElement(candidate) || ts.isOmittedExpression(candidate))
             continue;
-        const probe = probeLower(lowerer, candidate);
+        const probe = tryLowerExpression(lowerer, candidate);
         if (probe && lowerer.runtimeOptionalWidening(probe.type, type.elem) !== null) {
             runtimeOptionalElements.add(i);
             needsStateBuild = true;
@@ -4019,315 +3761,6 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         loc,
     };
 }
-/** `{ a: 1, b: "x" }` → recordLit. The record type comes from the
-   * contextual type when tsc has one (annotated declarations, arguments,
-   * nested literals) and from the literal's own type otherwise — both intern
-   * to the same shapeId unless width subtyping is in play (an `as` cast can
-   * smuggle a wider/narrower literal past tsc's freshness check), which the
-   * exact-shape checks below reject with SC2002. Fields lower IN SOURCE
-   * ORDER: JS evaluates property values in source order. */
-/** The dropped-field names of the PromiseSettledResult honest subset
- * (SEMANTICS.md 46): when the literal's target type is (a union
- * containing) the lib's PromiseFulfilledResult / PromiseRejectedResult,
- * the record mapping kept only `status` — `value` and `reason` evaluate
- * for effect and are not stored. Null for every other target. */
-function settledDropNames(lowerer, tsType) {
-    let names = null;
-    const parts = tsType.isUnionType() ? ts.constituentTypes(tsType) : [tsType];
-    for (const part of parts) {
-        const sym = part.getSymbol();
-        if (!sym ||
-            !lowerer.checker.declarationsOf(sym).some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
-            continue;
-        }
-        if (sym.name === "PromiseFulfilledResult")
-            (names ??= new Set()).add("value");
-        if (sym.name === "PromiseRejectedResult")
-            (names ??= new Set()).add("reason");
-    }
-    return names;
-}
-/** `{ [KEY]: v }` where KEY is a compile-time-known string or number:
- * the key folds into an ordinary (spelled) property name — the record
- * shape is exactly what tsc computed for the literal (the late-bound
- * name IS the checker's literal type), so the fold is just spelling.
- * PURE key forms only, so skipping the key's evaluation is exact (JS
- * evaluates the key before the value; effectful expressions keep the
- * fence): any side-effect-free expression — identifiers, property
- * chains with no accessor on them (enum members, `other.name` reads),
- * literals, parenthesized/as-wrapped forms, operators over those —
- * whose checker type is ONE string or number literal (or a union whose
- * arms all spell the same name — `E1.x || E2.x` where both are 0).
- * Number keys take JS's canonical spelling (`{ [E.member]: v }` stores
- * "0" — ToPropertyKey), exactly the name tsc late-bound. Templates
- * fold structurally span by span as well (a template of literals whose
- * checker type widened still spells one string). Symbol-typed and
- * runtime-valued keys stay out. */
-function literalComputedKey(lowerer, name) {
-    return foldedStringKeyOf(lowerer, name.expression);
-}
-export function foldedStringKeyOf(lowerer, expr) {
-    if (ts.isParenthesizedExpression(expr))
-        return foldedStringKeyOf(lowerer, expr.expression);
-    if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr))
-        return expr.text;
-    if (ts.isTemplateExpression(expr)) {
-        // Structural fold first — exact even where the checker widened the
-        // template's own type; the general type-directed fold below is the
-        // fallback (a template the checker DID type as one literal).
-        let out = expr.head.text;
-        let folded = true;
-        for (const span of expr.templateSpans) {
-            const part = foldedStringKeyOf(lowerer, span.expression);
-            if (part === null) {
-                folded = false;
-                break;
-            }
-            out += part + span.literal.text;
-        }
-        if (folded)
-            return out;
-    }
-    // The general fold: a PURE expression whose checker type spells one
-    // property name. An as-cast folds by its OWN checker type — that is
-    // the name tsc late-bound the property under, so shape and storage
-    // stay one name (the standard trust-the-checker bet); a cast that
-    // WIDENS to string un-late-binds the property, its type is no literal,
-    // and the fence stays.
-    if (!pureKeyExpr(lowerer, expr))
-        return null;
-    return literalKeySpellingOf(lowerer.typeOf(expr));
-}
-/** The property-name spelling of a single-literal checker type: string
- * literals directly, number literals in JS's canonical ToString spelling
- * (enum members included — their literal flags carry the value), and
- * unions whose arms all spell the SAME name (`E1.x || E2.x` — two enum
- * literal types, one value). Null for everything else. */
-function literalKeySpellingOf(t) {
-    if (t.isStringLiteralType())
-        return t.value;
-    if (t.isNumberLiteralType())
-        return String(t.value);
-    if (t.isUnionType()) {
-        let out = null;
-        for (const arm of ts.constituentTypes(t)) {
-            const s = arm.isStringLiteralType() ? arm.value : arm.isNumberLiteralType() ? String(arm.value) : null;
-            if (s === null || (out !== null && s !== out))
-                return null;
-            out = s;
-        }
-        return out;
-    }
-    return null;
-}
-/** True iff evaluating `expr` can have no observable effect, so a fold
- * may skip it: literals, identifier reads, property chains whose every
- * member is a plain field/enum member (an accessor anywhere on the chain
- * is a call), operators and casts over those. Calls, `new`, assignments,
- * and element accesses stay impure. */
-function pureKeyExpr(lowerer, expr) {
-    if (ts.isParenthesizedExpression(expr) || ts.isNonNullExpression(expr))
-        return pureKeyExpr(lowerer, expr.expression);
-    if (ts.isAsExpression(expr) || ts.isTypeAssertion(expr))
-        return pureKeyExpr(lowerer, expr.expression);
-    if (ts.isIdentifier(expr))
-        return true;
-    if (ts.isStringLiteralLike(expr) || ts.isNumericLiteral(expr))
-        return true;
-    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword ||
-        expr.kind === ts.SyntaxKind.NullKeyword)
-        return true;
-    if (ts.isPropertyAccessExpression(expr)) {
-        const sym = lowerer.checker.getSymbolAtLocation(expr.name);
-        if (sym && sym.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor))
-            return false;
-        return pureKeyExpr(lowerer, expr.expression);
-    }
-    if (ts.isPrefixUnaryExpression(expr) &&
-        (expr.operator === ts.SyntaxKind.MinusToken || expr.operator === ts.SyntaxKind.PlusToken ||
-            expr.operator === ts.SyntaxKind.ExclamationToken || expr.operator === ts.SyntaxKind.TildeToken)) {
-        return pureKeyExpr(lowerer, expr.operand);
-    }
-    if (ts.isBinaryExpression(expr)) {
-        const op = expr.operatorToken.kind;
-        const pureOp = op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken ||
-            op === ts.SyntaxKind.QuestionQuestionToken ||
-            (op >= ts.SyntaxKind.LessThanToken && op <= ts.SyntaxKind.CaretToken &&
-                op !== ts.SyntaxKind.InstanceOfKeyword && op !== ts.SyntaxKind.InKeyword);
-        return pureOp && pureKeyExpr(lowerer, expr.left) && pureKeyExpr(lowerer, expr.right);
-    }
-    if (ts.isConditionalExpression(expr)) {
-        return pureKeyExpr(lowerer, expr.condition) && pureKeyExpr(lowerer, expr.whenTrue) && pureKeyExpr(lowerer, expr.whenFalse);
-    }
-    if (ts.isTemplateExpression(expr))
-        return expr.templateSpans.every((s) => pureKeyExpr(lowerer, s.expression));
-    return false;
-}
-/** A property's field name: identifier/string-literal keys directly,
- * foldable computed keys through literalComputedKey (the syntax pass
- * fenced everything else). */
-function propNameText(lowerer, name) {
-    if (ts.isComputedPropertyName(name)) {
-        const k = literalComputedKey(lowerer, name);
-        if (k === null)
-            throw new InternalCompilerError("lowerer bug: unfoldable computed key past the fence");
-        return k;
-    }
-    // Numeric literals name their canonical string key (JS's ToPropertyKey
-    // — the same name the checker gives the property symbol).
-    if (ts.isNumericLiteral(name))
-        return String(Number(name.text));
-    return name.text;
-}
-/** The runtime-keyed JS object literal (a computed key that doesn't fold):
-   * builds a dyn object member-by-member. Keys evaluate before their values,
-   * properties in source order — JS's object-literal evaluation exactly.
-   * Identifier/string keys are compile-time strings; numeric keys take
-   * their canonical number string (`{ 0x10: v }` stores "16" — JS's
-   * ToPropertyKey); computed keys evaluate and pass through ToString (the
-   * dyn's String() for dyn operands — `{ [field]: v }` where field is a
-   * checked-dynamic param). Values convert through the usual dyn boundary
-   * (dynFrom's domain, functions box); a value with no dyn representation
-   * fences per property. Spreads copy through dyn.assign in source order;
-   * accessors stay fenced. */
-export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
-    const loc = locOf(expr);
-    let fields = [];
-    let acc = null;
-    const flushFields = () => {
-        if (fields.length === 0)
-            return;
-        const chunk = { kind: "dynObjLit", fields, type: DYN, loc };
-        acc = acc === null
-            ? chunk
-            : { kind: "libCall", fn: "dyn.assign", args: [acc, chunk], type: DYN, loc };
-        fields = [];
-    };
-    for (const prop of expr.properties) {
-        if (ts.isSpreadAssignment(prop)) {
-            flushFields();
-            const raw = lowerer.lowerExpr(prop.expression);
-            const source = boxValue
-                ? boxValue(prop.expression, raw)
-                : lowerer.coerceToExpected(raw, DYN);
-            if (source.type.kind !== "dyn") {
-                lowerer.unsupported("SC1101", prop.expression, `spreading '${lowerer.fmt(source.type)}' into a checked-dynamic object literal`);
-            }
-            acc ??= { kind: "dynObjLit", fields: [], type: DYN, loc };
-            acc = { kind: "libCall", fn: "dyn.assign", args: [acc, source], type: DYN, loc: locOf(prop) };
-            continue;
-        }
-        if (!ts.isPropertyAssignment(prop) &&
-            !ts.isShorthandPropertyAssignment(prop) &&
-            !ts.isMethodDeclaration(prop)) {
-            lowerer.unsupported("SC1090", prop, "accessors in a runtime-keyed (computed-key) object literal");
-        }
-        const name = prop.name;
-        let key;
-        if (ts.isComputedPropertyName(name)) {
-            const folded = literalComputedKey(lowerer, name);
-            if (folded !== null) {
-                key = { kind: "strLit", value: folded, type: STRING, loc: locOf(name) };
-            }
-            else {
-                let k = lowerer.lowerExpr(name.expression);
-                if (k.type.kind === "f64" || k.type.kind === "bool" || k.type.kind === "dyn") {
-                    k = { kind: "toString", operand: k, type: STRING, loc: locOf(name) };
-                }
-                if (k.type.kind !== "string") {
-                    lowerer.unsupported("SC1090", name, `'${lowerer.fmt(k.type)}'-typed computed property keys (string, number, boolean, and unknown keys stringify)`);
-                }
-                key = k;
-            }
-        }
-        else if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
-            key = { kind: "strLit", value: name.text, type: STRING, loc: locOf(name) };
-        }
-        else if (ts.isNumericLiteral(name)) {
-            key = { kind: "strLit", value: String(Number(name.text)), type: STRING, loc: locOf(name) };
-        }
-        else {
-            lowerer.unsupported("SC1090", prop, "non-identifier property names");
-        }
-        const valueExpr = ts.isMethodDeclaration(prop)
-            ? prop
-            : ts.isShorthandPropertyAssignment(prop)
-                ? prop.name
-                : prop.initializer;
-        // Lambda values that fail to lower become trap closures (the
-        // per-call fence granularity — fenceClosureProbe) so the object
-        // still builds; everything else keeps the per-property fence below.
-        let raw;
-        const propDiagsBefore = lowerer.diags.length;
-        try {
-            const lowerValue = () => ts.isMethodDeclaration(prop)
-                ? (lowerer.rejectThisInObjectMethod(prop.body ?? prop), lowerer.lowerLambda(prop))
-                : lowerer.lowerExpr(valueExpr);
-            raw =
-                fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ??
-                    lowerValue();
-        }
-        catch (err) {
-            // A PURE member read a JS file cannot lower (a namespace object
-            // in an export aggregate): the slot takes a boxed fence closure —
-            // the diagnostics defer to the runtime-fence ledger, the object
-            // builds, and only USING the member stops the run.
-            const pureMember = ts.isIdentifier(valueExpr);
-            if (!(err instanceof PoisonError) || !pureMember)
-                throw err;
-            const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, {
-                kind: "closure",
-                name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
-                returnType: VOID,
-                type: { kind: "func", params: [], ret: VOID },
-            });
-            if (!fence)
-                throw err;
-            raw = fence;
-        }
-        let v = boxValue
-            ? boxValue(valueExpr, raw)
-            : lowerer.coerceToExpected(raw, DYN);
-        if (v.type.kind !== "dyn") {
-            const convDiagsBefore = lowerer.diags.length;
-            try {
-                lowerer.unsupported("SC1101", valueExpr, `holding '${lowerer.fmt(v.type)}' values in a runtime-keyed (computed-key) object literal`);
-            }
-            catch (err) {
-                // A member value the checked-dynamic tree cannot hold — a func whose signature
-                // cannot box, an island ('any') handle, a record carrying func
-                // fields (the export aggregate's typed utilities and npm-handle
-                // members): the same call-time fence deferral as an unlowerable
-                // member — the slot takes a boxed fence closure; only USING it
-                // stops the run. Probe mode and ICEs keep the poison.
-                if (!(err instanceof PoisonError))
-                    throw err;
-                const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, {
-                    kind: "closure",
-                    name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
-                    returnType: VOID,
-                    type: { kind: "func", params: [], ret: VOID },
-                });
-                if (!fence)
-                    throw err;
-                v = lowerer.coerceToExpected(fence, DYN);
-            }
-        }
-        fields.push({ key, value: v });
-    }
-    flushFields();
-    return acc ?? { kind: "dynObjLit", fields: [], type: DYN, loc };
-}
-/** Spreading a source whose shape carries accessor slots: Node's copy
- * invokes each getter exactly once in insertion order — even for keys a
- * later contributor overrides — while the field-copy desugar assumes pure
- * reads it may drop or reorder. Getter-call counts would silently diverge,
- * so accessor-carrying sources fence by name. */
-function fenceAccessorSpreadSource(lowerer, prop, srcShape) {
-    if (srcShape && shapeHasAccessorSlots(srcShape)) {
-        lowerer.unsupported("SC1090", prop, "object spread of sources carrying get/set accessor properties (Node invokes each getter once during the copy — the field-copy desugar cannot model the calls; bind the reads to consts first)");
-    }
-}
 /** Convert an undefined-armed numeric value at an arithmetic use. Ordinary
  * reads preserve their tagged value; JavaScript's ToNumber(undefined) is NaN,
  * so compounds and binary arithmetic use this checked one-time extraction. */
@@ -4347,7 +3780,7 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
         return operand;
     let stable = operand;
     let prefix = [];
-    if (!pureReemittable(operand)) {
+    if (!isSafeToRepeat(operand)) {
         const tmp = lowerer.declareHiddenLocal("%arith", operand.type);
         stable = varRef(tmp.id, operand.type, loc);
         prefix = [{ kind: "varDecl", localId: tmp.id, init: operand, loc }];
@@ -4364,1499 +3797,6 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
     };
     return prefix.length === 0 ? value : { kind: "seqExpr", stmts: prefix, result: value, type: F64, loc };
 }
-/** The JS trap-closure fallback for FUNCTION-VALUED object properties: a
- * lambda whose body fails to lower inside a JS object literal becomes a
- * closure of the field's exact func type whose body is the runtime fence —
- * the object still BUILDS (commander's `_outputConfiguration` table: the
- * driven writeOut/writeErr entries work; an unloweraable color probe traps
- * only if something CALLS it). The failed lambda's diagnostics move to the
- * runtime-fence inventory, exactly like a fenced JS statement. Null when
- * the fallback does not apply (not a JS file, not a lambda, no func slot)
- * — the caller lowers normally. ICEs (SC9001) never convert. */
-function fenceClosureProbe(lowerer, node, slotType, attempt) {
-    if (!isJsSourceFile(node.getSourceFile()))
-        return null;
-    let inner = node;
-    while (ts.isParenthesizedExpression(inner))
-        inner = inner.expression;
-    if (!ts.isArrowFunction(inner) && !ts.isFunctionExpression(inner) && !ts.isMethodDeclaration(inner)) {
-        return null;
-    }
-    // The trap's ABI: the field's func slot when one exists; otherwise (the
-    // dyn-object literal path — the value boxes into dyn) the all-dyn
-    // signature of the lambda's own arity, which canBoxFuncIntoDyn always
-    // admits.
-    const fieldType = slotType !== undefined && slotType.kind === "func"
-        ? slotType
-        : { kind: "func", params: inner.parameters.map(() => DYN), ret: DYN };
-    if (slotType !== undefined && slotType.kind !== "func")
-        return null;
-    const diagsBefore = lowerer.diags.length;
-    try {
-        return attempt();
-    }
-    catch (e) {
-        if (!(e instanceof PoisonError))
-            throw e;
-        const params = fieldType.params.map((t, i) => ({ localId: `p.${i}`, name: `p${i}`, type: t }));
-        const fence = lowerer.deferToRuntimeFence(diagsBefore, node, {
-            kind: "closure",
-            name: () => `%fence.fn.${lowerer.liftedFns.length}`,
-            params,
-            returnType: fieldType.ret,
-            paramsMutable: true,
-            type: fieldType,
-            fallback: { code: "SC1090", message: "this function's body has no static lowering" },
-            bareMessage: true,
-            allowDiagSink: true,
-        });
-        if (!fence)
-            throw e;
-        return fence;
-    }
-}
-/** The union arm an object LITERAL inhabits when its fields must widen
- * PER FIELD into exactly one record arm — the reducer-action pattern
- * (`{ kind: "a", parsed: 1 }` into `{ kind: "a"; parsed: number | null }
- * | { kind: "b" }`). The IR shapes erased the literal types tsc
- * discriminated on, so the probe runs against the contextual union's
- * CHECKER members: every literal field must exist on the member
- * (excess-property freshness — tsc already enforced it), every arm field
- * missing from the literal must be optional-flavored (an undefined-armed
- * union, or a dyn slot — the absent-completion rule), and each present
- * field's LITERAL type must fit the member's field type — literal against
- * literal decides by VALUE (the discriminant), everything else by the
- * widened IR pair under the width-lift relation. Exactly ONE fitting arm
- * answers it; zero or several answer null and the caller keeps its
- * fences. Plain property-assignment/shorthand literals only — spreads,
- * accessors, methods, and unfoldable computed keys keep their own paths. */
-function literalUnionArmOf(lowerer, expr, tsType, recordArms) {
-    if (!tsType.isUnionType())
-        return null;
-    const props = [];
-    for (const p of expr.properties) {
-        if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
-            props.push({ name: propNameText(lowerer, p.name), node: p.initializer });
-        }
-        else if (ts.isShorthandPropertyAssignment(p) && ts.isIdentifier(p.name)) {
-            props.push({ name: p.name.text, node: p.name });
-        }
-        else {
-            return null;
-        }
-    }
-    /** litT fits ftT: unions per arm; literal-vs-literal by value; unit
-     * types only into their own unit; otherwise the widened IR pair must be
-     * equal or width-liftable. */
-    const fits = (litT, ftT) => {
-        if (ftT.isUnionType())
-            return ts.constituentTypes(ftT).some((a) => fits(litT, a));
-        if (ftT.isStringLiteralType())
-            return litT.isStringLiteralType() && litT.value === ftT.value;
-        if (ftT.isNumberLiteralType())
-            return litT.isNumberLiteralType() && litT.value === ftT.value;
-        if (ftT.flags & ts.TypeFlags.BooleanLiteral) {
-            return (litT.flags & ts.TypeFlags.BooleanLiteral) !== 0 && lowerer.checker.typeToString(litT) === lowerer.checker.typeToString(ftT);
-        }
-        if (ftT.flags & ts.TypeFlags.Null)
-            return (litT.flags & ts.TypeFlags.Null) !== 0;
-        if (ftT.flags & ts.TypeFlags.Undefined)
-            return (litT.flags & ts.TypeFlags.Undefined) !== 0;
-        if (litT.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
-            return false;
-        const li = lowerer.mapTypeOf(lowerer.checker.getBaseTypeOfLiteralType(litT));
-        const fi = lowerer.mapTypeOf(ftT);
-        if (!li || !fi)
-            return false;
-        return typeEquals(li, fi) || lowerer.widthLiftPlan(li, fi) !== null;
-    };
-    const armShapeIds = new Set(recordArms.map((a) => a.shapeId));
-    const candidates = new Set();
-    for (const member of ts.constituentTypes(tsType)) {
-        const mMapped = lowerer.mapTypeOf(member);
-        if (mMapped?.kind !== "record" || !armShapeIds.has(mMapped.shapeId) || candidates.has(mMapped.shapeId))
-            continue;
-        const shape = lowerer.shapes.get(mMapped.shapeId);
-        if (!shape || shape.tuple || shape.indexValue)
-            continue;
-        // Excess-property freshness: every literal field must exist on the
-        // member (tsc rejected the others for a fresh literal).
-        if (!props.every((p) => lowerer.checker.getPropertyOfType(member, p.name) !== undefined))
-            continue;
-        // Arm fields the literal leaves unset must be optional-flavored (the
-        // absent-completion rule: an undefined-armed union or a dyn slot).
-        const names = new Set(props.map((p) => p.name));
-        const absentOk = shape.fields.every((f) => {
-            if (names.has(f.name))
-                return true;
-            if (f.type.kind === "dyn")
-                return true;
-            if (f.type.kind !== "union")
-                return false;
-            return lowerer.unions.get(f.type.unionId)?.arms.some((a) => a.kind === "undefinedT") ?? false;
-        });
-        if (!absentOk)
-            continue;
-        const fieldsFit = props.every((p) => {
-            const sym = lowerer.checker.getPropertyOfType(member, p.name);
-            if (!sym)
-                return false;
-            return fits(lowerer.typeOf(p.node), lowerer.checker.getTypeOfSymbol(sym));
-        });
-        if (fieldsFit)
-            candidates.add(mMapped.shapeId);
-    }
-    if (candidates.size !== 1)
-        return null;
-    const [only] = candidates;
-    return recordArms.find((a) => a.shapeId === only) ?? null;
-}
-/** Object spread treats nullish sources as empty. Preserve evaluation once,
- * then turn `Record<K, V> | undefined` into either that record or a fresh
- * empty record of the same represented shape. */
-function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
-    if (source.type.kind !== "union")
-        return null;
-    const def = lowerer.unions.get(source.type.unionId);
-    if (!def || def.arms.length !== 2)
-        return null;
-    const undefinedTag = def.arms.findIndex((arm) => arm.kind === "undefinedT");
-    const recordTag = def.arms.findIndex((arm) => arm.kind === "record");
-    if (undefinedTag < 0 || recordTag < 0)
-        return null;
-    const recordType = def.arms[recordTag];
-    if (recordType.kind !== "record")
-        return null;
-    const prefix = [];
-    let stable = source;
-    if (!pureReemittable(source)) {
-        const local = lowerer.declareHiddenLocal("%spread", source.type);
-        prefix.push({ kind: "varDecl", localId: local.id, init: source, loc });
-        stable = varRef(local.id, source.type, loc);
-    }
-    const selected = {
-        kind: "ternary",
-        cond: { kind: "unionIsTag", unionId: source.type.unionId, tag: undefinedTag, negated: false, value: stable, type: BOOL, loc },
-        then: { kind: "recordLit", fields: [], type: recordType, loc },
-        else_: { kind: "unionNarrow", unionId: source.type.unionId, tag: recordTag, value: stable, type: recordType, loc },
-        type: recordType,
-        loc,
-    };
-    return prefix.length === 0 ? selected : { kind: "seqExpr", stmts: prefix, result: selected, type: recordType, loc };
-}
-export function lowerObjectLiteral(lowerer, expr) {
-    const loc = locOf(expr);
-    // The RUNTIME-KEYED literal (JS): a computed key that doesn't fold to a
-    // compile-time string means the literal's shape is not a compile-time
-    // fact — no record shape can hold it. The whole literal builds as a dyn
-    // object instead (`{ [field]: criteria, actual: 0, ... }` —
-    // test/common's _mustCallInner context), where keys are runtime string
-    // values. TypeScript keeps the record world and its fence: this shape
-    // only arises in checked-dynamic JS.
-    if (isJsSourceFile(expr.getSourceFile()) &&
-        expr.properties.some((p) => {
-            const n = ts.isSpreadAssignment(p) ? undefined : p.name;
-            return n !== undefined && ts.isComputedPropertyName(n) && literalComputedKey(lowerer, n) === null;
-        })) {
-        return lowerDynObjectLiteral(lowerer, expr);
-    }
-    // Syntax fence FIRST: unsupported member forms get their specific
-    // message even when they also make the literal's type unmappable
-    // (a getter or a `this`-returning method would otherwise surface as an
-    // opaque type fence on the whole literal).
-    for (const prop of expr.properties) {
-        if (ts.isSpreadAssignment(prop)) {
-            // Supported shapes: FULL spreads of known record shapes read as
-            // identifiers or other side-effect-free reads, all BEFORE any
-            // explicit property (the field-copy desugar reads spread fields
-            // first, exactly JS's eager copy order); and CONDITIONAL spreads
-            // `...(c ? {k: v} : {})` — the optional-field idiom tsc types as
-            // `k?: ...` — which desugar to one conditional field at the
-            // spread's own position (any position: they introduce one fresh
-            // name, collision-fenced below). Everything else stays fenced.
-            const cs = conditionalSpreadOf(prop.expression);
-            if (cs === "unsupported" || (cs && cs.props.length !== 1)) {
-                lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` (exactly one property against an empty arm — spell other shapes as optional fields)");
-            }
-            // Spread ORDER is fenced in the field-by-field desugar below, not
-            // here: the index-signature merge path supports any order (keyed
-            // last-write-wins writes), so `{ K: v, ...extra }` into a pure
-            // Record shape compiles — the buildServiceEnv pattern.
-            continue;
-        }
-        if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop)) {
-            // JavaScript CJS-export tables reach reads through the lifted-
-            // accessor path (cjsExportAccessorRead) — the literal VALUE
-            // narrows to its plain fields below (accessor names are not
-            // record storage; SEMANTICS.md documents the enumeration
-            // divergence). TypeScript accessors lower into the shape's
-            // reserved closure slots (%get:/%set: — see accessorSlotProp);
-            // `this` in the body is fenced up front: the closure slot has no
-            // receiver (capturing the record under construction would be an
-            // RC cycle), and the generic lexical-this walk would silently
-            // capture an ENCLOSING method's `this` — the object-method rule.
-            if (!isJsSourceFile(expr.getSourceFile())) {
-                rejectThisInObjectAccessor(lowerer, prop.body ?? prop);
-            }
-        }
-        // Unfoldable computed keys are NOT fenced here: an index-signature
-        // target lowers them as runtime keyed writes (the merge path below);
-        // every other target re-fences them after the merge path declined
-        // (fenceUnfoldableComputedKeys).
-        // Identifier keys, STRING-LITERAL keys (`"content-type": v` —
-        // record field names are data, never C identifiers; the mangler
-        // encodes what C can't spell), NUMERIC-LITERAL keys in their
-        // canonical string spelling (`{ 0: v }` stores "0", `{ 0x10: v }`
-        // stores "16" — JS's ToPropertyKey; the checker names the property
-        // symbol the same way), and FOLDABLE computed keys (above).
-        if (!prop.name ||
-            !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ||
-                ts.isNumericLiteral(prop.name) || ts.isComputedPropertyName(prop.name))) {
-            lowerer.unsupported("SC1090", prop, "non-identifier property names");
-        }
-        // Shorthand methods are just closure-valued fields — but their `this`
-        // is dynamically bound (typed as the literal by tsc, so noImplicitThis
-        // lets it through) and records don't model it; the generic
-        // lexical-this walk would silently capture an ENCLOSING method's
-        // `this`, so any `this` in the body is rejected up front.
-        if (ts.isMethodDeclaration(prop))
-            lowerer.rejectThisInObjectMethod(prop.body ?? prop);
-    }
-    let tsType = lowerer.checker.getContextualType(expr) ?? lowerer.typeOf(expr);
-    // `lit satisfies T` is TYPE-LEVEL only: the expression's checker type —
-    // and therefore the shape every downstream consumer sees — is the
-    // literal's OWN type (T still contextually types members, so inferred
-    // parameter types flow). Building at T would reshape the value tsc
-    // says has the literal's type: `{...} satisfies Movable &
-    // Record<string, unknown>` must NOT become an index-signature record.
-    // Own type wins whenever it maps to a record; an unmappable own type
-    // keeps the contextual fallback (a bare-null field whose satisfies
-    // target names the wider slot type).
-    {
-        let p = expr.parent;
-        while (ts.isParenthesizedExpression(p))
-            p = p.parent;
-        if (ts.isSatisfiesExpression(p)) {
-            const own = lowerer.typeOf(expr);
-            if (lowerer.mapTypeOf(own)?.kind === "record")
-                tsType = own;
-        }
-    }
-    // An async function's return position types the literal
-    // `T | PromiseLike<T>` (the lib's await-unwrapping contract). The
-    // PromiseLike arm never maps, and the record the return slot actually
-    // holds is exactly the checker's awaited type — strip to it BEFORE the
-    // own-type fallback below: the awaited contextual type carries the
-    // slot's field types (`lanIp: string | null`), which the literal's own
-    // type narrows away (a field written as `lanIp: null` types as bare
-    // `null`, which maps to nothing on its own).
-    if (tsType.isUnionType() && ts.constituentTypes(tsType).some((t) => t.getSymbol()?.name === "PromiseLike")) {
-        tsType = lowerer.checker.getAwaitedType(tsType) ?? tsType;
-    }
-    let mapped = lowerer.mapTypeOf(tsType);
-    // An EMPTY-record context under a NON-empty literal (`Object.keys({
-    // ...process.env })` — the lib's `{}`-typed parameters admit every
-    // object): `{}` carries no shape information, so the literal builds as
-    // its OWN type, exactly the unmappable-context fallback below. An
-    // empty LITERAL keeps the context (the shapes agree).
-    if (mapped?.kind === "record" && expr.properties.length > 0) {
-        const ctxShape = lowerer.shapes.get(mapped.shapeId);
-        if (ctxShape && ctxShape.fields.length === 0 && !ctxShape.indexValue && !ctxShape.tuple) {
-            mapped = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? mapped;
-        }
-    }
-    // A literal with a property the contextual TYPE ITSELF lacks — only
-    // reachable through type assertions and satisfies (fresh-literal
-    // excess-property checks reject the direct spelling): the context
-    // cannot hold the value, so the literal builds at its OWN type and the
-    // slot's width coercion narrows it (divergence 36's copy stance — the
-    // extra fields drop in the copy). The probe is against the CHECKER's
-    // contextual type, not the mapped shape: a property the contextual
-    // type carries but the shape dropped (settled value/reason,
-    // generic-callable members) belongs to the drop paths below, and
-    // index-signature contexts keep every key (overflow capture).
-    if (mapped?.kind === "record" && expr.properties.length > 0) {
-        const ctxShape = lowerer.shapes.get(mapped.shapeId);
-        if (ctxShape && !ctxShape.indexValue && !ctxShape.tuple) {
-            const names = new Set(ctxShape.fields.map((f) => f.name));
-            const ctxHasProp = (name) => {
-                const members = tsType.isUnionType() ? ts.constituentTypes(tsType) : [tsType];
-                return members.some((m) => lowerer.checker.getPropertyOfType(m, name) !== undefined);
-            };
-            const extraOf = (text) => !names.has(text) && !ctxHasProp(text);
-            const extra = expr.properties.some((p) => {
-                if (ts.isSpreadAssignment(p) || !p.name)
-                    return false;
-                if (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))
-                    return extraOf(p.name.text);
-                if (ts.isNumericLiteral(p.name))
-                    return extraOf(String(Number(p.name.text)));
-                return false; // computed keys keep their existing paths
-            });
-            if (extra)
-                mapped = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? mapped;
-        }
-    }
-    // A union-typed slot (`const r: Res = { kind: "ok", ... }`) contextually
-    // types the literal as the WHOLE union; build the literal as its own
-    // (arm) shape and let the slot's coercion wrap it into the union. An
-    // unknown-typed slot (`JSON.stringify({ a: 1 })`) likewise. An
-    // UNMAPPABLE context falls back the same way — the literal's own type
-    // is the plain record the slot coerces. A CLASS-INSTANCE context
-    // (`const p: Point = { x, y }` — tsc's structural view of data
-    // classes) falls back too: the literal builds as its own record and
-    // the slot's width coercion constructs through the trivial
-    // parameter-property constructor (recordToClassPlan), or fences with
-    // the record-shape story.
-    // A jsval-mapped context reaches here only when lowerExpr's island
-    // gate DECLINED it (a project-declared typedef that absorbed to the
-    // island through checker-`any` field residue): the literal builds at
-    // its own type like every unmappable context.
-    if (mapped === null || mapped.kind === "union" || mapped.kind === "dyn" || mapped.kind === "object" || mapped.kind === "jsval") {
-        const ctxUnion = mapped?.kind === "union" ? mapped : null;
-        mapped = lowerer.mapTypeOf(lowerer.typeOf(expr)) ?? mapped;
-        // A literal whose own shape re-tags into NO arm of the contextual
-        // union, where the union has exactly ONE record arm: build AS that
-        // arm — there is no ambiguity (tsc already checked the literal
-        // against the union, and the record arm is the only shape it can
-        // inhabit), and the arm's field types drive every property's
-        // coercion (`{ env: {...spread...}, onCleanup }` against an
-        // optional options param — the env value builds by ITS contextual
-        // index-signature type and wraps into the arm's `| undefined`
-        // field, where the literal's own inferred width would mismatch).
-        // Empty literals (`_env = {}` — the fieldless own shape) and
-        // literals against PURE index-signature arms (`{ OPENSSL_CONF:
-        // candidate }` — keys become overflow entries) are the same rule's
-        // simplest cases. The empty-array-in-union rule, record form.
-        if (ctxUnion) {
-            const def = lowerer.unions.get(ctxUnion.unionId);
-            const recordArms = def?.arms.filter((a) => a.kind === "record") ?? [];
-            if (recordArms.length === 1) {
-                const armShape = lowerer.shapes.get(recordArms[0].shapeId);
-                if ((mapped?.kind !== "record" || mapped.shapeId !== recordArms[0].shapeId) &&
-                    !armShape?.tuple) {
-                    mapped = recordArms[0];
-                }
-            }
-            else if (recordArms.length > 1) {
-                const ownShapeId = mapped?.kind === "record" ? mapped.shapeId : null;
-                // SEVERAL record arms (the reducer-action / discriminated-message
-                // pattern): the literal's own inferred shape re-tags into no arm
-                // — its field types widened per field (`parsed: 1` against
-                // `parsed: number | null`), so the IR-level candidate probe is
-                // ambiguous (a narrower arm also admits the literal by dropping
-                // fields). The LITERAL types tsc checked carry the discriminant
-                // the shapes erased: match the literal's fields against each
-                // union member's CHECKER types (literal-vs-literal field pairs
-                // decide by value — the `kind: "a"` discriminant), and when
-                // exactly ONE member fits, build AS that arm — its field types
-                // drive every property's coercion, exactly the single-record-arm
-                // rule above. Ambiguous literals keep the SC2003 fence.
-                if (ownShapeId === null || !recordArms.some((a) => a.shapeId === ownShapeId)) {
-                    const arm = literalUnionArmOf(lowerer, expr, tsType, recordArms);
-                    if (arm)
-                        mapped = arm;
-                }
-            }
-        }
-    }
-    // The CJS EXPORT-TABLE literal in VALUE position (JS): importers reach
-    // every member through alias plumbing and accessor lifts — the record
-    // VALUE exists for the module's own reads (Object.keys, internal
-    // member reads), so it keeps exactly the plain fields whose values
-    // lower; accessor entries and members with no value representation
-    // (rest-param function types) narrow away. SEMANTICS.md documents the
-    // enumeration divergence.
-    if (isJsSourceFile(expr.getSourceFile()) &&
-        (!mapped || expr.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))) &&
-        isCjsExportTableLiteral(expr)) {
-        const fields = [];
-        for (const prop of expr.properties) {
-            if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop))
-                continue;
-            const propName = ts.isSpreadAssignment(prop) ? undefined : prop.name;
-            if (!propName || !(ts.isIdentifier(propName) || ts.isStringLiteral(propName)))
-                continue;
-            const name = propName.text;
-            let v = null;
-            if (ts.isShorthandPropertyAssignment(prop)) {
-                v = probeLower(lowerer, propName);
-            }
-            else if (ts.isPropertyAssignment(prop)) {
-                v = probeLower(lowerer, prop.initializer);
-            }
-            if (!v || v.type.kind === "void" || v.type.kind === "caught" || v.type.kind === "jsval")
-                continue;
-            if (isUnitType(v.type))
-                continue;
-            fields.push({ name, value: v });
-        }
-        // Canonical (sorted) field order — the shape registry's invariant;
-        // the dropped reads are all pure, so reordering loses nothing.
-        fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-        const shapeId = lowerer.shapes.intern(fields.map((f) => ({ name: f.name, type: f.value.type })));
-        return { kind: "recordLit", fields, type: { kind: "record", shapeId }, loc };
-    }
-    // The JS declaration fallback, literal-side (the checked-dynamic tree-array rule's
-    // object form): a literal whose shape has no static home — an
-    // unmappable contextual type over unmappable own fields (the
-    // PropertyDescriptorMap argument of Object.defineProperties, nested
-    // descriptor records with `any` values) — builds as a dyn OBJECT:
-    // each field converts through the usual dyn boundary, and dynamic
-    // consumers ride the keyed-dyn paths. TypeScript keeps the fence.
-    if ((!mapped || mapped.kind === "dyn") && isJsSourceFile(expr.getSourceFile())) {
-        return lowerDynObjectLiteral(lowerer, expr);
-    }
-    if (!mapped || mapped.kind !== "record")
-        lowerer.badType(expr, tsType);
-    let type = mapped;
-    let shape = lowerer.shapes.get(type.shapeId);
-    // ACCESSOR properties, JS literals only (TS accessors fill the shape's
-    // %get:/%set: closure slots below): no record storage exists for them,
-    // so the literal's shape NARROWS to its plain fields (reads resolve
-    // through the lifted accessors; Object.keys over the value omits
-    // accessor names — the documented divergence).
-    if (isJsSourceFile(expr.getSourceFile())) {
-        const accessorNames = new Set(expr.properties
-            .filter((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p))
-            .map((p) => (p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? p.name.text : ""))
-            .filter((n) => n !== ""));
-        if (accessorNames.size > 0) {
-            const narrowed = shape.fields.filter((f) => !accessorNames.has(f.name));
-            const narrowedId = lowerer.shapes.intern(narrowed.map((f) => ({ name: f.name, type: f.type })), false, shape.indexValue);
-            type = { kind: "record", shapeId: narrowedId };
-            shape = lowerer.shapes.get(narrowedId);
-        }
-    }
-    const fieldTypes = new Map(shape.fields.map((f) => [f.name, f.type]));
-    // File-scope JavaScript object bindings live in the checked-dynamic tree
-    // to preserve open writes and identity. Build an optional-field literal
-    // from its actually written keys so Object.hasOwn can distinguish an
-    // omitted property from a present property whose value is undefined.
-    const topLevelJsDecl = ts.isVariableDeclaration(expr.parent) &&
-        expr.parent.initializer === expr &&
-        ts.isVariableStatement(expr.parent.parent.parent) &&
-        ts.isSourceFile(expr.parent.parent.parent.parent);
-    const assignedProperties = expr.properties.filter((prop) => ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop));
-    if (topLevelJsDecl && isJsSourceFile(expr.getSourceFile()) &&
-        assignedProperties.length === expr.properties.length) {
-        const provided = new Set(assignedProperties.map((prop) => propNameText(lowerer, prop.name)));
-        const omittedOptional = shape.fields.some((field) => !provided.has(field.name) && field.type.kind === "union" &&
-            lowerer.armTag(field.type.unionId, UNDEFINED_T) >= 0);
-        if (omittedOptional)
-            return lowerDynObjectLiteral(lowerer, expr);
-    }
-    // The clone probe may lower the leading spread before declining (a
-    // static `as` cast can make the checker-visible shape match while its
-    // erased IR value keeps a wider shape). Reuse that exact value in the
-    // ordinary spread path so lowering still happens once.
-    let leadingSpreadLowered = null;
-    // The overwhelmingly common immutable-update form over a record:
-    // `{ ...model, changed, other: value }`. The historic lowering expanded
-    // the spread into one recordGet per untouched field at EVERY site, then
-    // the backends inlined all of those retains and stores into the caller.
-    // A 178-field model updated hundreds of times consequently produced a
-    // half-million-line LLVM function. Keep the same evaluation/ownership
-    // semantics in one compact IR node: source first, explicit overrides in
-    // source order, and one backend clone helper per shape.
-    //
-    // Stay deliberately narrow. Tuple/index/accessor shapes, conditional or
-    // multiple spreads, spread-after-explicit order, and shape-changing width
-    // copies retain their existing lowering and diagnostics.
-    if (!isJsSourceFile(expr.getSourceFile()) &&
-        !shape.indexValue &&
-        !shape.tuple &&
-        !shapeHasAccessorSlots(shape) &&
-        expr.properties.length >= 2 &&
-        ts.isSpreadAssignment(expr.properties[0]) &&
-        !conditionalSpreadOf(expr.properties[0].expression) &&
-        expr.properties.slice(1).every((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
-            p.name !== undefined &&
-            (ts.isIdentifier(p.name) ||
-                ts.isStringLiteral(p.name) ||
-                ts.isNumericLiteral(p.name) ||
-                (ts.isComputedPropertyName(p.name) && literalComputedKey(lowerer, p.name) !== null)))) {
-        const spread = expr.properties[0];
-        const props = expr.properties.slice(1);
-        const names = props.map((p) => propNameText(lowerer, p.name));
-        const unique = new Set(names);
-        const sourceType = lowerer.mapTypeOf(lowerer.typeOf(spread.expression));
-        if (sourceType?.kind === "record" &&
-            sourceType.shapeId === type.shapeId &&
-            unique.size === names.length &&
-            names.every((name) => fieldTypes.has(name))) {
-            const source = lowerer.lowerExpr(spread.expression);
-            if (source.type.kind === "record" && source.type.shapeId === type.shapeId) {
-                const overrides = [];
-                for (let i = 0; i < props.length; i++) {
-                    const p = props[i];
-                    const name = names[i];
-                    const fieldType = fieldTypes.get(name);
-                    const valueNode = ts.isPropertyAssignment(p) ? p.initializer : p;
-                    let value = ts.isPropertyAssignment(p)
-                        ? lowerer.lowerExpr(p.initializer)
-                        : lowerer.lowerShorthandValue(p);
-                    value = lowerer.coerceInto(valueNode, value, fieldType);
-                    if (!typeEquals(value.type, fieldType))
-                        lowerer.badType(valueNode, lowerer.typeOf(valueNode));
-                    overrides.push({ name, value });
-                }
-                return { kind: "recordClone", source, overrides, type, loc };
-            }
-            leadingSpreadLowered = source;
-        }
-    }
-    // A PURE index-signature target with spreads — `{ ...process.env }`,
-    // `{ ...process.env, ...extraEnv }`, `{ ...env, PATH: p }` (the
-    // spawn-env pattern): the field-by-field desugar below cannot
-    // enumerate runtime overflow keys, so the literal lowers as ONE
-    // interned merge-helper call — contributors apply in literal order
-    // with keyed writes (JS last-write-wins), sources and values evaluate
-    // once each in source order (the call's argument order). A CONDITIONAL
-    // spread `...(c ? { k: v } : {})` contributes its one key as a ternary
-    // — cond once, v lazily, the empty arm holding the value slot's
-    // undefined arm (the explicit-undefined-is-absent stance: JSON and
-    // child-env builders drop it, exactly Node's absent key); targets
-    // with declared fields keep the historic desugar below.
-    const isRuntimeComputedKey = (p) => !ts.isSpreadAssignment(p) &&
-        p.name !== undefined &&
-        ts.isComputedPropertyName(p.name) &&
-        literalComputedKey(lowerer, p.name) === null;
-    if (shape.indexValue &&
-        shape.fields.length === 0 &&
-        !shape.tuple &&
-        (expr.properties.some((p) => ts.isSpreadAssignment(p)) || expr.properties.some(isRuntimeComputedKey))) {
-        const contributors = [];
-        let mergeable = true;
-        for (const prop of expr.properties) {
-            if (ts.isSpreadAssignment(prop)) {
-                const cs = conditionalSpreadOf(prop.expression);
-                if (cs === "unsupported" || (cs && cs.props.length !== 1)) {
-                    lowerer.unsupported("SC1090", prop, "conditional spreads beyond `...(c ? { field: v } : {})` (exactly one property against an empty arm)");
-                }
-                if (cs) {
-                    const absent = lowerer.wrappedUndefined(shape.indexValue, locOf(prop));
-                    if (!absent) {
-                        lowerer.unsupported("SC1090", prop, `conditional spreads into '${lowerer.fmt(shape.indexValue)}'-valued index-signature keys (the empty arm needs an undefined arm to hold — write the key in an if statement instead)`);
-                    }
-                    const csProp = cs.props[0];
-                    const cond = lowerer.lowerCondition(cs.cond);
-                    const vNode = ts.isPropertyAssignment(csProp) ? csProp.initializer : csProp;
-                    const v = lowerer.intoIndexValueSlot(ts.isPropertyAssignment(csProp) ? lowerer.lowerExpr(csProp.initializer) : lowerer.lowerShorthandValue(csProp), shape.indexValue, vNode);
-                    contributors.push({
-                        kind: "field",
-                        name: csProp.name.text,
-                        value: {
-                            kind: "ternary",
-                            cond,
-                            then: cs.whenTrue ? v : absent,
-                            else_: cs.whenTrue ? absent : v,
-                            type: shape.indexValue,
-                            loc: locOf(prop),
-                        },
-                    });
-                    continue;
-                }
-                let src = lowerer.lowerExpr(prop.expression);
-                src = lowerOptionalIndexSpreadSource(lowerer, src, locOf(prop)) ?? src;
-                if (src.type.kind !== "record") {
-                    lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(src.type)}' sources into an index-signature shape (only index-signature records merge — ${NARROW_FIRST})`);
-                }
-                fenceAccessorSpreadSource(lowerer, prop, lowerer.shapes.get(src.type.shapeId));
-                contributors.push({ kind: "spread", shapeId: src.type.shapeId, value: src });
-                continue;
-            }
-            if ((ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) &&
-                prop.name &&
-                (ts.isIdentifier(prop.name) ||
-                    ts.isStringLiteral(prop.name) ||
-                    ts.isNumericLiteral(prop.name) ||
-                    (ts.isComputedPropertyName(prop.name) && literalComputedKey(lowerer, prop.name) !== null))) {
-                const value = ts.isPropertyAssignment(prop)
-                    ? lowerer.intoIndexValueSlot(lowerer.lowerExpr(prop.initializer), shape.indexValue, prop.initializer)
-                    : lowerer.intoIndexValueSlot(lowerer.lowerShorthandValue(prop), shape.indexValue, prop);
-                contributors.push({ kind: "field", name: propNameText(lowerer, prop.name), value });
-                continue;
-            }
-            // A RUNTIME-keyed property (`{ ...m, ["a" + "b"]: "" }`, `{ [K]:
-            // v }` where K is a runtime string): the key evaluates before its
-            // value (JS's per-property order — both are helper arguments) and
-            // writes through the signature exactly like a spread's keys.
-            // Number/boolean/unknown keys stringify (ToPropertyKey).
-            if (ts.isPropertyAssignment(prop) && ts.isComputedPropertyName(prop.name)) {
-                let k = lowerer.lowerExpr(prop.name.expression);
-                if (k.type.kind === "f64" || k.type.kind === "bool" || k.type.kind === "dyn") {
-                    k = { kind: "toString", operand: k, type: STRING, loc: locOf(prop.name) };
-                }
-                if (k.type.kind !== "string") {
-                    lowerer.unsupported("SC1090", prop.name, `'${lowerer.fmt(k.type)}'-typed computed property keys (string, number, boolean, and unknown keys stringify)`);
-                }
-                const value = lowerer.intoIndexValueSlot(lowerer.lowerExpr(prop.initializer), shape.indexValue, prop.initializer);
-                contributors.push({ kind: "keyedField", key: k, value });
-                continue;
-            }
-            mergeable = false;
-            break;
-        }
-        if (mergeable) {
-            const helper = lowerIndexMergeHelper(lowerer, type.shapeId, contributors, loc);
-            if (helper === null) {
-                lowerer.unsupported("SC1090", expr, `object spread into '${lowerer.fmt(type)}' from these source shapes (spread sources must be index-signature records whose value type is, or lifts into, the target's)`);
-            }
-            return {
-                kind: "call",
-                callee: helper,
-                args: contributors.flatMap((c) => (c.kind === "keyedField" ? [c.key, c.value] : [c.value])),
-                type,
-                loc,
-            };
-        }
-    }
-    // Unfoldable computed keys outside the index-signature merge path:
-    // no record shape can hold a runtime-decided name.
-    for (const prop of expr.properties) {
-        if (isRuntimeComputedKey(prop)) {
-            lowerer.unsupported("SC1090", prop.name, "computed property keys (compile-time-known keys fold — a pure expression whose checker type is one string or number literal: consts, enum members, quoted keys, templates of those — `{ [MARKER]: v }`; runtime string keys write through an index-signature target; symbol keys stay out)");
-        }
-    }
-    // A DECLARED-fields target built ENTIRELY from index-signature spreads —
-    // `{ ...Object.fromEntries(...), ...Object.fromEntries(...) }` typed
-    // AppConfig (the defaults-merge idiom over runtime-keyed sources): the
-    // field-by-field desugar cannot enumerate runtime keys, so the literal
-    // lowers as ONE interned merge-helper call — sources evaluate once each
-    // in source order (the call's argument order — computed sources
-    // included, no re-read), contributors apply in order with per-key
-    // dispatch onto the declared fields (JS last-write-wins). Divergence 68
-    // has the runtime rules (validated collisions, extra keys dropped).
-    if (!shape.indexValue &&
-        !shape.tuple &&
-        shape.fields.length > 0 &&
-        expr.properties.length > 0 &&
-        expr.properties.every((p) => ts.isSpreadAssignment(p) && !conditionalSpreadOf(p.expression)) &&
-        expr.properties.some((p) => {
-            const t = lowerer.mapTypeOf(lowerer.typeOf(p.expression));
-            return t?.kind === "record" && !!lowerer.shapes.get(t.shapeId)?.indexValue;
-        })) {
-        return lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc);
-    }
-    const shapeMismatch = (node) => {
-        const own = lowerer.mapTypeOf(lowerer.typeOf(expr));
-        lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), own ? lowerer.fmt(own) : lowerer.checker.typeToString(lowerer.typeOf(expr)), locOf(node), own?.kind === "record" && type.kind === "record"
-            ? (lowerer.describeRecordWidthBlocker(own.shapeId, type.shapeId) ?? undefined)
-            : undefined));
-        throw new PoisonError();
-    };
-    const fields = [];
-    // Field names introduced by conditional spreads: their ternary carries
-    // the spread's whole evaluation (cond once, value lazily), so a LATER
-    // contributor overriding one would silently drop that evaluation —
-    // collisions fence in both directions.
-    const conditionalNames = new Set();
-    // Member names DROPPED from the shape (JS deferral — unlowerable pure
-    // member reads narrow away; see the catch in the property loop).
-    const droppedNames = new Set();
-    for (const prop of expr.properties) {
-        if (ts.isSpreadAssignment(prop)) {
-            const cs = conditionalSpreadOf(prop.expression);
-            if (cs && cs !== "unsupported") {
-                // `...(c ? { k: v } : {})` — ONE conditional field at the
-                // spread's own position: cond evaluates exactly once, `v` only
-                // when the non-empty arm is taken (ternary arms are lazy), and
-                // the empty arm holds the interned undefined arm — exactly the
-                // omitted-optional-field representation, which is also why the
-                // target field must be optional (tsc types the idiom that way).
-                const csProp = cs.props[0]; // single-prop-checked in the fence pass
-                const name = csProp.name.text;
-                const fieldType = fieldTypes.get(name);
-                if (!fieldType) {
-                    if (shape.indexValue) {
-                        lowerer.unsupported("SC1090", prop, "conditional spreads into index-signature keys (overflow entries model presence — write the key in an if statement instead)");
-                    }
-                    throw shapeMismatch(prop);
-                }
-                const absent = lowerer.wrappedUndefined(fieldType, locOf(prop));
-                if (!absent) {
-                    lowerer.unsupported("SC1090", prop, `conditional spreads onto the required field '${name}' (the empty arm leaves it undefined — declare the field optional)`);
-                }
-                if (fields.some((f) => f.name === name)) {
-                    lowerer.unsupported("SC1090", prop, `conditional spread of '${name}' over an earlier '${name}' (the desugar keeps one entry per name — restructure so each name has one contributor)`);
-                }
-                const cond = lowerer.lowerCondition(cs.cond);
-                const valueNode = ts.isPropertyAssignment(csProp) ? csProp.initializer : csProp;
-                let v = ts.isPropertyAssignment(csProp)
-                    ? lowerer.lowerExpr(csProp.initializer)
-                    : lowerer.lowerShorthandValue(csProp);
-                v = lowerer.coerceInto(valueNode, v, fieldType);
-                if (!typeEquals(v.type, fieldType))
-                    lowerer.badType(valueNode, lowerer.typeOf(valueNode));
-                conditionalNames.add(name);
-                fields.push({
-                    name,
-                    value: {
-                        kind: "ternary",
-                        cond,
-                        then: cs.whenTrue ? v : absent,
-                        else_: cs.whenTrue ? absent : v,
-                        type: fieldType,
-                        loc: locOf(prop),
-                    },
-                });
-                continue;
-            }
-            // `{ ...base, ... }` — field-by-field copy of a known record
-            // shape. Every source field must land on the target shape with an
-            // equal type (a wider source would silently DROP fields JS keeps —
-            // the width fence, same as literals). Later contributors override
-            // earlier ones (JS last-write-wins; the reads are side-effect-free,
-            // so dropping the earlier read is exact). Identifier sources
-            // re-read per field (historic path); any OTHER source must be a
-            // re-emittable pure read, sharing one lowered node per field.
-            // The desugar's one-entry-per-name list reads spread fields
-            // EAGERLY at the spread's position, so an explicit property
-            // BEFORE a spread would need JS's overwrite — order-fenced (the
-            // index-signature merge path above takes any order).
-            if (expr.properties
-                .slice(0, expr.properties.indexOf(prop))
-                .some((p) => !ts.isSpreadAssignment(p))) {
-                lowerer.unsupported("SC1090", prop, "object spread after explicit properties (spreads must come first — a later spread would overwrite them with JS semantics the desugar does not model)");
-            }
-            let srcNode = prop.expression;
-            while (ts.isParenthesizedExpression(srcNode))
-                srcNode = srcNode.expression;
-            const srcLowered = prop === expr.properties[0] && leadingSpreadLowered !== null
-                ? leadingSpreadLowered
-                : ts.isIdentifier(srcNode)
-                    ? null
-                    : lowerer.lowerExpr(srcNode);
-            const srcType = srcLowered ? srcLowered.type : lowerer.mapTypeOf(lowerer.typeOf(srcNode));
-            // `...options.installConfig` — a spread of `Partial<X> | undefined`
-            // (the optional-options merge idiom `{ ...DEFAULTS, ...overrides }`):
-            // JS spreads nothing for the unit arm and copies present keys
-            // otherwise. Per target field the desugar builds
-            // `present ? extracted : earlier` — present tests the source's
-            // record tag AND (optional source fields) the field's own value
-            // arm; absent keeps the earlier contributor's value (both reads
-            // are pure, so the reorder into the ternary is unobservable).
-            if (srcType?.kind === "union") {
-                const def = lowerer.unions.get(srcType.unionId);
-                const recArms = def?.arms.filter((a) => a.kind === "record") ?? [];
-                if (!def ||
-                    recArms.length !== 1 ||
-                    !def.arms.every((a) => a.kind === "record" || isUnitType(a))) {
-                    lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(srcType)}' sources (only known record shapes spread — ${NARROW_FIRST})`);
-                }
-                if (srcLowered && !pureReemittable(srcLowered)) {
-                    lowerer.unsupported("SC1090", prop, "object spread of computed sources (the field copies re-read the source — bind it to a const first)");
-                }
-                const recArm = recArms[0];
-                const recTag = def.arms.indexOf(recArm);
-                // A checked-dynamic VALUE under the union-mapped checker type
-                // (a JS dyn-holding binding): the present/absent desugar tests
-                // union tags a dyn box does not carry — fence honestly instead
-                // of the validator's ICE.
-                const probedSrc = srcLowered ?? probeLower(lowerer, srcNode);
-                if (probedSrc?.type.kind === "dyn") {
-                    lowerer.unsupported("SC1090", prop, `object spread of a checked-dynamic '${lowerer.fmt(srcType)}' source (${NARROW_FIRST})`);
-                }
-                const srcShape = lowerer.shapes.get(recArm.shapeId);
-                if (!srcShape)
-                    throw new InternalCompilerError(`lowerer bug: spread of unknown shape ${recArm.shapeId}`);
-                fenceAccessorSpreadSource(lowerer, prop, srcShape);
-                if (srcShape.indexValue || shape.indexValue) {
-                    lowerer.unsupported("SC1090", prop, "object spread involving index-signature shapes (overflow keys are runtime state — copy the fields you need explicitly)");
-                }
-                const laterNames = new Set();
-                for (const later of expr.properties.slice(expr.properties.indexOf(prop) + 1)) {
-                    if (ts.isSpreadAssignment(later)) {
-                        if (conditionalSpreadOf(later.expression))
-                            continue;
-                        const lt = lowerer.mapTypeOf(lowerer.typeOf(later.expression));
-                        if (lt?.kind === "record") {
-                            for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
-                                laterNames.add(lf.name);
-                        }
-                        continue;
-                    }
-                    if (later.name &&
-                        (ts.isIdentifier(later.name) ||
-                            ts.isStringLiteral(later.name) ||
-                            ts.isNumericLiteral(later.name) ||
-                            (ts.isComputedPropertyName(later.name) && literalComputedKey(lowerer, later.name) !== null))) {
-                        laterNames.add(propNameText(lowerer, later.name));
-                    }
-                }
-                const srcRef = () => srcLowered ?? lowerer.lowerExpr(srcNode);
-                for (const f of srcShape.fields) {
-                    if (laterNames.has(f.name))
-                        continue;
-                    const targetType = fieldTypes.get(f.name);
-                    // No slot on the target shape: the copy DROPS the field
-                    // (divergence 36's stance, same as the plain-record spread).
-                    if (!targetType)
-                        continue;
-                    if (conditionalNames.has(f.name)) {
-                        lowerer.unsupported("SC1090", prop, `spread of '${f.name}' over an earlier conditional spread (the desugar keeps one entry per name — restructure so each name has one contributor)`);
-                    }
-                    const fRead = () => ({
-                        kind: "recordGet",
-                        obj: { kind: "unionNarrow", unionId: srcType.unionId, tag: recTag, value: srcRef(), type: recArm, loc: locOf(prop) },
-                        shapeId: recArm.shapeId,
-                        field: f.name,
-                        type: f.type,
-                        loc: locOf(prop),
-                    });
-                    let cond = { kind: "unionIsTag", unionId: srcType.unionId, tag: recTag, negated: false, value: srcRef(), type: BOOL, loc: locOf(prop) };
-                    let thenVal;
-                    if (typeEquals(f.type, targetType)) {
-                        thenVal = fRead();
-                    }
-                    else if (f.type.kind === "union" &&
-                        lowerer.armTag(f.type.unionId, UNDEFINED_T) >= 0 &&
-                        typeEquals(lowerer.stripUndefinedArm(f.type), targetType)) {
-                        // Optional source field into a required target slot: present
-                        // means the source holds the record AND the field its value
-                        // arm — the spread-override completion, union-source form.
-                        const ftUndef = lowerer.armTag(f.type.unionId, UNDEFINED_T);
-                        cond = {
-                            kind: "logical",
-                            op: "&&",
-                            left: cond,
-                            right: { kind: "unionIsTag", unionId: f.type.unionId, tag: ftUndef, negated: true, value: fRead(), type: BOOL, loc: locOf(prop) },
-                            type: BOOL,
-                            loc: locOf(prop),
-                        };
-                        const ftDef = lowerer.unions.get(f.type.unionId);
-                        if (targetType.kind === "union") {
-                            const retag = lowerer.unionRetagHelper(f.type.unionId, targetType.unionId, locOf(prop));
-                            if (!retag) {
-                                lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(recArm), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' cannot re-tag into '${lowerer.fmt(targetType)}' behind the present-test`));
-                                throw new PoisonError();
-                            }
-                            thenVal = { kind: "call", callee: retag, args: [fRead()], type: targetType, loc: locOf(prop) };
-                        }
-                        else if (ftDef && ftDef.arms.length === 2 && lowerer.armTag(f.type.unionId, targetType) >= 0) {
-                            thenVal = { kind: "unionNarrow", unionId: f.type.unionId, tag: lowerer.armTag(f.type.unionId, targetType), value: fRead(), type: targetType, loc: locOf(prop) };
-                        }
-                        else {
-                            lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(recArm), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' cannot narrow into '${lowerer.fmt(targetType)}' behind the present-test`));
-                            throw new PoisonError();
-                        }
-                    }
-                    else {
-                        // The width-lift fallback (arm wrap, re-tag, nested
-                        // reshape) — the same per-field rule the slot coercion
-                        // applies. Runs AFTER the optional-completion branch: a
-                        // present-test has its own semantics a re-tag's stranded
-                        // undefined trap must not shadow.
-                        const lift = lowerer.widthLiftPlan(f.type, targetType);
-                        if (!lift) {
-                            lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(recArm), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' does not lift into '${lowerer.fmt(targetType)}'`));
-                            throw new PoisonError();
-                        }
-                        thenVal = lowerer.applyWidthLift(lift, fRead(), targetType, locOf(prop));
-                    }
-                    const at = fields.findIndex((x) => x.name === f.name && !x.drop);
-                    const elseVal = at >= 0 ? fields[at].value : lowerer.wrappedUndefined(targetType, locOf(prop));
-                    if (!elseVal) {
-                        lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(srcType)}' sources where '${f.name}' has no earlier contributor (the absent arm leaves the required field unset — spread defaults first: { ...defaults, ...overrides })`);
-                    }
-                    const merged = { kind: "ternary", cond, then: thenVal, else_: elseVal, type: targetType, loc: locOf(prop) };
-                    if (at >= 0)
-                        fields[at] = { name: f.name, value: merged };
-                    else
-                        fields.push({ name: f.name, value: merged });
-                }
-                continue;
-            }
-            if (srcType?.kind !== "record") {
-                lowerer.unsupported("SC1090", prop, `object spread of '${srcType ? lowerer.fmt(srcType) : lowerer.checker.typeToString(lowerer.typeOf(srcNode))}' sources (only known record shapes spread — ${NARROW_FIRST})`);
-            }
-            if (srcLowered && !pureReemittable(srcLowered)) {
-                lowerer.unsupported("SC1090", prop, "object spread of computed sources (the field copies re-read the source — bind it to a const first)");
-            }
-            const srcShape = lowerer.shapes.get(srcType.shapeId);
-            if (!srcShape)
-                throw new InternalCompilerError(`lowerer bug: spread of unknown shape ${srcType.shapeId}`);
-            fenceAccessorSpreadSource(lowerer, prop, srcShape);
-            // Index-signature shapes carry runtime-keyed overflow entries the
-            // field-by-field desugar cannot enumerate — fenced on either side.
-            if (srcShape.indexValue || shape.indexValue) {
-                lowerer.unsupported("SC1090", prop, "object spread involving index-signature shapes (overflow keys are runtime state — copy the fields you need explicitly)");
-            }
-            // Names a LATER contributor unconditionally defines: copying such a
-            // source field is dead under JS last-write-wins (and spread reads
-            // are side-effect-free), so it neither lowers nor width-checks —
-            // the spread-then-override completion `{ ...config, stateDir }`
-            // narrows an optional source field into a required target slot
-            // exactly like Node does. Conditional spreads don't count (their
-            // empty arm defines nothing) — their own collision fences hold.
-            const laterNames = new Set();
-            for (const later of expr.properties.slice(expr.properties.indexOf(prop) + 1)) {
-                if (ts.isSpreadAssignment(later)) {
-                    if (conditionalSpreadOf(later.expression))
-                        continue;
-                    const lt = lowerer.mapTypeOf(lowerer.typeOf(later.expression));
-                    if (lt?.kind === "record") {
-                        for (const lf of lowerer.shapes.get(lt.shapeId)?.fields ?? [])
-                            laterNames.add(lf.name);
-                    }
-                    continue;
-                }
-                if (later.name &&
-                    (ts.isIdentifier(later.name) ||
-                        ts.isStringLiteral(later.name) ||
-                        ts.isNumericLiteral(later.name) ||
-                        (ts.isComputedPropertyName(later.name) && literalComputedKey(lowerer, later.name) !== null))) {
-                    laterNames.add(propNameText(lowerer, later.name));
-                }
-            }
-            for (const f of srcShape.fields) {
-                if (laterNames.has(f.name))
-                    continue;
-                const targetType = fieldTypes.get(f.name);
-                // A source field with NO slot on the target shape: the copy
-                // DROPS it — a spread of a wider record into a narrower literal
-                // is width subtyping in spread clothing, divergence 36's stance
-                // (Node's object would keep the key); the read is pure, so
-                // skipping evaluates nothing.
-                if (!targetType)
-                    continue;
-                const lift = typeEquals(f.type, targetType)
-                    ? null
-                    : lowerer.widthLiftPlan(f.type, targetType);
-                if (!typeEquals(f.type, targetType) && !lift) {
-                    // Print the SOURCE shape, not the literal's own type: the
-                    // checker's own type already has later overrides applied, so
-                    // it can render identically to the target while the spread
-                    // source (the thing that actually mismatches) differs — an
-                    // invisible difference is a diagnostics bug.
-                    lowerer.pushDiag(recordShapeMismatchDiag(lowerer.fmt(type), lowerer.fmt(srcType), locOf(prop), `spread field '${f.name}': '${lowerer.fmt(f.type)}' does not lift into '${lowerer.fmt(targetType)}'`));
-                    throw new PoisonError();
-                }
-                const obj = srcLowered ?? lowerer.lowerExpr(srcNode);
-                // A record-mapped CHECKER type whose VALUE lives in the checked-dynamic tree (a
-                // JS file-scope object-literal global): read each field from
-                // the checked-dynamic tree (dynKeyGet) and VALIDATE it into the source shape's
-                // field type (dynCheck) — the checked-dynamic member-read
-                // discipline. A missing key answers the dyn undefined, exactly
-                // the undefined-armed optional's absent case; a mismatched
-                // runtime value throws the catchable TypeError, never a silent
-                // wrong copy. Runtime-ADDED keys drop — width subtyping in
-                // spread clothing, divergence 36's stance.
-                let value;
-                if (obj.type.kind === "dyn") {
-                    if (!canDynCheckTo(f.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
-                        lowerer.unsupported("SC1100", prop, `object spread of a checked-dynamic source whose field '${f.name}' ('${lowerer.fmt(f.type)}') cannot validate out of the checked-dynamic tree (copy the fields explicitly)`);
-                    }
-                    value = {
-                        kind: "dynCheck",
-                        value: {
-                            kind: "dynKeyGet",
-                            key: { kind: "strLit", value: f.name, type: STRING, loc: locOf(prop) },
-                            value: obj,
-                            type: DYN,
-                            loc: locOf(prop),
-                        },
-                        type: f.type,
-                        loc: locOf(prop),
-                    };
-                }
-                else {
-                    value = {
-                        kind: "recordGet",
-                        obj,
-                        shapeId: srcType.shapeId,
-                        field: f.name,
-                        type: f.type,
-                        loc: locOf(prop),
-                    };
-                }
-                // A liftable field widens into the target slot (arm wrap,
-                // re-tag, nested reshape) — the same per-field rule the slot
-                // coercion applies.
-                if (lift)
-                    value = lowerer.applyWidthLift(lift, value, targetType, locOf(prop));
-                if (conditionalNames.has(f.name)) {
-                    lowerer.unsupported("SC1090", prop, `spread of '${f.name}' over an earlier conditional spread (the desugar keeps one entry per name — restructure so each name has one contributor)`);
-                }
-                const at = fields.findIndex((x) => x.name === f.name);
-                if (at >= 0)
-                    fields[at] = { name: f.name, value };
-                else
-                    fields.push({ name: f.name, value });
-            }
-            continue;
-        }
-        if (ts.isGetAccessorDeclaration(prop) || ts.isSetAccessorDeclaration(prop)) {
-            // JS accessor entries carry no storage (narrowed away above); TS
-            // accessors fill the shape's reserved closure slots — the getter
-            // body lowers as an ordinary zero-arg closure invoked per property
-            // READ, the setter as a one-arg closure invoked per WRITE
-            // (fieldGetExpr/fieldSetStmt dispatch on the slots). Creating the
-            // closures is side-effect-free, so their position among the data
-            // fields' source-order evaluation is unobservable — exactly JS,
-            // where accessor definitions evaluate nothing.
-            if (isJsSourceFile(expr.getSourceFile()))
-                continue;
-            const name = propNameText(lowerer, prop.name); // key-form-checked above
-            const slotName = `${ts.isGetAccessorDeclaration(prop) ? "%get" : "%set"}:${name}`;
-            const slotT = fieldTypes.get(slotName);
-            if (!slotT || slotT.kind !== "func") {
-                // The contextual shape stores a DATA value under this name
-                // (`const p: { x: number } = { get x() {...} }` — tsc lets a
-                // live accessor satisfy a data member): the slot would freeze
-                // one getter answer where Node keeps the accessor live.
-                if (fieldTypes.has(name)) {
-                    lowerer.unsupported("SC1090", prop, `a get/set accessor satisfying the data property '${name}' of '${lowerer.fmt(type)}' (the record slot stores a plain value — Node would keep the accessor live through this type)`);
-                }
-                throw shapeMismatch(prop);
-            }
-            const closure = lowerer.coerceInto(prop, lowerer.lowerLambda(prop), slotT);
-            if (!typeEquals(closure.type, slotT))
-                lowerer.badType(prop, lowerer.typeOf(prop));
-            fields.push({ name: slotName, value: closure });
-            continue;
-        }
-        const name = propNameText(lowerer, prop.name); // key-form-checked above
-        let fieldType = fieldTypes.get(name);
-        // An undeclared name against an index-signature shape is an OVERFLOW
-        // entry (tsc typechecked it against the signature's value type);
-        // against a plain shape it is the width mismatch it always was —
-        // EXCEPT the PromiseSettledResult honest subset's dropped fields
-        // (value/reason — SEMANTICS.md 46): those evaluate for effect in
-        // their source-order slot and store nothing.
-        // A GENERIC-callable member (a generic method `m<T>(x: T) {...}` or a
-        // generic arrow/function-expression property): excluded from the
-        // record shape (isGenericCallableMemberType — no single closure slot
-        // can hold it), so the literal stores nothing for it. Pure
-        // function-creating forms skip outright (creating a closure has no
-        // side effects; calls resolve statically against this declaration);
-        // a computed initializer would need its evaluation kept — fenced.
-        if (!fieldType && !ts.isSpreadAssignment(prop)) {
-            const memberSym = prop.name && lowerer.checker.getSymbolAtLocation(prop.name);
-            const memberT = memberSym ? lowerer.checker.getTypeOfSymbol(memberSym) : undefined;
-            if (memberT && isGenericCallableMemberType(memberT, lowerer.checker)) {
-                const pureInit = (() => {
-                    if (ts.isMethodDeclaration(prop))
-                        return true;
-                    if (ts.isShorthandPropertyAssignment(prop))
-                        return true; // a pure read
-                    if (!ts.isPropertyAssignment(prop))
-                        return false;
-                    let init = prop.initializer;
-                    while (ts.isParenthesizedExpression(init))
-                        init = init.expression;
-                    return ts.isArrowFunction(init) || ts.isFunctionExpression(init) || ts.isIdentifier(init);
-                })();
-                if (!pureInit) {
-                    lowerer.unsupported("SC1090", prop, `generic-function-valued properties with computed initializers ('${name}' has no record slot — its evaluation would be dropped; bind the function to a top-level declaration instead)`);
-                }
-                continue;
-            }
-        }
-        if (!fieldType && !shape.indexValue) {
-            if (settledDropNames(lowerer, tsType)?.has(name)) {
-                // Identifier and shorthand initializers are effect-free reads —
-                // skipped outright. The caught `reason` MUST skip: lowering the
-                // read would hit the catch-binding narrowness fence, and the
-                // snapshot it names needs no evaluation.
-                if (ts.isPropertyAssignment(prop) && !ts.isIdentifier(prop.initializer)) {
-                    const v = lowerer.lowerExpr(prop.initializer);
-                    // Effect-free lowerings (literals, plain reads) drop at
-                    // compile time; anything else — the awaited mapper — runs
-                    // (and may throw into the enclosing catch) with its result
-                    // released by the statement frame.
-                    if (v.kind !== "unitLit" && v.kind !== "numLit" && v.kind !== "strLit" &&
-                        v.kind !== "boolLit" && v.kind !== "varRef" && v.kind !== "closure") {
-                        fields.push({ name, value: v, drop: true });
-                    }
-                }
-                continue;
-            }
-            throw shapeMismatch(prop);
-        }
-        let value;
-        let valueNode = prop;
-        const propDiagsBefore = lowerer.diags.length;
-        try {
-            if (ts.isPropertyAssignment(prop)) {
-                valueNode = prop.initializer;
-                // ARRAY-LITERAL initializers route through the expected-type
-                // lowering: a union field with one array-family arm builds the
-                // literal AS that arm (lowerExprExpecting's IR-directed rule —
-                // the option-table `default: [{ value: [] }]` shape), where the
-                // bare lowering would take the JS dyn fallback and fence.
-                let init = prop.initializer;
-                while (ts.isParenthesizedExpression(init))
-                    init = init.expression;
-                value =
-                    fenceClosureProbe(lowerer, prop.initializer, fieldType, () => lowerer.lowerExpr(prop.initializer)) ??
-                        (fieldType !== undefined && ts.isArrayLiteralExpression(init)
-                            ? lowerer.lowerExprExpecting(prop.initializer, fieldType)
-                            : lowerer.lowerExpr(prop.initializer));
-            }
-            else if (ts.isShorthandPropertyAssignment(prop)) {
-                value = lowerer.lowerShorthandValue(prop);
-            }
-            else if (ts.isMethodDeclaration(prop)) {
-                value =
-                    fenceClosureProbe(lowerer, prop, fieldType, () => lowerer.lowerLambda(prop)) ?? lowerer.lowerLambda(prop);
-            }
-            else {
-                lowerer.unsupported("SC1090", prop, `syntax '${ts.SyntaxKind[prop.kind]}'`);
-            }
-        }
-        catch (err) {
-            // A member VALUE a JS file cannot lower (a namespace object in an
-            // export aggregate — the sharedWithCli `errors` member): the
-            // member NARROWS AWAY like a CJS export-table accessor entry —
-            // the diagnostics defer to the runtime-fence ledger, the shape
-            // drops the field, and each READ of it meets its own per-site
-            // fence. Pure member forms only (identifier/shorthand reads);
-            // TypeScript, probe mode, and ICEs keep the poison.
-            const pureMember = ts.isShorthandPropertyAssignment(prop) ||
-                (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.initializer));
-            if (!(err instanceof PoisonError) ||
-                !pureMember ||
-                !isJsSourceFile(expr.getSourceFile()) ||
-                lowerer.diagSink !== null ||
-                lowerer.diags.length <= propDiagsBefore ||
-                lowerer.diags.slice(propDiagsBefore).some((d) => d.code === "SC9001")) {
-                throw err;
-            }
-            lowerer.runtimeFences.push(...lowerer.diags.splice(propDiagsBefore));
-            droppedNames.add(name);
-            continue;
-        }
-        if (!fieldType) {
-            // Overflow entry: the value flows into the index signature's value
-            // slot — dyn slots take a dyn conversion (dynFrom), typed slots the
-            // ordinary coercion path. Later duplicates override (map semantics
-            // are last-write-wins already; a duplicate literal key is a tsc
-            // error anyway).
-            const slotted = lowerer.intoIndexValueSlot(value, shape.indexValue, valueNode);
-            fields.push({ name, value: slotted, overflow: true });
-            continue;
-        }
-        const promotedField = fieldType ? lowerer.runtimeOptionalWidening(value.type, fieldType) : null;
-        if (promotedField && fieldType) {
-            type = lowerer.runtimeOptionalRecordField(type, name, promotedField);
-            if (type.kind === "record")
-                shape = lowerer.shapes.get(type.shapeId);
-            fieldTypes.set(name, promotedField);
-            fieldType = promotedField;
-        }
-        value = lowerer.coerceInto(valueNode, value, fieldType); // union-typed fields wrap arm values
-        if (!typeEquals(value.type, fieldType))
-            lowerer.badType(valueNode, lowerer.typeOf(valueNode));
-        // An explicit property overrides a spread-copied field: JS
-        // last-write-wins. The entry moves to the END so explicit property
-        // values keep their source-order evaluation among themselves. A
-        // conditional-spread entry cannot be overridden (its ternary IS the
-        // spread's evaluation; splicing it out would drop that).
-        if (conditionalNames.has(name)) {
-            lowerer.unsupported("SC1090", prop, `'${name}' after a conditional spread of the same name (the desugar keeps one entry per name — restructure so each name has one contributor)`);
-        }
-        const at = fields.findIndex((x) => x.name === name);
-        if (at >= 0)
-            fields.splice(at, 1);
-        fields.push({ name, value });
-    }
-    // Optional fields (undefined-armed union slots) may be omitted: the
-    // absent field holds the interned undefined arm, exactly like writing
-    // `a: undefined` (without exactOptionalPropertyTypes tsc treats the two
-    // the same, and only optional fields may be omitted — tsc rejects
-    // omission of required fields before lowering, undefined-armed or not).
-    // A REQUIRED missing field keeps the shape-mismatch rejection (possible
-    // through `as`: the cast smuggles a narrower literal past freshness).
-    if (droppedNames.size > 0) {
-        const narrowed = shape.fields.filter((f) => !droppedNames.has(f.name));
-        const narrowedId = lowerer.shapes.intern(narrowed.map((f) => ({ name: f.name, type: f.type })), false, shape.indexValue);
-        type = { kind: "record", shapeId: narrowedId };
-        shape = lowerer.shapes.get(narrowedId);
-    }
-    if (fields.filter((f) => !f.overflow).length !== shape.fields.length) {
-        const provided = new Set(fields.filter((f) => !f.overflow).map((f) => f.name));
-        for (const f of shape.fields) {
-            if (provided.has(f.name))
-                continue;
-            // 'unknown' fields complete with the dyn undefined — the absent
-            // property reads as undefined in Node, and a dyn slot holds
-            // exactly that (the options-record call shape against
-            // `{ plugins: unknown, ... }` — a JS caller the checker admits).
-            const absent = lowerer.wrappedUndefined(f.type, loc) ?? (f.type.kind === "dyn" ? dynUndefinedExpr(loc) : null);
-            if (!absent)
-                throw shapeMismatch(expr); // only optional (undefined-armed) and 'unknown' fields may be omitted
-            fields.push({ name: f.name, value: absent });
-        }
-    }
-    return { kind: "recordLit", fields, type, loc };
-}
-/** Parses the conditional-spread idiom `...(c ? { k: v, ... } : {})`
-   * (either orientation). Returns the condition, the non-empty arm's
-   * properties, and which arm carries them; "unsupported" for conditional
-   * sources OUTSIDE the idiom (both arms non-empty, computed/method
-   * members); null when the spread source isn't a conditional at all.
-   * Callers slice their own honest subset (the static record path takes
-   * exactly one property; the island literal takes any number; spawn's
-   * options walk takes a `detached` boolean literal). */
-export function conditionalSpreadOf(expr) {
-    let e = expr;
-    while (ts.isParenthesizedExpression(e))
-        e = e.expression;
-    if (!ts.isConditionalExpression(e))
-        return null;
-    const unwrap = (a) => {
-        let x = a;
-        while (ts.isParenthesizedExpression(x))
-            x = x.expression;
-        return x;
-    };
-    const whenTrue = unwrap(e.whenTrue);
-    const whenFalse = unwrap(e.whenFalse);
-    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
-        return "unsupported";
-    }
-    const trueCarries = whenFalse.properties.length === 0 && whenTrue.properties.length > 0;
-    const falseCarries = whenTrue.properties.length === 0 && whenFalse.properties.length > 0;
-    if (!trueCarries && !falseCarries)
-        return "unsupported"; // both empty is tsc-unreachable; both non-empty has no single desugar
-    const carrier = trueCarries ? whenTrue : whenFalse;
-    const props = [];
-    for (const p of carrier.properties) {
-        if ((ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
-            p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name))) {
-            props.push(p);
-        }
-        else {
-            return "unsupported";
-        }
-    }
-    return { cond: e.condition, props, whenTrue: trueCarries };
-}
-/** `{ ...idx, ...idx2 }` typed a DECLARED shape (no index signature) — the
-   * defaults-merge idiom over runtime-keyed sources (`{ ...fromEntries(a),
-   * ...fromEntries(b) }` typed AppConfig). Lowers to ONE interned helper
-   * call: sources evaluate once each as arguments (source order — computed
-   * sources included, JS's evaluate-once), the result starts all-undefined
-   * (every target field must be optional — the runtime keys decide
-   * presence), and each source's keys apply in JS own-key order with a
-   * per-key dispatch onto the declared fields: a matching key writes the
-   * field — identity when the source's value slot IS the field type, a
-   * validated extraction otherwise (a dyn slot dynChecks; a union slot
-   * re-tags arm-by-arm, and a value outside the field's arms throws the
-   * catchable TypeError — divergence 34's keyed-write stance, where Node's
-   * untyped copy would store the lie) — and a key naming NO declared field
-   * is DROPPED (the shape cannot represent it; Node keeps it invisibly —
-   * divergence 68). Later contributors overwrite earlier ones
-   * (last-write-wins). Sources must be PURE index-signature records. */
-function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
-    const srcs = [];
-    for (const prop of expr.properties) {
-        const spread = prop; // caller-checked: all spreads
-        const value = lowerer.lowerExpr(spread.expression);
-        const srcShape = value.type.kind === "record" ? lowerer.shapes.get(value.type.shapeId) : undefined;
-        if (value.type.kind !== "record" || !srcShape?.indexValue || srcShape.tuple || srcShape.fields.length > 0) {
-            lowerer.unsupported("SC1090", prop, `object spread of '${lowerer.fmt(value.type)}' into '${lowerer.fmt(type)}' (only PURE index-signature records — Object.fromEntries results, Record<string, T> values — spread into a declared shape)`);
-        }
-        srcs.push({ value, shapeId: value.type.shapeId, iv: srcShape.indexValue });
-    }
-    // Every target field must be optional: absent keys leave the undefined
-    // arm, exactly the unset-optional representation.
-    for (const f of shape.fields) {
-        if (f.type.kind !== "union" || lowerer.armTag(f.type.unionId, UNDEFINED_T) < 0) {
-            lowerer.unsupported("SC1090", expr, `object spread of runtime-keyed sources onto the required field '${f.name}' (the keys decide presence at runtime — declare the field optional or spell it explicitly)`);
-        }
-    }
-    // Per (source value slot → field) conversion, checked up front so the
-    // fence fires at the literal, not inside the interned helper.
-    const conv = (iv, f, v) => {
-        if (typeEquals(iv, f.type))
-            return { value: v };
-        if (iv.kind === "dyn") {
-            return { value: { kind: "dynCheck", value: v, type: f.type, loc } };
-        }
-        if (iv.kind === "union" && f.type.kind === "union") {
-            const fUnion = f.type;
-            const def = lowerer.unions.get(iv.unionId);
-            const fDef = lowerer.unions.get(fUnion.unionId);
-            if (def && fDef && def.arms.some((a) => lowerer.armTag(fUnion.unionId, a) >= 0)) {
-                // Arm-by-arm validated re-tag, inline in the helper: matching
-                // arms map by identity (unit arms re-wrap, value arms narrow and
-                // wrap); anything else throws the catchable TypeError.
-                return {
-                    stmts: (write) => {
-                        const chain = (i) => {
-                            if (i >= def.arms.length) {
-                                return [{
-                                        kind: "throw",
-                                        value: {
-                                            kind: "libCall",
-                                            fn: "error.new",
-                                            args: [{ kind: "strLit", value: `expected ${lowerer.fmt(fUnion)} at $.${f.name}`, type: STRING, loc }],
-                                            type: { kind: "object", className: "%TypeError" },
-                                            loc,
-                                        },
-                                        loc,
-                                    }];
-                            }
-                            const arm = def.arms[i];
-                            const toTag = lowerer.armTag(fUnion.unionId, arm);
-                            if (toTag < 0)
-                                return chain(i + 1);
-                            const extracted = isUnitType(arm)
-                                ? { kind: "unionWrap", unionId: fUnion.unionId, tag: toTag, value: { kind: "unitLit", unit: arm.kind === "undefinedT" ? "undefined" : "null", type: arm, loc }, type: fUnion, loc }
-                                : { kind: "unionWrap", unionId: fUnion.unionId, tag: toTag, value: { kind: "unionNarrow", unionId: iv.unionId, tag: i, value: v, type: arm, loc }, type: fUnion, loc };
-                            return [{
-                                    kind: "if",
-                                    cond: { kind: "unionIsTag", unionId: iv.unionId, tag: i, negated: false, value: v, type: BOOL, loc },
-                                    then: [write(extracted)],
-                                    else_: chain(i + 1),
-                                    loc,
-                                }];
-                        };
-                        return chain(0);
-                    },
-                };
-            }
-        }
-        lowerer.unsupported("SC1090", expr, `object spread into '${lowerer.fmt(type)}' where the source's '${lowerer.fmt(iv)}' values cannot reach the '${lowerer.fmt(f.type)}' field '${f.name}' (the value slot must be the field type, 'unknown', or a union covering the field's arms)`);
-    };
-    const key = `declmerge:${type.shapeId}:${srcs.map((s) => s.shapeId).join(",")}`;
-    let helper = lowerer.widthHelpers.get(key);
-    if (!helper) {
-        helper = `%rec.declmerge.${lowerer.widthHelpers.size}`;
-        const outRef = varRef("out.0", type, loc);
-        const ksT = arrayOf(STRING);
-        const locals = [{ id: "out.0", name: "out", type, mutable: false }];
-        const params = srcs.map((s, j) => {
-            locals.push({ id: `s${j}.0`, name: `s${j}`, type: s.value.type, mutable: true });
-            return { localId: `s${j}.0`, name: `s${j}`, type: s.value.type };
-        });
-        const body = [
-            {
-                kind: "varDecl",
-                localId: "out.0",
-                init: {
-                    kind: "recordLit",
-                    fields: shape.fields.map((f) => ({ name: f.name, value: lowerer.wrappedUndefined(f.type, loc) })),
-                    type,
-                    loc,
-                },
-                loc,
-            },
-        ];
-        srcs.forEach((s, j) => {
-            const sRef = varRef(`s${j}.0`, s.value.type, loc);
-            const kRef = varRef(`k${j}.0`, STRING, loc);
-            const vRef = varRef(`v${j}.0`, s.iv, loc);
-            locals.push({ id: `ks${j}.0`, name: `ks${j}`, type: ksT, mutable: false }, { id: `i${j}.0`, name: `i${j}`, type: F64, mutable: true }, { id: `k${j}.0`, name: `k${j}`, type: STRING, mutable: false }, { id: `v${j}.0`, name: `v${j}`, type: s.iv, mutable: false });
-            // Per-key dispatch: if (k === "a") { write a } else if ... else drop.
-            const dispatch = shape.fields.reduceRight((rest, f) => {
-                const write = (value) => ({ kind: "recordSet", obj: outRef, shapeId: type.shapeId, field: f.name, value, loc });
-                const c = conv(s.iv, f, vRef);
-                const thenBody = "value" in c ? [write(c.value)] : c.stmts(write);
-                return [{
-                        kind: "if",
-                        cond: { kind: "strEq", negated: false, left: kRef, right: { kind: "strLit", value: f.name, type: STRING, loc }, type: BOOL, loc },
-                        then: thenBody,
-                        else_: rest.length > 0 ? rest : null,
-                        loc,
-                    }];
-            }, []);
-            body.push({ kind: "varDecl", localId: `ks${j}.0`, init: { kind: "recordOvfKeys", obj: sRef, shapeId: s.shapeId, type: ksT, loc }, loc }, {
-                kind: "for",
-                init: { kind: "varDecl", localId: `i${j}.0`, init: numLit(0, loc), loc },
-                cond: { kind: "bin", op: "<", left: varRef(`i${j}.0`, F64, loc), right: { kind: "arrIntrinsic", method: "length", receiver: varRef(`ks${j}.0`, ksT, loc), args: [], type: F64, loc }, type: BOOL, loc },
-                update: { kind: "assign", localId: `i${j}.0`, value: { kind: "bin", op: "+", left: varRef(`i${j}.0`, F64, loc), right: numLit(1, loc), type: F64, loc }, loc },
-                body: [
-                    { kind: "varDecl", localId: `k${j}.0`, init: { kind: "arrayGet", arr: varRef(`ks${j}.0`, ksT, loc), index: varRef(`i${j}.0`, F64, loc), type: STRING, loc }, loc },
-                    { kind: "varDecl", localId: `v${j}.0`, init: { kind: "recordKeyGet", obj: sRef, shapeId: s.shapeId, key: kRef, overflowOnly: true, type: s.iv, loc }, loc },
-                    ...dispatch,
-                ],
-                loc,
-            });
-        });
-        body.push({ kind: "return", value: outRef, loc });
-        lowerer.liftedFns.push({
-            name: helper,
-            params,
-            returnType: type,
-            locals,
-            body,
-            loc,
-        });
-        // Registered only after a fence-free build: a conv() fence mid-build
-        // must not leave a phantom helper behind for the next literal.
-        lowerer.widthHelpers.set(key, helper);
-    }
-    return { kind: "call", callee: helper, args: srcs.map((s) => s.value), type, loc };
-}
-/** The value of a shorthand property (`{ x }`): the binding `x` refers to.
-   * The property name's own symbol is the PROPERTY, so resolution goes
-   * through getShorthandAssignmentValueSymbol. */
-export function lowerShorthandValue(lowerer, prop) {
-    // 7 types the shorthand's name as PropertyName; it is always an
-    // Identifier (the grammar allows nothing else in shorthand position).
-    const propName = prop.name;
-    const loc = locOf(propName);
-    const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop);
-    if (symbol) {
-        if (lowerer.ctx.selfSymbol === symbol) {
-            return { kind: "selfRef", type: lowerer.ctx.selfType, loc };
-        }
-        const local = lowerer.resolveKey(symbol, propName);
-        if (local) {
-            return lowerer.maybeNarrow({ kind: "varRef", localId: local.id, type: local.type, loc }, propName);
-        }
-        const resolved = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
-        lowerer.flushDeferred(resolved);
-        const g = lowerer.globalsBySymbol.get(resolved);
-        if (g) {
-            return lowerer.maybeNarrow({ kind: "varRef", localId: g.id, type: g.type, loc }, propName);
-        }
-        const sig = lowerer.fnSigsBySymbol.get(resolved);
-        const decl = lowerer.checker.declarationsOf(resolved)[0];
-        if (sig && decl && ts.isFunctionDeclaration(decl) &&
-            (ts.isSourceFile(decl.parent) || lowerer.nsBlocks.get(decl.parent) === "flattened")) {
-            lowerer.noteEdge(sig.name);
-            const funcType = {
-                kind: "func",
-                params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
-                ret: sig.returnType,
-                ...(sig.params.some((p) => p.mode === "dynRest") ? { rest: true } : {}),
-            };
-            lowerer.requireExactArityValue(prop, propName, sig.params, funcType);
-            return { kind: "closure", fnName: sig.name, captures: [], type: funcType, loc };
-        }
-        if (lowerer.genericFnsBySymbol.has(resolved)) {
-            lowerer.unsupported("SC1090", prop, `generic functions as values (call '${propName.text}' directly)`);
-        }
-    }
-    lowerer.rejectUnresolvedSymbol(symbol ? (symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol) : null, propName.text, prop, `the reference to '${propName.text}' (a binding form with no lowering)`);
-}
-/** Rejects any `this` inside an object-literal method body — including in
-   * nested arrows, which inherit the method's `this` (nested function
-   * expressions reset it, but their bare `this` is already a tsc error
-   * under noImplicitThis, so over-rejecting them here changes nothing). */
-export function rejectThisInObjectMethod(lowerer, node) {
-    if (node.kind === ts.SyntaxKind.ThisKeyword) {
-        lowerer.unsupported("SC1090", node, "references to 'this' in object literal methods");
-    }
-    ts.forEachChild(node, (child) => lowerer.rejectThisInObjectMethod(child));
-}
-/** The accessor twin of rejectThisInObjectMethod: a get/set accessor body
-   * referencing `this` (`get x() { return this._x }`). The accessor lowers
-   * as a closure stored IN the record — passing the record as a receiver
-   * would capture the value under construction (an RC cycle), and the
-   * generic lexical-this walk would silently bind an ENCLOSING method's
-   * `this`; the fence names the fix (capture a binding instead). */
-function rejectThisInObjectAccessor(lowerer, node) {
-    if (node.kind === ts.SyntaxKind.ThisKeyword) {
-        lowerer.unsupported("SC1090", node, "references to 'this' in object literal get/set accessors (the accessor lowers as a captured closure with no receiver — read a captured binding instead)");
-    }
-    ts.forEachChild(node, (child) => rejectThisInObjectAccessor(lowerer, child));
-}
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
    * string-key element access (`a["length"]`) and string indexing (`s[0]`
    * typechecks against the lib's index signature; use .charAt) stay out. */
@@ -5868,7 +3808,7 @@ export function lowerElementAccess(lowerer, expr) {
     }
     // `a?.b[i]` — the tail of a chain whose token sits deeper: the whole
     // tail short-circuits with the guard.
-    if (!expr.questionDotToken && chainTailClaimed(lowerer, expr)) {
+    if (!expr.questionDotToken && isOptionalChainTail(lowerer, expr)) {
         return lowerer.lowerOptionalChain(expr);
     }
     // Enum accesses in element clothing — `E["A"]` forward reads and
@@ -5879,6 +3819,9 @@ export function lowerElementAccess(lowerer, expr) {
         if (en)
             return en;
     }
+    const cachedModule = lowerRequireCacheElement(lowerer, expr);
+    if (cachedModule)
+        return cachedModule;
     // Native Web handles use the same supported surface for bracket and dot
     // spellings. Fence a statically-known unsupported key before the generic
     // checked-dynamic element-read path can turn it into a runtime missing
@@ -5975,7 +3918,7 @@ export function lowerElementAccess(lowerer, expr) {
                 ? { kind: "toString", operand: rawKey, type: STRING, loc: rawKey.loc }
                 : null;
         if (key) {
-            const opt = chainGuardedByQuestionDot(expr.expression);
+            const opt = hasOptionalChainGuard(expr.expression);
             return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: recv, type: DYN, loc: locOf(expr) }, expr);
         }
     }
@@ -6089,7 +4032,7 @@ export function lowerElementAccess(lowerer, expr) {
                     ? { kind: "toString", operand: rawKey, type: STRING, loc: rawKey.loc }
                     : null;
             if (key) {
-                const opt = chainGuardedByQuestionDot(expr.expression);
+                const opt = hasOptionalChainGuard(expr.expression);
                 return lowerer.maybeNarrow({ kind: "dynKeyGet", key, ...(opt ? { optional: true } : {}), value: obj, type: DYN, loc: locOf(expr) }, expr);
             }
         }
@@ -6111,6 +4054,17 @@ export function lowerElementAccess(lowerer, expr) {
         const value = lowerer.lowerExpr(expr.expression);
         if (value.type.kind === "union") {
             const key = lowerer.lowerExpr(expr.argumentExpression);
+            if (key.type.kind === "f64") {
+                const def = lowerer.unions.get(value.type.unionId);
+                const presentArms = def?.arms.filter((arm) => !isUnitType(arm)) ?? [];
+                if (presentArms.length === 1 && presentArms[0]?.kind === "string") {
+                    const property = runtimeOptionalElementKey(expr.argumentExpression);
+                    const receiver = property === null ? null : lowerer.runtimeOptionalPropertyReceiver(expr.expression, value, STRING, property);
+                    if (receiver !== null) {
+                        return { kind: "strIntrinsic", method: "charAt", receiver, args: [key], type: STRING, loc: locOf(expr) };
+                    }
+                }
+            }
             if (key.type.kind === "string") {
                 const lit = ts.isStringLiteral(expr.argumentExpression)
                     ? expr.argumentExpression.text
@@ -6392,6 +4346,19 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
     if (key.type.kind !== "string") {
         lowerer.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
     }
+    if (shape.fields.length === 0 && shape.indexValue === undefined) {
+        const result = dynUndefinedExpr(loc);
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "exprStmt", expr: obj, loc },
+                { kind: "exprStmt", expr: key, loc },
+            ],
+            result,
+            type: DYN,
+            loc,
+        };
+    }
     // The DECLARED result type of the access — the index signature's value
     // type (armed with undefined under noUncheckedIndexedAccess), or the
     // declared fields' one common type on signature-free shapes (tsc's
@@ -6483,6 +4450,9 @@ export function lowerAbsenceProbe(lowerer, node) {
     }
     if (!ts.isElementAccessExpression(expr))
         return null;
+    const cachedModule = lowerRequireCacheElement(lowerer, expr);
+    if (cachedModule)
+        return cachedModule;
     const header = lowerer.lowerHttpHeadersElement(expr);
     if (header)
         return header;
@@ -6580,6 +4550,7 @@ function tupleLiteralIndex(node) {
    * assignment, produce no value in our subset). */
 export function lowerElementWrite(lowerer, expr) {
     const target = expr.left;
+    fenceNodeModuleMutation(lowerer, target, "assignment");
     // `process.env[key] = v` — the computed twin of the dotted env write:
     // setenv(3), string keys and string values only.
     if (lowerer.isProcessEnv(target.expression) && !target.questionDotToken) {
@@ -6846,7 +4817,7 @@ export function lowerElementWrite(lowerer, expr) {
     // probes the receiver's own lowered world: a dyn value takes the same
     // write, anything else falls through to the fences.
     if (receiverIr?.kind === "dyn" || receiverIr === null) {
-        const obj = receiverIr !== null ? lowerer.lowerExpr(target.expression) : probeLower(lowerer, target.expression);
+        const obj = receiverIr !== null ? lowerer.lowerExpr(target.expression) : tryLowerExpression(lowerer, target.expression);
         if (obj !== null && obj.type.kind === "dyn") {
             const loc = locOf(expr);
             const litKey = recordKeyLiteralText(target.argumentExpression);
@@ -6904,6 +4875,15 @@ export function lowerElementWrite(lowerer, expr) {
 export function ensureString(lowerer, e, node) {
     if (e.type.kind === "string")
         return e;
+    if (e.type.kind === "bigint") {
+        return {
+            kind: "libCall",
+            fn: "bigint.toString",
+            args: [e, { kind: "numLit", value: 10, type: F64, loc: e.loc }],
+            type: STRING,
+            loc: e.loc,
+        };
+    }
     if (e.type.kind === "dyn") {
         // String(u) / `${u}`: a runtime dispatch over the dyn kind — Node's
         // String() exactly (undefined/null texts, JS number formatting,
@@ -6933,7 +4913,7 @@ export function ensureString(lowerer, e, node) {
         // JS would print "[object Object]" and friends — narrow first.
         const def = lowerer.unions.get(e.type.unionId);
         const stringable = def?.arms.every((a) => a.kind === "undefinedT" || a.kind === "nullT" ||
-            a.kind === "string" || a.kind === "f64" || a.kind === "bool");
+            a.kind === "string" || a.kind === "f64" || a.kind === "bigint" || a.kind === "bool");
         if (stringable) {
             return { kind: "toString", operand: e, type: STRING, loc: e.loc };
         }
@@ -7164,6 +5144,12 @@ export function lowerAsExpression(lowerer, expr) {
         if (target.kind === "bytes" && target.elem === "u8") {
             return { kind: "dynCheck", value: inner, type: target, loc: locOf(expr) };
         }
+        // Class instances round-trip only through compiler-owned typed
+        // references. Plain JSON objects fail the runtime class-brand check;
+        // exact capsules unwrap the original object by identity.
+        if (isDynTypedRefType(target)) {
+            return { kind: "dynCheck", value: inner, type: target, loc: locOf(expr) };
+        }
         // ADAPTABLE function targets (`u as (x: number) => number` — the
         // checked-dynamic function boundary): kind check, then exact unwrap
         // or the per-target adapter shim. Non-adaptable signatures keep the
@@ -7206,6 +5192,9 @@ export function lowerPrefixUnary(lowerer, expr) {
             if (raw.type.kind === "jsval") {
                 return { kind: "jsOp", op: "neg", args: [raw], type: JSVAL, loc };
             }
+            if (raw.type.kind === "bigint") {
+                return { kind: "libCall", fn: "bigint.neg", args: [raw], type: BIGINT_T, loc };
+            }
             const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
@@ -7236,7 +5225,11 @@ export function lowerPrefixUnary(lowerer, expr) {
         }
         case ts.SyntaxKind.TildeToken: {
             // `~x`: ToInt32, complement, back to f64 (JS-exact, incl. NaN → -1).
-            const operand = lowerOptionalNumber(lowerer, lowerer.lowerExpr(expr.operand), loc, expr.operand);
+            const raw = lowerer.lowerExpr(expr.operand);
+            if (raw.type.kind === "bigint") {
+                return { kind: "libCall", fn: "bigint.not", args: [raw], type: BIGINT_T, loc };
+            }
+            const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             return { kind: "unary", op: "~", operand, type: F64, loc };
@@ -7328,10 +5321,46 @@ function seqExprSafeStmt(s) {
             return false;
     }
 }
+/** Run one supported `any` binary operation in the island. Checked-dynamic
+ * operands marshal in only after lowerBinary's identity-preserving native
+ * cases have had their chance (notably dyn strict equality). */
+function lowerAnyBinaryInIsland(lowerer, expr, left, right, loc) {
+    const op = expr.operatorToken.kind;
+    const JS_BIN = {
+        [ts.SyntaxKind.PlusToken]: "add",
+        [ts.SyntaxKind.MinusToken]: "sub",
+        [ts.SyntaxKind.AsteriskToken]: "mul",
+        [ts.SyntaxKind.SlashToken]: "div",
+        [ts.SyntaxKind.PercentToken]: "mod",
+        [ts.SyntaxKind.AsteriskAsteriskToken]: "pow",
+        [ts.SyntaxKind.LessThanToken]: "lt",
+        [ts.SyntaxKind.LessThanEqualsToken]: "le",
+        [ts.SyntaxKind.GreaterThanToken]: "gt",
+        [ts.SyntaxKind.GreaterThanEqualsToken]: "ge",
+        [ts.SyntaxKind.EqualsEqualsEqualsToken]: "eq",
+        [ts.SyntaxKind.ExclamationEqualsEqualsToken]: "neq",
+    };
+    const jop = JS_BIN[op];
+    if (jop === undefined) {
+        lowerer.unsupported("SC1090", expr, `operator '${ts.tokenToString(op) ?? ts.SyntaxKind[op]}' on 'any' values`);
+    }
+    const type = jsOpResultKind(jop) === "bool" ? BOOL : JSVAL;
+    return {
+        kind: "jsOp", op: jop,
+        args: [lowerer.jsvalIn(left, expr.left), lowerer.jsvalIn(right, expr.right)],
+        type, loc,
+    };
+}
 export function lowerBinary(lowerer, expr) {
     const loc = locOf(expr);
     const op = expr.operatorToken.kind;
+    const cacheHas = lowerRequireCacheHas(lowerer, expr);
+    if (cacheHas)
+        return cacheHas;
     if (op === ts.SyntaxKind.EqualsToken || (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment)) {
+        if (ts.isPropertyAccessExpression(expr.left) || ts.isElementAccessExpression(expr.left)) {
+            fenceNodeModuleMutation(lowerer, expr.left, "assignment");
+        }
         // `x = e` in EXPRESSION position (`while ((idx = s.indexOf("\n")) !== -1)`,
         // `f(x = v)`): evaluate e once, write the binding, yield the assigned
         // value — JS evaluation order. Variable targets only (locals and module
@@ -7442,7 +5471,7 @@ export function lowerBinary(lowerer, expr) {
             // RHS value is the expression's value — its OWN type, so the
             // consumer sees exactly what the checker typed.
             if (ts.isPropertyAccessExpression(expr.left) && !expr.left.questionDotToken) {
-                const recv = probeLower(lowerer, expr.left.expression);
+                const recv = tryLowerExpression(lowerer, expr.left.expression);
                 if (recv && recv.type.kind === "dyn") {
                     const recvTmp = lowerer.declareHiddenLocal("%setRecv", DYN);
                     const rhsVal = lowerer.lowerExpr(expr.right);
@@ -7567,8 +5596,74 @@ export function lowerBinary(lowerer, expr) {
             // Everything else (`u && flag`, whose value would need a wider
             // re-tagged union) stays fenced — in CONDITION position those
             // shapes lower through lowerCondition's bool descent instead.
-            const target = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            let target = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            // A broad-JSDoc npm-static body can leave the CHECKER result `any`
+            // even after declaration-backed specialization has recovered both
+            // operands (`helpOption && args.find(...)` in commander). When the
+            // left consists only of always-truthy references and falsy units,
+            // the static result is exactly the right operand plus those units.
+            if (target === null &&
+                lowerer.implicitParamTypes !== null &&
+                npmStaticPackageOfPath(expr.getSourceFile().fileName) !== null &&
+                (lowerer.typeOf(expr).flags & ts.TypeFlags.Any) !== 0 &&
+                left.type.kind === "union") {
+                const leftArms = lowerer.unions.get(left.type.unionId)?.arms;
+                const rightArms = right.type.kind === "union"
+                    ? lowerer.unions.get(right.type.unionId)?.arms
+                    : [right.type];
+                const rightIsStatic = rightArms?.every((arm) => arm.kind !== "dyn" && arm.kind !== "caught" && arm.kind !== "jsval" && arm.kind !== "void") ?? false;
+                if (leftArms && rightArms && rightIsStatic &&
+                    leftArms.some(isUnitType) &&
+                    leftArms.every((arm) => isUnitType(arm) || REF_TRUTHY_KINDS.has(arm.kind))) {
+                    const byKey = new Map();
+                    for (const arm of [...rightArms, ...leftArms.filter(isUnitType)]) {
+                        byKey.set(typeKey(arm), arm);
+                    }
+                    const arms = [...byKey.values()].sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+                    if (arms.length > 1) {
+                        target = { kind: "union", unionId: lowerer.unions.intern(arms) };
+                    }
+                }
+            }
             if (target?.kind === "union") {
+                // `&&` whose left does NOT fit the result union: the checker
+                // built that result by DROPPING left arms which are always
+                // truthy (`Option | undefined && string | undefined` answers
+                // `string | undefined`, not `Option | string | undefined`).
+                // Evaluate the left once, test it in its own union, and retag it
+                // only on the falsy path. Any stranded reference arms are
+                // unreachable there because every JS object is truthy.
+                if (op === ts.SyntaxKind.AmpersandAmpersandToken && left.type.kind === "union" && !typeEquals(left.type, target)) {
+                    const def = lowerer.unions.get(left.type.unionId);
+                    const trappable = new Set();
+                    def?.arms.forEach((arm, tag) => {
+                        if (lowerer.armTag(target.unionId, arm) < 0 && REF_TRUTHY_KINDS.has(arm.kind)) {
+                            trappable.add(tag);
+                        }
+                    });
+                    const retag = trappable.size === 0
+                        ? null
+                        : lowerer.unionRetagHelper(left.type.unionId, target.unionId, loc, trappable);
+                    if (retag) {
+                        lowerer.requireTruthyUnion(left.type.unionId, expr);
+                        const stmts = [];
+                        let stable = left;
+                        if (!isSafeToRepeat(left)) {
+                            const local = lowerer.declareHiddenLocal("%and", left.type);
+                            stmts.push({ kind: "varDecl", localId: local.id, init: left, loc });
+                            stable = varRef(local.id, left.type, loc);
+                        }
+                        const result = {
+                            kind: "ternary",
+                            cond: lowerer.ensureBool(stable, expr.left),
+                            then: lowerer.coerceInto(expr.right, right, target),
+                            else_: { kind: "call", callee: retag, args: [stable], type: target, loc },
+                            type: target,
+                            loc,
+                        };
+                        return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: target, loc };
+                    }
+                }
                 // `||` whose left does NOT fit the result union: the checker built
                 // that result by DROPPING the left's falsy arms (`process.env.X ||
                 // null` is `string | null`, `|| 3000` is `string | number` — the
@@ -7576,9 +5671,7 @@ export function lowerBinary(lowerer, expr) {
                 // the shared shape below does, retags an arm the test is about to
                 // rule out and throws where Node yields the default. Single-eval
                 // instead: test the left in its OWN union and retag only on the
-                // truthy side, where the dropped arms are unreachable. `&&` keeps
-                // the eager shape — there the falsy left IS the result, so the
-                // checker keeps those arms in the target and they must coerce.
+                // truthy side, where the dropped arms are unreachable.
                 if (op === ts.SyntaxKind.BarBarToken && left.type.kind === "union" && !typeEquals(left.type, target)) {
                     const retag = lowerer.unionRetagHelper(left.type.unionId, target.unionId, loc);
                     if (retag) {
@@ -7791,6 +5884,14 @@ export function lowerBinary(lowerer, expr) {
         // retry lifts the site. Genuine unknown keeps the SC1100 story.
         if ((left.type.kind === "dyn" && lowerer.anyOrigin(expr.left)) ||
             (right.type.kind === "dyn" && lowerer.anyOrigin(expr.right))) {
+            // `JSON.parse` and other checked-dynamic producers deliberately
+            // remain dyn when assigned to an `any` local: eagerly converting
+            // the binding would deep-copy its data and sever aliases. At an
+            // operator the dynamic build can cross only the operands and let
+            // the engine apply JS's exact coercion semantics. Static builds
+            // retain the SC2011 promise that --dynamic lifts this site.
+            if (lowerer.dynamic)
+                return lowerAnyBinaryInIsland(lowerer, expr, left, right, loc);
             lowerer.anyOpFence(`the '${ts.tokenToString(op) ?? ts.SyntaxKind[op]}' operator`, expr);
         }
         // tsc allows ===/!== on unknown (arithmetic/comparisons it rejects
@@ -7802,30 +5903,74 @@ export function lowerBinary(lowerer, expr) {
     // computes. Comparisons come back as static bools; arithmetic stays
     // an island value ('1 as any + "x"' is a string over there).
     if (left.type.kind === "jsval" || right.type.kind === "jsval") {
-        const JS_BIN = {
-            [ts.SyntaxKind.PlusToken]: "add",
-            [ts.SyntaxKind.MinusToken]: "sub",
-            [ts.SyntaxKind.AsteriskToken]: "mul",
-            [ts.SyntaxKind.SlashToken]: "div",
-            [ts.SyntaxKind.PercentToken]: "mod",
-            [ts.SyntaxKind.AsteriskAsteriskToken]: "pow",
-            [ts.SyntaxKind.LessThanToken]: "lt",
-            [ts.SyntaxKind.LessThanEqualsToken]: "le",
-            [ts.SyntaxKind.GreaterThanToken]: "gt",
-            [ts.SyntaxKind.GreaterThanEqualsToken]: "ge",
-            [ts.SyntaxKind.EqualsEqualsEqualsToken]: "eq",
-            [ts.SyntaxKind.ExclamationEqualsEqualsToken]: "neq",
+        return lowerAnyBinaryInIsland(lowerer, expr, left, right, loc);
+    }
+    if (left.type.kind === "bigint" && right.type.kind === "bigint") {
+        const binary = {
+            [ts.SyntaxKind.PlusToken]: "bigint.add",
+            [ts.SyntaxKind.MinusToken]: "bigint.sub",
+            [ts.SyntaxKind.AsteriskToken]: "bigint.mul",
+            [ts.SyntaxKind.SlashToken]: "bigint.div",
+            [ts.SyntaxKind.PercentToken]: "bigint.mod",
+            [ts.SyntaxKind.AsteriskAsteriskToken]: "bigint.pow",
+            [ts.SyntaxKind.AmpersandToken]: "bigint.and",
+            [ts.SyntaxKind.BarToken]: "bigint.or",
+            [ts.SyntaxKind.CaretToken]: "bigint.xor",
+            [ts.SyntaxKind.LessThanLessThanToken]: "bigint.shl",
+            [ts.SyntaxKind.GreaterThanGreaterThanToken]: "bigint.shr",
         };
-        const jop = JS_BIN[op];
-        if (jop === undefined) {
-            lowerer.unsupported("SC1090", expr, `operator '${ts.tokenToString(op) ?? ts.SyntaxKind[op]}' on 'any' values`);
+        const fn = binary[op];
+        if (fn)
+            return { kind: "libCall", fn, args: [left, right], type: BIGINT_T, loc };
+        if (op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+            op === ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+            const equal = { kind: "libCall", fn: "bigint.eq", args: [left, right], type: BOOL, loc };
+            return op === ts.SyntaxKind.ExclamationEqualsEqualsToken
+                ? { kind: "unary", op: "!", operand: equal, type: BOOL, loc }
+                : equal;
+        }
+        if (op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken ||
+            op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken) {
+            const cmp = { kind: "libCall", fn: "bigint.cmp", args: [left, right], type: F64, loc };
+            const zero = { kind: "numLit", value: 0, type: F64, loc };
+            const cmpOp = op === ts.SyntaxKind.LessThanToken ? "<"
+                : op === ts.SyntaxKind.LessThanEqualsToken ? "<="
+                    : op === ts.SyntaxKind.GreaterThanToken ? ">" : ">=";
+            return { kind: "bin", op: cmpOp, left: cmp, right: zero, type: BOOL, loc };
+        }
+    }
+    if ((left.type.kind === "bigint" && right.type.kind === "f64") ||
+        (left.type.kind === "f64" && right.type.kind === "bigint")) {
+        if (op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken ||
+            op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken) {
+            const big = left.type.kind === "bigint" ? left : right;
+            const num = left.type.kind === "f64" ? left : right;
+            const cmp = { kind: "libCall", fn: "bigint.cmpNumber", args: [big, num], type: F64, loc };
+            const cmpLocal = lowerer.declareHiddenLocal("%bigcmp", F64);
+            const cmpRef = { kind: "varRef", localId: cmpLocal.id, type: F64, loc };
+            const unordered = {
+                kind: "bin", op: "===", left: cmpRef,
+                right: { kind: "numLit", value: 2, type: F64, loc }, type: BOOL, loc,
+            };
+            const zero = { kind: "numLit", value: 0, type: F64, loc };
+            const leftBig = left.type.kind === "bigint";
+            const cmpOp = leftBig
+                ? op === ts.SyntaxKind.LessThanToken ? "<" : op === ts.SyntaxKind.LessThanEqualsToken ? "<=" : op === ts.SyntaxKind.GreaterThanToken ? ">" : ">="
+                : op === ts.SyntaxKind.LessThanToken ? ">" : op === ts.SyntaxKind.LessThanEqualsToken ? ">=" : op === ts.SyntaxKind.GreaterThanToken ? "<" : "<=";
+            const result = {
+                kind: "logical", op: "&&",
+                left: { kind: "unary", op: "!", operand: unordered, type: BOOL, loc },
+                right: { kind: "bin", op: cmpOp, left: cmpRef, right: zero, type: BOOL, loc },
+                type: BOOL, loc,
+            };
+            return {
+                kind: "seqExpr",
+                stmts: [{ kind: "varDecl", localId: cmpLocal.id, init: cmp, loc }],
+                result,
+                type: BOOL,
+                loc,
+            };
         }
-        const type = jsOpResultKind(jop) === "bool" ? BOOL : JSVAL;
-        return {
-            kind: "jsOp", op: jop,
-            args: [lowerer.jsvalIn(left, expr.left), lowerer.jsvalIn(right, expr.right)],
-            type, loc,
-        };
     }
     // An unchecked array read keeps its undefined arm in the IR even when
     // the checker typed the binding as `string`. An optional string is not
@@ -7860,7 +6005,7 @@ export function lowerBinary(lowerer, expr) {
         // with observable getters/calls.
         const prefix = [];
         const stable = (operand) => {
-            if (pureReemittable(operand) || droppableStatic(operand))
+            if (isSafeToRepeat(operand) || isSafeToDiscard(operand))
                 return operand;
             const tmp = lowerer.declareHiddenLocal("%plus", operand.type);
             prefix.push({ kind: "varDecl", localId: tmp.id, init: operand, loc });
@@ -8340,6 +6485,7 @@ function typeofAnswer(arm) {
         case "undefinedT": return "undefined";
         case "func": return "function";
         case "symbol": return "symbol";
+        case "bigint": return "bigint";
         case "nullT":
         case "array":
         case "map":
@@ -8359,7 +6505,10 @@ function typeofAnswer(arm) {
         case "httpClientReq":
         case "secureCtx":
         case "fsWatcher":
+        case "cryptoHash":
+        case "cryptoHmac":
         case "childStream":
+        case "childWriter":
         case "procStream":
         case "object":
         case "record":
@@ -8518,7 +6667,7 @@ function lowerUnionTypeofTest(lowerer, expr, loc) {
             continue;
         const tags = answers.flatMap((s, i) => (s === b.text ? [i] : []));
         if (tags.length === 0 || tags.length === def.arms.length) {
-            if (!pureReemittable(value)) {
+            if (!isSafeToRepeat(value)) {
                 lowerer.unsupported("SC1090", expr, "statically-decided 'typeof' tests over effectful operands (bind the value to a const first)");
             }
             return { kind: "boolLit", value: (tags.length !== 0) !== negated, type: BOOL, loc };
@@ -8528,7 +6677,7 @@ function lowerUnionTypeofTest(lowerer, expr, loc) {
         });
         if (tags.length === 1)
             return isTag(tags[0]);
-        if (!pureReemittable(value)) {
+        if (!isSafeToRepeat(value)) {
             lowerer.unsupported("SC1090", expr, "'typeof' tests matching several union arms over operands that aren't plain reads (bind the value to a const first)");
         }
         // Tag-in-set as a short-circuit chain (De Morgan for `!==`).
@@ -8583,7 +6732,7 @@ function lowerDynTypeofTest(lowerer, expr, loc) {
                 const recv = unparen(pn.expression);
                 if (ts.isAsExpression(recv) || ts.isTypeAssertion(recv)) {
                     const inner = unparen(recv.expression);
-                    const obj = probeLower(lowerer, inner);
+                    const obj = tryLowerExpression(lowerer, inner);
                     if (obj?.type.kind === "dyn") {
                         keyed = {
                             kind: "dynKeyGet",
@@ -8606,7 +6755,7 @@ function lowerDynTypeofTest(lowerer, expr, loc) {
                 // "string") ... }`, the validateConfig idiom). Probe the lowering
                 // and claim exactly the dyn results; anything else keeps its
                 // sibling lowerings and fences untouched.
-                const probed = probeLower(lowerer, a.expression);
+                const probed = tryLowerExpression(lowerer, a.expression);
                 if (probed?.type.kind !== "dyn")
                     continue;
                 value = probed;
@@ -8770,33 +6919,6 @@ function lowerCjsExportTableThisMember(lowerer, expr) {
         return null;
     return cjsAccessorCall(lowerer, sibling, locOf(expr));
 }
-/** Lowers an expression, converting a fence (PoisonError) into a null
-   * DECLINE — the probing dispatch for shapes where only the lowered
-   * value's type can say whether a lowering applies. unsupported() pushes
-   * its diagnostic BEFORE throwing, so the probe runs behind a diagnostic
-   * sink: a declined probe's diagnostics vanish (the sibling lowerings
-   * own the site), a successful probe's flush through afterwards. */
-export function probeLower(lowerer, node) {
-    const saved = lowerer.diagSink;
-    const captured = [];
-    lowerer.diagSink = captured;
-    let result;
-    try {
-        result = lowerer.lowerExpr(node);
-    }
-    catch (e) {
-        if (e instanceof PoisonError) {
-            lowerer.diagSink = saved;
-            return null;
-        }
-        lowerer.diagSink = saved;
-        throw e;
-    }
-    lowerer.diagSink = saved;
-    for (const d of captured)
-        lowerer.pushDiag(d);
-    return result;
-}
 /** A read of a catch binding — the caught analog of maybeNarrow. Where
    * tsc's control-flow narrowing has proven a supported test (`instanceof`
    * over a hierarchy class, `typeof` over a primitive), the read bridges
@@ -9276,7 +7398,7 @@ function lowerInExpression(lowerer, expr, loc) {
         // stringified like every property key (o[k] is o[String(k)] in JS;
         // `in` shares the coercion).
         {
-            const probed = probeLower(lowerer, expr.right);
+            const probed = tryLowerExpression(lowerer, expr.right);
             if (probed?.type.kind === "dyn") {
                 let k = lowerer.lowerExpr(expr.left); // JS order: the key evaluates first
                 if (k.type.kind === "f64" || k.type.kind === "string" || k.type.kind === "dyn") {
@@ -10106,6 +8228,34 @@ export function lowerUnionProperty(lowerer, expr) {
     if (!def)
         throw new InternalCompilerError(`lowerer bug: unknown union ${value.type.unionId}`);
     const field = expr.name.text;
+    if (field === "length") {
+        const presentArms = def.arms.filter((arm) => !isUnitType(arm));
+        const present = presentArms.length === 1 ? presentArms[0] : null;
+        if (present?.kind === "string" || present?.kind === "array") {
+            const receiver = lowerer.runtimeOptionalPropertyReceiver(expr.expression, value, present, field);
+            if (receiver !== null) {
+                return present.kind === "string"
+                    ? { kind: "strIntrinsic", method: "length", receiver, args: [], type: F64, loc: locOf(expr) }
+                    : { kind: "arrIntrinsic", method: "length", receiver, args: [], type: F64, loc: locOf(expr) };
+            }
+        }
+    }
+    const nonUnitArms = def.arms.filter((arm) => !isUnitType(arm));
+    if (nonUnitArms.length === 1 && nonUnitArms[0]?.kind === "object") {
+        const objectType = nonUnitArms[0];
+        const fieldType = lowerer.classes.get(objectType.className)?.fields.get(field);
+        if (fieldType !== undefined) {
+            let receiver = lowerer.runtimeOptionalPropertyReceiver(expr.expression, value, objectType, field);
+            if (receiver === null) {
+                const helper = lowerer.narrowedArmHelper(value.type.unionId, objectType, locOf(expr.expression));
+                if (helper !== null)
+                    receiver = { kind: "call", callee: helper, args: [value], type: objectType, loc: locOf(expr.expression) };
+            }
+            if (receiver !== null) {
+                return { kind: "fieldGet", obj: receiver, className: objectType.className, field, type: fieldType, loc: locOf(expr) };
+            }
+        }
+    }
     let common = null;
     for (const arm of def.arms) {
         let ft;
@@ -10770,7 +8920,7 @@ export function lowerFieldCompound(lowerer, access, op, rhsNode, loc) {
     // receiver is an identifier (checked above), so evaluating it for
     // read and write matches JS's once-evaluation observably.
     if (ts.isPropertyAccessExpression(access)) {
-        const probed = probeLower(lowerer, access.expression);
+        const probed = tryLowerExpression(lowerer, access.expression);
         if (probed?.type.kind === "dyn") {
             const key = { kind: "strLit", value: access.name.text, type: STRING, loc: locOf(access.name) };
             const read = { kind: "dynKeyGet", key, value: probed, type: DYN, loc };