@scriptc/compiler 0.0.36 → 0.1.2

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

@@ -7,13 +7,15 @@ import { InternalCompilerError } from "../../errors.js";
  * (FieldTarget). */
 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 { 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";
 import { fenceEnumObjectValue, lowerEnumAccess } from "./lower-enums.js";
@@ -27,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
@@ -403,7 +410,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 };
@@ -531,6 +538,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
@@ -576,7 +591,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
@@ -585,7 +600,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)) {
@@ -612,6 +627,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 };
         }
@@ -640,9 +658,13 @@ function lowerExprInner(lowerer, expr) {
             const symbol = lowerer.resolveValueSymbol(expr);
             const runtimeOptionalRoot = lowerer.runtimeOptionalRootOf(local);
             const active = lowerer.runtimeOptionalLocals.has(runtimeOptionalRoot);
+            const arithmetic = lowerer.runtimeOptionalArithmeticLocals.has(runtimeOptionalRoot);
             const captured = !!symbol &&
                 lowerer.runtimeOptionalStorageLocals.has(runtimeOptionalRoot) &&
-                lowerer.ctx.captureBySymbol.get(symbol) === local;
+                (lowerer.ctx.captureBySymbol.get(symbol) === local || runtimeOptionalRoot !== local);
+            if (arithmetic && !runtimeOptionalUseOf(expr)) {
+                return { kind: "varRef", localId: local.id, type: local.type, loc };
+            }
             if (active || captured) {
                 const use = runtimeOptionalUseOf(expr);
                 if (use?.complex) {
@@ -665,8 +687,20 @@ function lowerExprInner(lowerer, expr) {
                     }
                     return runtimeOptionalReceiverRead(lowerer, expr, local, null, loc);
                 }
-                if (active || captured)
-                    return { kind: "varRef", localId: local.id, type: local.type, loc };
+                if (runtimeOptionalObjectWalkerArg(lowerer, expr)) {
+                    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(expr));
+                    if (local.type.kind === "union" && narrowed) {
+                        const helper = narrowed.kind === "union"
+                            ? lowerer.narrowedRetagHelper(expr, local.type.unionId, narrowed.unionId, loc)
+                            : !isUnitType(narrowed)
+                                ? lowerer.narrowedArmHelper(local.type.unionId, narrowed, loc)
+                                : null;
+                        if (helper) {
+                            return { kind: "call", callee: helper, args: [varRef(local.id, local.type, loc)], type: narrowed, loc };
+                        }
+                    }
+                }
+                return { kind: "varRef", localId: local.id, type: local.type, loc };
             }
             return lowerer.maybeNarrow({ kind: "varRef", localId: local.id, type: local.type, loc }, expr);
         }
@@ -686,7 +720,53 @@ function lowerExprInner(lowerer, expr) {
                 lowerer.pushDiag(blockedBindingUseDiag(expr.text, loc));
                 throw new PoisonError();
             }
-            return lowerer.maybeNarrow({ kind: "varRef", localId: g.id, type: g.type, loc }, expr);
+            const ref = { kind: "varRef", localId: g.id, type: g.type, loc };
+            if (lowerer.isRuntimeOptionalArithmeticGlobal(g) && !runtimeOptionalUseOf(expr)) {
+                return ref;
+            }
+            const storageHasUndefined = g.type.kind === "union" &&
+                lowerer.armTag(g.type.unionId, UNDEFINED_T) >= 0;
+            if (lowerer.isRuntimeOptionalGlobal(g) || storageHasUndefined) {
+                // A checker-narrowed global receiver (`if (tags !== undefined)
+                // tags[tags.length] = ...`, or `a ? Object.keys(a) : ...`) is
+                // still stored as the runtime optional union. Extract the proven
+                // value arm before routing the member/element operation so dynamic
+                // keys and builtin record walkers do not see a union receiver.
+                const narrowed = lowerer.mapTypeOf(lowerer.typeOf(expr));
+                const arithmeticUnion = g.type.kind === "union" &&
+                    (lowerer.unions.get(g.type.unionId)?.arms.length === 2) &&
+                    lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "f64") &&
+                    lowerer.unions.get(g.type.unionId).arms.some((a) => a.kind === "string");
+                if (!arithmeticUnion && g.type.kind === "union" && narrowed && narrowed.kind !== "union" &&
+                    !isUnitType(narrowed) &&
+                    narrowed.kind !== "f64" && narrowed.kind !== "string" && narrowed.kind !== "bool" &&
+                    lowerer.armTag(g.type.unionId, narrowed) >= 0) {
+                    const helper = lowerer.narrowedArmHelper(g.type.unionId, narrowed, loc);
+                    if (helper)
+                        return { kind: "call", callee: helper, args: [ref], type: narrowed, loc };
+                }
+                const use = runtimeOptionalUseOf(expr);
+                // The enclosing logical/conditional expression consumes the union
+                // before any member operation runs (`(value ?? fallback).length`).
+                // Keep the tagged value intact and let that lazy expression decide
+                // its branch; extracting here would evaluate or throw too early.
+                if (use?.complex)
+                    return ref;
+                if (use?.optional)
+                    return ref;
+                if (use?.kind === "property")
+                    return runtimeOptionalReceiverRead(lowerer, expr, g, use.access.name.text, loc);
+                if (use?.kind === "element") {
+                    const key = runtimeOptionalElementKey(use.access.argumentExpression);
+                    if (key === null)
+                        lowerer.unsupported("SC1090", use.access, "a computed read from a runtime-optional global (use a literal key)");
+                    return runtimeOptionalReceiverRead(lowerer, expr, g, key, loc);
+                }
+                if (use?.kind === "call")
+                    return runtimeOptionalReceiverRead(lowerer, expr, g, null, loc);
+                return ref;
+            }
+            return lowerer.maybeNarrow(ref, expr);
         }
         // `undefined` — tsc's intrinsic global (a local shadowing the name
         // resolved above): a unit literal, exactly like the `null` keyword.
@@ -709,9 +789,7 @@ function lowerExprInner(lowerer, expr) {
             // directory at `/tmp`. Bake the matching GUEST spelling so resource
             // lookups relative to these CommonJS globals stay inside the exposed
             // capability instead of naming an unreachable host-absolute path.
-            const fileName = lowerer.targetPlatform === "wasi"
-                ? wasiGuestPath(sf.fileName) ?? sf.fileName.replace(/\\/g, "/")
-                : sf.fileName;
+            const fileName = moduleFileName(lowerer, sf);
             const value = expr.text === "__dirname"
                 ? (lowerer.targetPlatform === "wasi" ? posix.dirname(fileName) : dirname(fileName))
                 : fileName;
@@ -1214,8 +1292,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);
     }
@@ -1243,6 +1321,15 @@ function lowerExprInner(lowerer, expr) {
             if (en)
                 return en;
         }
+        // `import.meta.<field>` — the file-backed ESM metadata that survives
+        // compilation as a constant. Only direct, identifier-named reads are
+        // claimed here; the bare meta object, computed access, writes, and
+        // unsupported members continue through the generic module-loader fence
+        // below. The source file is the module identity, so imported modules
+        // receive their own filename/dirname and only the entry receives main.
+        const importMeta = importMetaProperty(lowerer, expr);
+        if (importMeta)
+            return importMeta;
         // `require.main.filename` / `require.main?.filename` — CommonJS
         // entry-module identity: in a compiled binary require.main IS the
         // entry module (never undefined in a CJS graph, so the chain's guard
@@ -1254,6 +1341,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.
@@ -1262,7 +1360,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
@@ -1536,8 +1634,14 @@ function lowerExprInner(lowerer, expr) {
             lowerer.lowerFieldRead(expr);
         // A union-typed field read narrows like an identifier when the
         // checker has narrowed this use to one arm.
-        if (handled)
+        if (handled) {
+            if (handled.type.kind === "union" &&
+                lowerer.armTag(handled.type.unionId, UNDEFINED_T) >= 0 &&
+                handled.kind === "recordGet" &&
+                lowerer.isRuntimeOptionalField(handled.shapeId, handled.field))
+                return handled;
             return lowerer.maybeNarrow(handled, expr);
+        }
         // `globalThis.<name>` that no lowering above claimed
         // (globalThis.crypto, globalThis.SubtleCrypto, globalThis.localStorage
         // — the harness's capability-conditional knownGlobals adds): the
@@ -1585,7 +1689,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);
             }
         }
@@ -1599,7 +1703,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);
@@ -1664,7 +1768,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,
@@ -1724,7 +1828,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 —
@@ -1778,6 +1882,43 @@ function lowerExprInner(lowerer, expr) {
         lowerer.unsupported(entry.code, expr, entry.feature);
     lowerer.unsupported("SC1090", expr, `syntax '${ts.SyntaxKind[expr.kind]}'`);
 }
+function moduleFileName(lowerer, sf) {
+    return lowerer.targetPlatform === "wasi"
+        ? wasiGuestPath(sf.fileName) ?? sf.fileName.replace(/\\/g, "/")
+        : sf.fileName;
+}
+function importMetaProperty(lowerer, expr) {
+    if (expr.questionDotToken !== undefined || !ts.isMetaProperty(expr.expression))
+        return null;
+    const meta = expr.expression;
+    if (meta.keywordToken !== ts.SyntaxKind.ImportKeyword || meta.name.text !== "meta")
+        return null;
+    const sf = expr.getSourceFile();
+    const fileName = moduleFileName(lowerer, sf);
+    switch (expr.name.text) {
+        case "url":
+            return {
+                kind: "strLit",
+                value: pathToFileURL(fileName, { windows: lowerer.targetPlatform === "win32" }).href,
+                type: STRING,
+                loc: locOf(expr),
+            };
+        case "filename":
+            return { kind: "strLit", value: fileName, type: STRING, loc: locOf(expr) };
+        case "dirname":
+            return {
+                kind: "strLit",
+                value: lowerer.targetPlatform === "wasi" ? posix.dirname(fileName) : dirname(fileName),
+                type: STRING,
+                loc: locOf(expr),
+            };
+        case "main":
+            return { kind: "boolLit", value: sf === lowerer.entry, type: BOOL, loc: locOf(expr) };
+        default:
+            lowerer.unsupported("SC1090", expr, `'import.meta.${expr.name.text}' (only url, filename, dirname, and main are supported in static ESM)`);
+            return null;
+    }
+}
 /** `c ? a : b` — see the inline comments. `expected` plays the contextual
    * array type's role when the caller knows the slot's array type and tsc's
    * API doesn't surface it (a ternary as a SPREAD source — lowerArrayLiteral
@@ -2125,19 +2266,65 @@ export function maybeNarrow(lowerer, expr, node) {
  * even though an OOB-safe assignment may have restored undefined. Check
  * that hidden arm and throw the member-read TypeError Node would produce. */
 function runtimeOptionalReceiverRead(lowerer, expr, local, property, loc) {
-    if (local.type.kind !== "union")
-        throw new InternalCompilerError("runtime-optional local is not union-typed");
-    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(expr));
-    if (!narrowed || narrowed.kind === "union" || isUnitType(narrowed)) {
+    if (local.type.kind !== "union") {
+        lowerer.runtimeOptionalLocals.delete(local);
+        lowerer.runtimeOptionalStorageLocals.delete(local);
+        return varRef(local.id, local.type, loc);
+    }
+    // A non-null/type assertion around the receiver carries the useful
+    // checker narrowing on the wrapper rather than on the identifier token
+    // itself (`gg!.day`). Follow only erased wrappers; the member/call node
+    // still receives the checked extraction built below.
+    let narrowedNode = expr;
+    while ((ts.isParenthesizedExpression(narrowedNode.parent) ||
+        ts.isAssertionExpression(narrowedNode.parent) ||
+        ts.isSatisfiesExpression(narrowedNode.parent) ||
+        ts.isNonNullExpression(narrowedNode.parent)) &&
+        narrowedNode.parent.expression === narrowedNode) {
+        narrowedNode = narrowedNode.parent;
+    }
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(narrowedNode));
+    if (!narrowed || isUnitType(narrowed)) {
         lowerer.unsupported("SC1090", expr, "a runtime-optional capture whose narrowed value type is not representable");
     }
+    if (narrowed.kind === "union") {
+        // The checker may keep the receiver at the storage union unchanged
+        // (`string | undefined` on a JS `.match()` call). There is no
+        // sub-union to re-tag: preserve the value for the downstream
+        // nullable-receiver lowering, which performs the member-specific
+        // checked extraction. Refusing here deferred the whole statement to
+        // a runtime fence before that lowering could run.
+        if (typeEquals(local.type, narrowed)) {
+            return varRef(local.id, local.type, loc);
+        }
+        // A captured array element can itself be a union of records (for
+        // example Circle | Square). The optional storage union has one extra
+        // undefined arm; re-tag it to the checker-narrowed value union with a
+        // checked trap for that arm, then let union property lowering inspect
+        // the surviving record arms.
+        const helper = lowerer.narrowedRetagHelper(expr, local.type.unionId, narrowed.unionId, loc);
+        if (!helper) {
+            lowerer.unsupported("SC1090", expr, "a runtime-optional capture whose narrowed union is not representable");
+        }
+        return { kind: "call", callee: helper, args: [varRef(local.id, local.type, loc)], type: narrowed, loc };
+    }
     const valueTag = lowerer.armTag(local.type.unionId, narrowed);
     const undefTag = lowerer.armTag(local.type.unionId, UNDEFINED_T);
     if (valueTag < 0 || undefTag < 0)
         throw new InternalCompilerError("runtime-optional local is missing its value or undefined arm");
     const def = lowerer.unions.get(local.type.unionId);
     if (!def || def.arms.length !== 2) {
-        lowerer.unsupported("SC1090", expr, "a direct read from a runtime-optional capture with multiple value arms");
+        // The checker may narrow a runtime-optional capture to one arm of a
+        // value union (`Circle | Square | undefined` -> `Circle`). The
+        // two-arm fast path below cannot extract that arm safely: a later
+        // array mutation can leave any of the stored tags in the slot. Use
+        // the checked helper so every other arm, including undefined, remains
+        // a catchable TypeError rather than an unchecked payload read.
+        const helper = lowerer.narrowedArmHelper(local.type.unionId, narrowed, loc);
+        if (!helper) {
+            lowerer.unsupported("SC1090", expr, "a direct read from a runtime-optional capture with multiple value arms");
+        }
+        return { kind: "call", callee: helper, args: [varRef(local.id, local.type, loc)], type: narrowed, loc };
     }
     const message = property === null
         ? `${expr.text} is not a function`
@@ -2209,6 +2396,25 @@ function runtimeOptionalUseOf(expr) {
     }
     return null;
 }
+/** Object.keys/Object.entries require an object receiver, but their first
+ * argument is not syntactically a member receiver. Recognize that one
+ * standard-library position so a runtime-optional loop element can be
+ * checked against the checker-narrowed record arm before builtin lowering. */
+function runtimeOptionalObjectWalkerArg(lowerer, expr) {
+    let arg = expr;
+    while ((ts.isParenthesizedExpression(arg.parent) ||
+        ts.isAssertionExpression(arg.parent) ||
+        ts.isSatisfiesExpression(arg.parent) ||
+        ts.isNonNullExpression(arg.parent)) &&
+        arg.parent.expression === arg) {
+        arg = arg.parent;
+    }
+    const call = arg.parent;
+    if (!ts.isCallExpression(call) || call.arguments[0] !== arg || !ts.isPropertyAccessExpression(call.expression))
+        return false;
+    const access = call.expression;
+    return (access.name.text === "keys" || access.name.text === "entries") && lowerer.isStdlibMember(access);
+}
 function runtimeOptionalElementKey(expr) {
     if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr))
         return expr.text;
@@ -2255,7 +2461,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,
@@ -2363,7 +2569,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)`);
         }
@@ -2393,88 +2599,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
@@ -2523,6 +2647,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
@@ -2533,9 +2693,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 };
             }
@@ -2602,383 +2825,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 receiver = lowerer.lowerExpr(recvNode);
-    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
@@ -2988,6 +2834,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) {
@@ -3021,6 +2872,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))
@@ -3153,6 +3045,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     if (kind === "child" ? !isChildSurfaceMember(lowerer, expr) : !tupleLengthOnArray && !lowerer.isStdlibMember(expr))
         return null;
     const name = expr.name.text;
+    const strictReceiver = (expected) => {
+        const value = lowerer.lowerExpr(expr.expression);
+        return lowerer.runtimeOptionalPropertyReceiver(expr.expression, value, expected, name) ?? value;
+    };
     if (kind === "child") {
         const loc = locOf(expr);
         // The lifecycle reads, Node's exact shapes (SEMANTICS.md pins the
@@ -3315,7 +3211,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     }
     if (kind === "regex") {
         if (name === "source" || name === "flags") {
-            const receiver = lowerer.lowerExpr(expr.expression);
+            const receiver = strictReceiver({ kind: "regex" });
             return { kind: "regexIntrinsic", method: name, receiver, args: [], type: STRING, loc: locOf(expr) };
         }
         if (name === "test") {
@@ -3334,7 +3230,19 @@ export function lowerIntrinsicProperty(lowerer, expr) {
     if (kind === "bytes") {
         const loc = locOf(expr);
         if (name === "length" || name === "byteLength") {
-            const receiver = lowerer.lowerExpr(expr.expression);
+            const expected = lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+            let receiver = expected?.kind === "bytes"
+                ? strictReceiver(expected)
+                : lowerer.lowerExpr(expr.expression);
+            if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
+                const present = lowerer.stripUndefinedArm(receiver.type);
+                const helper = present.kind === "bytes"
+                    ? lowerer.narrowedArmHelper(receiver.type.unionId, present, locOf(expr.expression))
+                    : null;
+                receiver = helper
+                    ? { kind: "call", callee: helper, args: [receiver], type: present, loc: locOf(expr.expression) }
+                    : lowerer.maybeNarrow(receiver, expr.expression);
+            }
             // An island handle behind a typed-array .d.ts surface: the engine
             // property read, exiting at the declared number type (the array
             // .length rule). Chain-handled reads stay jsval.
@@ -3387,7 +3295,21 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         return null;
     }
     if (name === "length") {
-        const receiver = lowerer.lowerExpr(expr.expression);
+        const expected = kind === "string"
+            ? STRING
+            : lowerer.mapTypeOf(lowerer.typeOf(expr.expression));
+        let receiver = expected && (expected.kind === "string" || expected.kind === "array")
+            ? strictReceiver(expected)
+            : lowerer.lowerExpr(expr.expression);
+        if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0 && kind === "array") {
+            const present = lowerer.stripUndefinedArm(receiver.type);
+            const helper = present.kind === "array"
+                ? lowerer.narrowedArmHelper(receiver.type.unionId, present, locOf(expr.expression))
+                : null;
+            receiver = helper
+                ? { kind: "call", callee: helper, args: [receiver], type: present, loc: locOf(expr.expression) }
+                : lowerer.maybeNarrow(receiver, expr.expression);
+        }
         // An island handle behind an array-typed .d.ts surface
         // (`parts().length` on a declared `string[]` return — arrays never
         // exit eagerly, so the value stays jsval): an engine property read,
@@ -3516,6 +3438,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
@@ -3598,7 +3541,24 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         lowerer.badType(expr, tsType);
     }
     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
+    // would force boxed union storage and change aliases.
     const spreads = [];
+    const holes = new Set();
+    const runtimeOptionalElements = new Set();
+    let needsStateBuild = false;
+    for (let i = 0; i < expr.elements.length; i++) {
+        const candidate = expr.elements[i];
+        if (ts.isSpreadElement(candidate) || ts.isOmittedExpression(candidate))
+            continue;
+        const probe = tryLowerExpression(lowerer, candidate);
+        if (probe && lowerer.runtimeOptionalWidening(probe.type, type.elem) !== null) {
+            runtimeOptionalElements.add(i);
+            needsStateBuild = true;
+        }
+    }
     const elems = expr.elements.map((el, i) => {
         if (ts.isSpreadElement(el)) {
             // `[...xs, b]`: xs must be an array of the literal's own element
@@ -3664,1807 +3624,166 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
             // (string | symbol)[] literal — per-element wrap/width copy):
             // the interned width helper reshapes before the spread copies.
             if (src.type.kind === "array" && !typeEquals(src.type, type)) {
-                const w = lowerer.widthCoerce(src, type);
-                if (w)
-                    src = w;
-            }
-            if (!typeEquals(src.type, type)) {
-                lowerer.unsupported("SC1090", el, `spreading '${lowerer.fmt(src.type)}' into a '${lowerer.fmt(type)}' literal (only a same-element-type array spreads)`);
-            }
-            spreads.push(i);
-            return src;
-        }
-        // A HOLE (`[,]` — an elision): the slot materializes the undefined
-        // arm — reads, length, and JSON answer exactly Node (JSON.stringify
-        // prints null for holes AND for undefined elements). Iteration
-        // methods do not skip the position the way JS skips holes — the
-        // documented sparse-literal divergence.
-        if (ts.isOmittedExpression(el)) {
-            const hole = type.elem.kind === "union" ? lowerer.wrappedUndefined(type.elem, locOf(el)) : null;
-            if (hole)
-                return hole;
-            lowerer.unsupported("SC1090", el, "holes in array literals of this element type");
-        }
-        // An ARRAY-LITERAL element under a UNION element slot whose own type
-        // has no lift into the slot builds against the union's single array
-        // arm instead (`['pwd', []]` as (string | string[])[] — tsc pushes no
-        // contextual type through the unannotated chain, so the empty nested
-        // literal types never[], whose f64-element representation re-tags
-        // into nothing). One array arm is unambiguous — the union-slot rule's
-        // stance; several keep the fence.
-        if (type.elem.kind === "union" || type.elem.kind === "array") {
-            let x = el;
-            while (ts.isParenthesizedExpression(x))
-                x = x.expression;
-            if (ts.isArrayLiteralExpression(x)) {
-                const ownT = lowerer.mapTypeOf(lowerer.checker.getContextualType(x) ?? lowerer.typeOf(x));
-                if (ownT === null || lowerer.widthLiftPlan(ownT, type.elem) === null) {
-                    // An ARRAY-typed slot takes the literal directly; a union slot
-                    // routes through its single array arm and wraps.
-                    if (type.elem.kind === "array") {
-                        return lowerer.lowerArrayLiteral(x, type.elem);
-                    }
-                    const def = lowerer.unions.get(type.elem.unionId);
-                    const arrayArms = def?.arms.filter((a) => a.kind === "array") ?? [];
-                    if (arrayArms.length === 1) {
-                        const built = lowerer.lowerArrayLiteral(x, arrayArms[0]);
-                        return lowerer.coerceInto(el, built, type.elem);
-                    }
-                }
-            }
-        }
-        // Elements flow into the element slot like an assignment: union
-        // elements wrap plain arm values (`[1, "a"]` as (number | string)[]),
-        // holes reject inside lowerExpr.
-        const lowered = lowerer.lowerExprExpecting(el, type.elem);
-        if (!typeEquals(lowered.type, type.elem))
-            lowerer.badType(el, lowerer.typeOf(el));
-        return lowered;
-    });
-    return { kind: "arrayLit", elems, ...(spreads.length > 0 ? { spreads } : {}), type, 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)");
-    }
-}
-/** 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;
-}
-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]));
-    // 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;
-                }
-                const src = lowerer.lowerExpr(prop.expression);
-                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"
-            ? (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 });
+                const w = lowerer.widthCoerce(src, type);
+                if (w)
+                    src = w;
             }
-            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);
+            if (!typeEquals(src.type, type)) {
+                lowerer.unsupported("SC1090", el, `spreading '${lowerer.fmt(src.type)}' into a '${lowerer.fmt(type)}' literal (only a same-element-type array spreads)`);
             }
-            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;
+            spreads.push(i);
+            return src;
         }
-        const name = propNameText(lowerer, prop.name); // key-form-checked above
-        const 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;
-            }
+        // A HOLE (`[,]` — an elision) remains absent. Ordinary reads still
+        // answer undefined, while presence-sensitive methods and concat keep
+        // the hole. The state-building path below advances length without
+        // writing a value into this slot.
+        if (ts.isOmittedExpression(el)) {
+            needsStateBuild = true;
+            holes.add(i);
+            return { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc: locOf(el) };
         }
-        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 });
+        // An ARRAY-LITERAL element under a UNION element slot whose own type
+        // has no lift into the slot builds against the union's single array
+        // arm instead (`['pwd', []]` as (string | string[])[] — tsc pushes no
+        // contextual type through the unannotated chain, so the empty nested
+        // literal types never[], whose f64-element representation re-tags
+        // into nothing). One array arm is unambiguous — the union-slot rule's
+        // stance; several keep the fence.
+        if (type.elem.kind === "union" || type.elem.kind === "array") {
+            let x = el;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isArrayLiteralExpression(x)) {
+                const ownT = lowerer.mapTypeOf(lowerer.checker.getContextualType(x) ?? lowerer.typeOf(x));
+                if (ownT === null || lowerer.widthLiftPlan(ownT, type.elem) === null) {
+                    // An ARRAY-typed slot takes the literal directly; a union slot
+                    // routes through its single array arm and wraps.
+                    if (type.elem.kind === "array") {
+                        return lowerer.lowerArrayLiteral(x, type.elem);
+                    }
+                    const def = lowerer.unions.get(type.elem.unionId);
+                    const arrayArms = def?.arms.filter((a) => a.kind === "array") ?? [];
+                    if (arrayArms.length === 1) {
+                        const built = lowerer.lowerArrayLiteral(x, arrayArms[0]);
+                        return lowerer.coerceInto(el, built, type.elem);
                     }
                 }
-                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;
-        }
-        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);
+        // Elements flow into the element slot like an assignment: union
+        // elements wrap plain arm values (`[1, "a"]` as (number | string)[]),
+        // holes reject inside lowerExpr.
+        let lowered;
+        const directOptionalCandidate = runtimeOptionalElements.has(i) ||
+            ts.isElementAccessExpression(el) ||
+            (ts.isCallExpression(el) && ts.isPropertyAccessExpression(el.expression) &&
+                (el.expression.name.text === "pop" || el.expression.name.text === "shift"));
+        if (directOptionalCandidate) {
+            const raw = lowerer.lowerExpr(el);
+            if (!typeEquals(raw.type, type.elem)) {
+                needsStateBuild = true;
+                return raw;
+            }
+            lowered = raw;
         }
         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);
-                    },
-                };
-            }
+            lowered = lowerer.lowerExprExpecting(el, type.elem);
         }
-        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,
-                ],
+        if (!typeEquals(lowered.type, type.elem))
+            lowerer.badType(el, lowerer.typeOf(el));
+        return lowered;
+    });
+    if (!needsStateBuild) {
+        return { kind: "arrayLit", elems, ...(spreads.length > 0 ? { spreads } : {}), type, loc };
+    }
+    const out = lowerer.declareHiddenLocal("%arrayLit", type);
+    const outRef = varRef(out.id, type, loc);
+    const body = [
+        { kind: "varDecl", localId: out.id, init: { kind: "arrayLit", elems: [], type, loc }, loc },
+    ];
+    const spreadSet = new Set(spreads);
+    const currentLength = () => ({
+        kind: "arrIntrinsic",
+        method: "length",
+        receiver: outRef,
+        args: [],
+        type: F64,
+        loc,
+    });
+    const nextLength = () => ({
+        kind: "bin",
+        op: "+",
+        left: currentLength(),
+        right: { kind: "numLit", value: 1, type: F64, loc },
+        type: F64,
+        loc,
+    });
+    for (let i = 0; i < elems.length; i++) {
+        const el = elems[i];
+        if (spreadSet.has(i)) {
+            body.push({
+                kind: "exprStmt",
+                expr: { kind: "arrIntrinsic", method: "pushSpread", receiver: outRef, args: [el], type: F64, loc },
                 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);
+            continue;
         }
-        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 (holes.has(i)) {
+            body.push({ kind: "arraySetLength", arr: outRef, length: nextLength(), loc });
+            continue;
         }
-        if (lowerer.genericFnsBySymbol.has(resolved)) {
-            lowerer.unsupported("SC1090", prop, `generic functions as values (call '${propName.text}' directly)`);
+        let value = el;
+        if (!typeEquals(value.type, type.elem)) {
+            const temp = lowerer.declareHiddenLocal("%arrayValue", value.type);
+            body.push({ kind: "varDecl", localId: temp.id, init: value, loc });
+            value = varRef(temp.id, temp.type, loc);
         }
+        body.push(arrayValueStore(lowerer, outRef, currentLength(), value, type.elem, loc));
     }
-    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));
+    return {
+        kind: "seqExpr",
+        stmts: body,
+        result: outRef,
+        type,
+        loc,
+    };
 }
-/** 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));
+/** 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. */
+export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
+    if (operand.type.kind !== "union" || lowerer.armTag(operand.type.unionId, UNDEFINED_T) < 0)
+        return operand;
+    const directNumber = lowerer.stripUndefinedArm(operand.type).kind === "f64";
+    const checkerNumber = narrowedNode !== undefined && lowerer.mapTypeOf(lowerer.typeOf(narrowedNode))?.kind === "f64";
+    if (!directNumber && (!checkerNumber || lowerer.armTag(operand.type.unionId, F64) < 0))
+        return operand;
+    const undefTag = lowerer.armTag(operand.type.unionId, UNDEFINED_T);
+    const valueTag = lowerer.armTag(operand.type.unionId, F64);
+    if (undefTag < 0 || valueTag < 0)
+        return operand;
+    const checked = directNumber ? null : lowerer.narrowedArmHelper(operand.type.unionId, F64, loc);
+    if (!directNumber && !checked)
+        return operand;
+    let stable = operand;
+    let prefix = [];
+    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 }];
+    }
+    const value = {
+        kind: "ternary",
+        cond: { kind: "unionIsTag", unionId: operand.type.unionId, tag: undefTag, negated: false, value: stable, type: BOOL, loc },
+        then: { kind: "bin", op: "/", left: numLit(0, loc), right: numLit(0, loc), type: F64, loc },
+        else_: checked
+            ? { kind: "call", callee: checked, args: [stable], type: F64, loc }
+            : { kind: "unionNarrow", unionId: operand.type.unionId, tag: valueTag, value: stable, type: F64, loc },
+        type: F64,
+        loc,
+    };
+    return prefix.length === 0 ? value : { kind: "seqExpr", stmts: prefix, result: value, type: F64, loc };
 }
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
    * string-key element access (`a["length"]`) and string indexing (`s[0]`
@@ -5477,7 +3796,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
@@ -5488,6 +3807,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
@@ -5584,7 +3906,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);
         }
     }
@@ -5592,7 +3914,16 @@ export function lowerElementAccess(lowerer, expr) {
     // result; any invalid index traps (the array discipline; JS would
     // read undefined — divergence 4's policy).
     if (receiverIr?.kind === "bytes") {
-        const recv = lowerer.lowerExpr(expr.expression);
+        let recv = lowerer.lowerExpr(expr.expression);
+        if (recv.type.kind === "union" && lowerer.armTag(recv.type.unionId, UNDEFINED_T) >= 0) {
+            const present = lowerer.stripUndefinedArm(recv.type);
+            const helper = present.kind === "bytes"
+                ? lowerer.narrowedArmHelper(recv.type.unionId, present, locOf(expr.expression))
+                : null;
+            recv = helper
+                ? { kind: "call", callee: helper, args: [recv], type: present, loc: locOf(expr.expression) }
+                : lowerer.maybeNarrow(recv, expr.expression);
+        }
         // A typed-array .d.ts surface whose VALUE is an island handle
         // (`data()[0]` on a declared Uint8Array return — call results only
         // exit primitives eagerly): the engine element read, exiting at the
@@ -5612,7 +3943,7 @@ export function lowerElementAccess(lowerer, expr) {
     if (receiverIr?.kind === "record") {
         const shape = lowerer.shapes.get(receiverIr.shapeId);
         if (shape?.tuple) {
-            const obj = lowerer.lowerExpr(expr.expression);
+            let obj = lowerer.lowerExpr(expr.expression);
             // A tuple-typed .d.ts surface whose VALUE is an island handle
             // (`pair()[0]` on a declared `[number, string]` return — the
             // anonymous tuple type has no npm symbol, so the checker maps it
@@ -5621,22 +3952,38 @@ export function lowerElementAccess(lowerer, expr) {
             // like the array path.
             if (obj.type.kind === "jsval")
                 return islandElementRead(lowerer, expr, obj);
+            if (obj.type.kind === "union" && lowerer.armTag(obj.type.unionId, UNDEFINED_T) >= 0) {
+                // The checker sees the outer `arrays[i]` as a tuple when
+                // noUncheckedIndexedAccess is disabled, but the lowered read is
+                // still tuple | undefined. A nested tuple field must validate the
+                // outer tag before recordGet; an unchecked unionNarrow would let a
+                // missing outer element reach the record backend as a bad pointer.
+                const present = lowerer.stripUndefinedArm(obj.type);
+                const helper = present.kind === "record"
+                    ? lowerer.narrowedArmHelper(obj.type.unionId, present, locOf(expr.expression))
+                    : null;
+                obj = helper
+                    ? { kind: "call", callee: helper, args: [obj], type: present, loc: locOf(expr.expression) }
+                    : lowerer.maybeNarrow(obj, expr.expression);
+            }
             const idx = tupleLiteralIndex(expr.argumentExpression);
             if (idx === null) {
                 lowerer.unsupported("SC1090", expr.argumentExpression, "tuple indexing with a non-literal index (tuples are fixed-shape — use t[0], t[1], ...)");
             }
-            const fieldType = shape.fields.find((f) => f.name === String(idx))?.type;
+            const shapeId = obj.type.kind === "record" ? obj.type.shapeId : receiverIr.shapeId;
+            const actualShape = lowerer.shapes.get(shapeId) ?? shape;
+            const fieldType = actualShape.fields.find((f) => f.name === String(idx))?.type;
             if (fieldType === undefined)
                 lowerer.badType(expr, lowerer.typeOf(expr)); // OOB smuggled past tsc
             const get = {
                 kind: "recordGet",
                 obj,
-                shapeId: receiverIr.shapeId,
+                shapeId,
                 field: String(idx),
                 type: fieldType,
                 loc: locOf(expr),
             };
-            return lowerer.maybeNarrow(get, expr);
+            return lowerer.isRuntimeOptionalField(shapeId, String(idx)) ? get : lowerer.maybeNarrow(get, expr);
         }
         if (shape && !shape.tuple) {
             // A record-typed .d.ts surface whose VALUE is an island handle
@@ -5673,7 +4020,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);
             }
         }
@@ -5695,6 +4042,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
@@ -5751,6 +4109,65 @@ export function lowerElementAccess(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, "element access on non-array values");
     }
     let arr = lowerer.lowerExpr(expr.expression);
+    const runtimeOptionalSource = lowerer.runtimeOptionalSourceValue(expr.expression, arr);
+    if (runtimeOptionalSource?.kind === "varRef" &&
+        runtimeOptionalSource.type.kind === "union" &&
+        arr.type.kind === "array") {
+        // lowerer.lowerElementAccess has already recognized a captured
+        // array | undefined receiver and supplied its checked extraction as
+        // the expression override. Rebuild that check here so a missing
+        // receiver throws the member-access error Node exposes, rather than
+        // the generic target-union narrowing error. The stored receiver is a
+        // varRef, so both the tag test and extraction read the same value
+        // without repeating an effect.
+        const stored = runtimeOptionalSource;
+        if (stored.type.kind !== "union")
+            throw new InternalCompilerError("runtime-optional array source lost its union storage");
+        const unionId = stored.type.unionId;
+        const undefTag = lowerer.armTag(unionId, UNDEFINED_T);
+        const valueTag = lowerer.armTag(unionId, arr.type);
+        const property = runtimeOptionalElementKey(expr.argumentExpression);
+        if (undefTag >= 0 && valueTag >= 0 && property !== null) {
+            arr = {
+                kind: "ternary",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId,
+                    tag: undefTag,
+                    negated: false,
+                    value: stored,
+                    type: BOOL,
+                    loc: locOf(expr.expression),
+                },
+                then: nodeThrowExpr(1, "", `Cannot read properties of undefined (reading '${property}')`, arr.type, locOf(expr.expression)),
+                else_: {
+                    kind: "unionNarrow",
+                    unionId,
+                    tag: valueTag,
+                    value: stored,
+                    type: arr.type,
+                    loc: locOf(expr.expression),
+                },
+                type: arr.type,
+                loc: locOf(expr.expression),
+            };
+        }
+    }
+    if (arr.type.kind === "union" &&
+        lowerer.armTag(arr.type.unionId, UNDEFINED_T) >= 0 &&
+        receiverIr.kind === "array") {
+        // As with tuple receivers above, an unchecked outer read can be
+        // undefined even when the checker reports an array. Extract the
+        // present array arm with a runtime tag check before arrayGet or the
+        // safe indexed-read helper runs.
+        const present = lowerer.stripUndefinedArm(arr.type);
+        const helper = present.kind === "array"
+            ? lowerer.narrowedArmHelper(arr.type.unionId, present, locOf(expr.expression))
+            : null;
+        arr = helper
+            ? { kind: "call", callee: helper, args: [arr], type: present, loc: locOf(expr.expression) }
+            : lowerer.maybeNarrow(arr, expr.expression);
+    }
     // The checker sees an array but the VALUE is an island handle (an
     // array-typed .d.ts surface: `parts()[0]` on a declared `string[]`
     // return, `issue.path[0]` on a declared member — arrays never exit
@@ -5782,12 +4199,22 @@ export function lowerElementAccess(lowerer, expr) {
     // signature where the .d.ts says Function[], which would flatten the
     // element to a zero-parameter closure).
     const elemT = arr.type.kind === "array" ? arr.type.elem : receiverIr.elem;
-    // OOB-SAFE reads over fresh/probe array results. These expressions are
-    // commonly used to ask for a first/last match (`filter(...).sort(...)[0]`,
-    // `slice(-1)[0]`); an empty result is ordinary undefined, not a bounds
-    // failure. Downstream lowering keeps the explicit optional union, so an
-    // unchecked consumer still cannot place it into a plain element slot.
-    if (arr.type.kind === "array" && isFreshArrayProbe(expr.expression)) {
+    // Every ordinary array read is a JavaScript property read: an invalid
+    // index answers undefined, even when the checker was built without
+    // noUncheckedIndexedAccess. Keep the explicit optional union in the IR
+    // so it can flow through templates, locals, calls, returns, operators,
+    // and narrowing. The helper performs one length/proof check and then
+    // uses the dense getter for the proven-present path, so this does not
+    // change the storage representation or the low-level getter itself.
+    if (arr.type.kind === "array") {
+        // A non-null assertion is the explicit proven-present form. Preserve
+        // the dense getter's established bounds trap here; turning `xs[i]!`
+        // into an optional union would change library ABI checks and the
+        // existing catchable RangeError contract for an out-of-bounds assert.
+        const provenPresent = ts.isNonNullExpression(expr.parent) && expr.parent.expression === expr;
+        if (provenPresent) {
+            return lowerer.maybeNarrow({ kind: "arrayGet", arr, index, type: elemT, loc: locOf(expr) }, expr);
+        }
         const safe = lowerSafeIndexRead(lowerer, arr, index, locOf(expr));
         if (safe)
             return safe;
@@ -5807,16 +4234,6 @@ export function lowerElementAccess(lowerer, expr) {
     // narrows literal-index element accesses).
     return lowerer.maybeNarrow({ kind: "arrayGet", arr, index, type: elemT, loc: locOf(expr) }, expr);
 }
-function isFreshArrayProbe(node) {
-    let current = node;
-    while (ts.isParenthesizedExpression(current))
-        current = current.expression;
-    return (ts.isCallExpression(current) &&
-        ts.isPropertyAccessExpression(current.expression) &&
-        (current.expression.name.text === "filter" ||
-            current.expression.name.text === "slice" ||
-            current.expression.name.text === "sort"));
-}
 /** `o[k]` where the RECEIVER is an island value — a jsval-mapped checker
    * type, or an array/tuple-typed .d.ts surface whose lowered value is a
    * handle. The key marshals in (any JS key kind — the engine does its
@@ -5883,8 +4300,7 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
         // Number AND checked-dynamic keys ride the JS-exact formatter —
         // property keys ARE strings (o[k] is o[String(k)] in JS), and a dyn
         // key (agent.sockets[agent.getName(...)]) stringifies the same way.
-        if (dk.type.kind === "f64" || dk.type.kind === "dyn")
-            dk = lowerer.ensureString(dk, keyNode);
+        dk = lowerRecordPropertyKey(lowerer, dk, keyNode);
         if (dk.type.kind !== "string") {
             lowerer.unsupported("SC1090", keyNode, "indexing records with non-string or non-number keys");
         }
@@ -5914,11 +4330,23 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
         : lowerer.lowerExpr(keyNode);
     // Runtime NUMBER keys ride the JS-exact formatter (o[n] is o[String(n)]
     // in JS — the number-keyed-signature access path).
-    if (key.type.kind === "f64")
-        key = lowerer.ensureString(key, keyNode);
+    key = lowerRecordPropertyKey(lowerer, key, keyNode);
     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
@@ -5958,6 +4386,16 @@ export function lowerRecordKeyRead(lowerer, expr, shapeId, shape, includeUndefin
     };
     return includeUndefined ? read : lowerer.maybeNarrow(read, expr);
 }
+/** ToPropertyKey for represented record keys. Missing array-derived string
+ * values remain real undefined values, whose JavaScript property spelling
+ * is the string "undefined". */
+function lowerRecordPropertyKey(lowerer, key, node) {
+    if (key.type.kind === "f64" || key.type.kind === "bool" || key.type.kind === "dyn" ||
+        lowerer.runtimeOptionalWidening(key.type, STRING) !== null) {
+        return lowerer.ensureString(key, node);
+    }
+    return key;
+}
 /** A keyed read used only to observe absence (`if (map[k])`, or the left
  * side of `||`/`??`). JavaScript answers undefined for missing record keys
  * and array indices even when noUncheckedIndexedAccess is disabled. Keep
@@ -6000,6 +4438,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;
@@ -6097,6 +4538,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) {
@@ -6229,8 +4671,7 @@ export function lowerElementWrite(lowerer, expr) {
                 let key = litKey !== null
                     ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(target.argumentExpression) }
                     : lowerer.lowerExpr(target.argumentExpression);
-                if (key.type.kind === "f64")
-                    key = lowerer.ensureString(key, target.argumentExpression);
+                key = lowerRecordPropertyKey(lowerer, key, target.argumentExpression);
                 if (key.type.kind !== "string") {
                     lowerer.unsupported("SC1090", target.argumentExpression, "indexing records with non-string or non-number keys");
                 }
@@ -6308,11 +4749,7 @@ export function lowerElementWrite(lowerer, expr) {
                     : lowerer.lowerExpr(target.argumentExpression);
                 // Runtime number/boolean/dyn keys stringify — ToPropertyKey,
                 // exactly the index-signature path's rule.
-                if (key.type.kind === "f64")
-                    key = lowerer.ensureString(key, target.argumentExpression);
-                if (key.type.kind === "bool" || key.type.kind === "dyn") {
-                    key = { kind: "toString", operand: key, type: STRING, loc: locOf(target.argumentExpression) };
-                }
+                key = lowerRecordPropertyKey(lowerer, key, target.argumentExpression);
                 if (key.type.kind !== "string") {
                     lowerer.unsupported("SC1090", target.argumentExpression, "indexing records with non-string or non-number keys");
                 }
@@ -6341,8 +4778,7 @@ export function lowerElementWrite(lowerer, expr) {
                 : lowerer.lowerExpr(target.argumentExpression);
             // Runtime NUMBER keys canonicalize through the JS-exact formatter
             // (o[n] = v writes o[String(n)] — the number-keyed-signature path).
-            if (key.type.kind === "f64")
-                key = lowerer.ensureString(key, target.argumentExpression);
+            key = lowerRecordPropertyKey(lowerer, key, target.argumentExpression);
             if (key.type.kind !== "string") {
                 lowerer.unsupported("SC1090", target.argumentExpression, "indexing records with non-string or non-number keys");
             }
@@ -6369,18 +4805,14 @@ 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);
             let key = litKey !== null
                 ? { kind: "strLit", value: litKey, type: STRING, loc: locOf(target.argumentExpression) }
                 : lowerer.lowerExpr(target.argumentExpression);
-            if (key.type.kind === "f64")
-                key = lowerer.ensureString(key, target.argumentExpression);
-            if (key.type.kind === "bool" || key.type.kind === "dyn") {
-                key = { kind: "toString", operand: key, type: STRING, loc: locOf(target.argumentExpression) };
-            }
+            key = lowerRecordPropertyKey(lowerer, key, target.argumentExpression);
             if (key.type.kind !== "string") {
                 lowerer.unsupported("SC1090", target.argumentExpression, "indexing checked-dynamic values with non-string or non-number keys");
             }
@@ -6394,7 +4826,7 @@ export function lowerElementWrite(lowerer, expr) {
     if (receiverIr?.kind !== "array") {
         lowerer.unsupported("SC1090", target, "assignment to non-array elements");
     }
-    const arr = lowerer.lowerExpr(target.expression);
+    let arr = lowerer.lowerExpr(target.expression);
     // The write twin of the island element read: an array-typed .d.ts
     // surface whose VALUE is a handle takes the engine keyed write, never
     // a static arraySet over a jsval.
@@ -6404,17 +4836,29 @@ export function lowerElementWrite(lowerer, expr) {
         const loc = locOf(expr);
         return { kind: "exprStmt", expr: { kind: "jsOp", op: "setIdx", args: [arr, key, value], type: VOID, loc }, loc };
     }
+    if (arr.type.kind === "union" &&
+        lowerer.armTag(arr.type.unionId, UNDEFINED_T) >= 0 &&
+        receiverIr.kind === "array") {
+        const present = lowerer.stripUndefinedArm(arr.type);
+        const helper = present.kind === "array"
+            ? lowerer.narrowedArmHelper(arr.type.unionId, present, locOf(target.expression))
+            : null;
+        if (helper) {
+            arr = { kind: "call", callee: helper, args: [arr], type: present, loc: locOf(target.expression) };
+        }
+    }
+    if (arr.type.kind !== "array") {
+        lowerer.unsupported("SC1090", target.expression, "assignment through a possibly missing nested array receiver");
+    }
     const index = lowerer.lowerExpr(target.argumentExpression);
     if (index.type.kind !== "f64") {
         lowerer.unsupported("SC1090", target.argumentExpression, "indexing with non-number keys");
     }
-    // The value flows into the element slot like an assignment: union
-    // elements wrap plain arm values.
-    const value = lowerer.lowerExprExpecting(expr.right, receiverIr.elem);
-    if (!typeEquals(value.type, receiverIr.elem)) {
-        lowerer.badType(expr.right, lowerer.typeOf(expr.right));
-    }
-    return { kind: "arraySet", arr, index, value, loc: locOf(expr) };
+    // Optional array reads carry the source array's payload type plus an
+    // undefined arm. arrayValueStore turns that arm into the runtime's
+    // UNDEFINED state while keeping number[]/string[] payload storage scalar.
+    const value = lowerer.lowerExpr(expr.right);
+    return arrayValueStore(lowerer, arr, index, value, receiverIr.elem, locOf(expr));
 }
 export function ensureString(lowerer, e, node) {
     if (e.type.kind === "string")
@@ -6679,6 +5123,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
@@ -6717,10 +5167,11 @@ export function lowerPrefixUnary(lowerer, expr) {
     const loc = locOf(expr);
     switch (expr.operator) {
         case ts.SyntaxKind.MinusToken: {
-            const operand = lowerer.lowerExpr(expr.operand);
-            if (operand.type.kind === "jsval") {
-                return { kind: "jsOp", op: "neg", args: [operand], type: JSVAL, loc };
+            const raw = lowerer.lowerExpr(expr.operand);
+            if (raw.type.kind === "jsval") {
+                return { kind: "jsOp", op: "neg", args: [raw], type: JSVAL, loc };
             }
+            const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             if (operand.kind === "numLit")
@@ -6728,16 +5179,17 @@ export function lowerPrefixUnary(lowerer, expr) {
             return { kind: "unary", op: "-", operand, type: F64, loc };
         }
         case ts.SyntaxKind.PlusToken: {
-            const operand = lowerer.lowerExpr(expr.operand);
+            const raw = lowerer.lowerExpr(expr.operand);
             // Unary + is ToNumber; on an already-number operand it's identity,
             // and a STRING operand runs the runtime's ECMA-exact StringToNumber
             // (num.fromString — Number(aString)'s lowering, scr_string.c).
-            if (operand.type.kind === "jsval") {
-                return { kind: "jsOp", op: "plus", args: [operand], type: JSVAL, loc };
+            if (raw.type.kind === "jsval") {
+                return { kind: "jsOp", op: "plus", args: [raw], type: JSVAL, loc };
             }
-            if (operand.type.kind === "string") {
-                return { kind: "libCall", fn: "num.fromString", args: [operand], type: F64, loc };
+            if (raw.type.kind === "string") {
+                return { kind: "libCall", fn: "num.fromString", args: [raw], type: F64, loc };
             }
+            const operand = lowerOptionalNumber(lowerer, raw, loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             return operand;
@@ -6749,7 +5201,7 @@ export function lowerPrefixUnary(lowerer, expr) {
         }
         case ts.SyntaxKind.TildeToken: {
             // `~x`: ToInt32, complement, back to f64 (JS-exact, incl. NaN → -1).
-            const operand = lowerer.lowerExpr(expr.operand);
+            const operand = lowerOptionalNumber(lowerer, lowerer.lowerExpr(expr.operand), loc, expr.operand);
             if (operand.type.kind !== "f64")
                 lowerer.unsupported("SC1043", expr);
             return { kind: "unary", op: "~", operand, type: F64, loc };
@@ -6815,9 +5267,9 @@ function lowerIncDec(lowerer, expr, prefix) {
         lowerer.unsupported("SC1043", expr);
     return { kind: "incDec", op, prefix, localId: target.id, type: F64, loc };
 }
-/** Whether a lowered statement can live inside a seqExpr — the
- * validator's straight-line set (writes and effect expressions only; the
- * C emission point is mid-expression, so no control flow, no jumps).
+/** Whether a lowered statement can live inside a seqExpr. These statements
+ * do not leave the expression through a jump; the native emitters can place
+ * their writes and local state branches before evaluating the final result.
  * Blocks check their bodies recursively. */
 function seqExprSafeStmt(s) {
     switch (s.kind) {
@@ -6828,18 +5280,59 @@ function seqExprSafeStmt(s) {
         case "recordSet":
         case "recordKeySet":
         case "arraySet":
+        case "arraySetLength":
         case "bytesSet":
+        case "arraySetUndefined":
+        case "arrayDelete":
             return true;
+        case "if":
+            return s.then.every(seqExprSafeStmt) && (s.else_?.every(seqExprSafeStmt) ?? true);
         case "block":
             return s.body.every(seqExprSafeStmt);
         default:
             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
@@ -6950,7 +5443,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);
@@ -7075,8 +5568,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
@@ -7084,9 +5643,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) {
@@ -7299,6 +5856,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
@@ -7310,37 +5875,120 @@ 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);
+    }
+    // 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
+    // itself a string operand for `+`: `undefined + 1` and
+    // `undefined + undefined` are NaN, while a present string concatenates.
+    // Keep this predicate exact so a nullable string does not silently take
+    // the string path either.
+    const optionalStringType = (type) => {
+        if (type.kind !== "union")
+            return false;
+        const arms = lowerer.unions.get(type.unionId)?.arms;
+        return !!arms && arms.length === 2 &&
+            arms.some((arm) => arm.kind === "string") &&
+            arms.some((arm) => arm.kind === "undefinedT");
+    };
+    const arithmeticNumber = (operand, node) => lowerOptionalNumber(lowerer, operand, loc, node);
+    const arithmeticLeft = strictEquality ? left : arithmeticNumber(left, expr.left);
+    const arithmeticRight = strictEquality ? right : arithmeticNumber(right, expr.right);
+    const plainBothNum = left.type.kind === "f64" && right.type.kind === "f64";
+    const bothNum = arithmeticLeft.type.kind === "f64" && arithmeticRight.type.kind === "f64";
+    const bothStr = left.type.kind === "string" && right.type.kind === "string";
+    const lowerOptionalStringPlus = () => {
+        const leftOptional = optionalStringType(left.type);
+        const rightOptional = optionalStringType(right.type);
+        if (!leftOptional && !rightOptional)
+            return null;
+        const allowed = (type) => type.kind === "f64" || type.kind === "string" || optionalStringType(type);
+        if (!allowed(left.type) || !allowed(right.type))
+            return null;
+        // The tag tests and the chosen concatenation branch must see the same
+        // operand values. This matters for `take()[0] + 1` and for two reads
+        // with observable getters/calls.
+        const prefix = [];
+        const stable = (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 });
+            return varRef(tmp.id, operand.type, loc);
         };
-        const jop = JS_BIN[op];
-        if (jop === undefined) {
-            lowerer.unsupported("SC1090", expr, `operator '${ts.tokenToString(op) ?? ts.SyntaxKind[op]}' on 'any' values`);
+        const stableLeft = stable(left);
+        const stableRight = stable(right);
+        const leftString = lowerer.ensureString(stableLeft, expr.left);
+        const rightString = lowerer.ensureString(stableRight, expr.right);
+        const concat = { kind: "strConcat", left: leftString, right: rightString, type: STRING, loc };
+        const nan = { kind: "bin", op: "/", left: numLit(0, loc), right: numLit(0, loc), type: F64, loc };
+        const resultT = { kind: "union", unionId: lowerer.unions.intern([F64, STRING]) };
+        lowerer.runtimeOptionalArithmeticTypes.set(expr, resultT);
+        const numberTag = lowerer.armTag(resultT.unionId, F64);
+        const stringTag = lowerer.armTag(resultT.unionId, STRING);
+        if (numberTag < 0 || stringTag < 0)
+            throw new InternalCompilerError("lowerer bug: optional string plus result union");
+        const number = () => ({
+            kind: "unionWrap", unionId: resultT.unionId, tag: numberTag, value: nan, type: resultT, loc,
+        });
+        const string = () => ({
+            kind: "unionWrap", unionId: resultT.unionId, tag: stringTag, value: concat, type: resultT, loc,
+        });
+        const undefinedTest = (operand) => ({
+            kind: "unionIsTag",
+            unionId: operand.type.kind === "union" ? operand.type.unionId : "",
+            tag: operand.type.kind === "union" ? lowerer.armTag(operand.type.unionId, UNDEFINED_T) : -1,
+            negated: false,
+            value: operand,
+            type: BOOL,
+            loc,
+        });
+        let result;
+        if (leftOptional && rightOptional) {
+            const rightMissing = undefinedTest(stableRight);
+            const bothMissing = {
+                kind: "ternary",
+                cond: rightMissing,
+                then: number(),
+                else_: string(),
+                type: resultT,
+                loc,
+            };
+            result = {
+                kind: "ternary",
+                cond: undefinedTest(stableLeft),
+                then: bothMissing,
+                else_: string(),
+                type: resultT,
+                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,
-        };
-    }
-    const bothNum = left.type.kind === "f64" && right.type.kind === "f64";
-    const bothStr = left.type.kind === "string" && right.type.kind === "string";
+        else if (leftOptional) {
+            result = {
+                kind: "ternary",
+                cond: undefinedTest(stableLeft),
+                then: number(),
+                else_: string(),
+                type: resultT,
+                loc,
+            };
+        }
+        else {
+            result = {
+                kind: "ternary",
+                cond: undefinedTest(stableRight),
+                then: number(),
+                else_: string(),
+                type: resultT,
+                loc,
+            };
+        }
+        return prefix.length === 0 ? result : { kind: "seqExpr", stmts: prefix, result, type: resultT, loc };
+    };
     switch (op) {
         case ts.SyntaxKind.PlusToken:
             if (bothNum)
-                return { kind: "bin", op: "+", left, right, type: F64, loc };
+                return { kind: "bin", op: "+", left: arithmeticLeft, right: arithmeticRight, type: F64, loc };
             if (left.type.kind === "string" || right.type.kind === "string") {
                 return {
                     kind: "strConcat",
@@ -7349,6 +5997,9 @@ export function lowerBinary(lowerer, expr) {
                     type: STRING, loc,
                 };
             }
+            const optionalStringPlus = lowerOptionalStringPlus();
+            if (optionalStringPlus)
+                return optionalStringPlus;
             lowerer.unsupported("SC1043", expr);
             break;
         case ts.SyntaxKind.MinusToken:
@@ -7362,7 +6013,7 @@ export function lowerBinary(lowerer, expr) {
                 : op === ts.SyntaxKind.AsteriskToken ? "*"
                     : op === ts.SyntaxKind.SlashToken ? "/"
                         : op === ts.SyntaxKind.PercentToken ? "%" : "**";
-            return { kind: "bin", op: binOp, left, right, type: F64, loc };
+            return { kind: "bin", op: binOp, left: arithmeticLeft, right: arithmeticRight, type: F64, loc };
         }
         // The bitwise six, JS-exact: operands through ToInt32/ToUint32
         // (NaN/±Infinity → 0, truncate, wrap mod 2^32), the operation in
@@ -7381,12 +6032,12 @@ export function lowerBinary(lowerer, expr) {
                     : op === ts.SyntaxKind.CaretToken ? "^"
                         : op === ts.SyntaxKind.LessThanLessThanToken ? "<<"
                             : op === ts.SyntaxKind.GreaterThanGreaterThanToken ? ">>" : ">>>";
-            return { kind: "bin", op: bitOp, left, right, type: F64, loc };
+            return { kind: "bin", op: bitOp, left: arithmeticLeft, right: arithmeticRight, type: F64, loc };
         }
         case ts.SyntaxKind.EqualsEqualsEqualsToken:
         case ts.SyntaxKind.ExclamationEqualsEqualsToken: {
             const negated = op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
-            if (bothNum)
+            if (plainBothNum)
                 return { kind: "bin", op: negated ? "!==" : "===", left, right, type: BOOL, loc };
             if (bothStr)
                 return { kind: "strEq", negated, left, right, type: BOOL, loc };
@@ -7445,6 +6096,38 @@ export function lowerBinary(lowerer, expr) {
                         loc,
                     };
                 }
+                if (left.type.kind === "union" && right.type.kind === "union") {
+                    const leftDef = lowerer.unions.get(left.type.unionId);
+                    const rightDef = lowerer.unions.get(right.type.unionId);
+                    if (leftDef && rightDef) {
+                        const leftValues = leftDef.arms.filter((arm) => !isUnitType(arm));
+                        const rightValues = rightDef.arms.filter((arm) => !isUnitType(arm));
+                        const sameValueArms = leftValues.length === rightValues.length &&
+                            leftValues.every((arm) => rightValues.some((candidate) => typeEquals(candidate, arm)));
+                        if (sameValueArms) {
+                            const arms = [...leftDef.arms];
+                            for (const arm of rightDef.arms) {
+                                if (!arms.some((candidate) => typeEquals(candidate, arm)))
+                                    arms.push(arm);
+                            }
+                            arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+                            const common = {
+                                kind: "union",
+                                unionId: lowerer.unions.intern(arms),
+                            };
+                            return {
+                                kind: "unionEq",
+                                unionId: common.unionId,
+                                negated,
+                                sameValue: false,
+                                left: lowerer.coerceInto(expr.left, left, common),
+                                right: lowerer.coerceInto(expr.right, right, common),
+                                type: BOOL,
+                                loc,
+                            };
+                        }
+                    }
+                }
                 lowerer.unsupported("SC1090", expr, `comparisons of union-typed values (${NARROW_FIRST})`);
             }
             // Arrays, maps, functions, class instances and records compare by
@@ -7509,7 +6192,7 @@ export function lowerBinary(lowerer, expr) {
                 : op === ts.SyntaxKind.LessThanEqualsToken ? "<="
                     : op === ts.SyntaxKind.GreaterThanToken ? ">" : ">=";
             if (bothNum)
-                return { kind: "bin", op: cmpOp, left, right, type: BOOL, loc };
+                return { kind: "bin", op: cmpOp, left: arithmeticLeft, right: arithmeticRight, type: BOOL, loc };
             if (bothStr)
                 return { kind: "strCmp", op: cmpOp, left, right, type: BOOL, loc };
             lowerer.unsupported("SC1043", expr);
@@ -7885,7 +6568,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 };
@@ -7895,7 +6578,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 `!==`).
@@ -7950,7 +6633,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",
@@ -7973,7 +6656,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;
@@ -8137,33 +6820,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
@@ -8643,7 +7299,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") {
@@ -9473,6 +8129,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;
@@ -9638,8 +8322,21 @@ export function fieldTarget(lowerer, access) {
             return null;
         }
         const fieldType = info.fields.get(access.name.text);
+        const lowerObjectReceiver = () => {
+            let obj = lowerer.lowerExpr(access.expression);
+            if (obj.type.kind === "union" && lowerer.armTag(obj.type.unionId, UNDEFINED_T) >= 0) {
+                const present = lowerer.stripUndefinedArm(obj.type);
+                const helper = present.kind === "object"
+                    ? lowerer.narrowedArmHelper(obj.type.unionId, present, locOf(access.expression))
+                    : null;
+                obj = helper
+                    ? { kind: "call", callee: helper, args: [obj], type: present, loc: locOf(access.expression) }
+                    : lowerer.maybeNarrow(obj, access.expression);
+            }
+            return obj;
+        };
         if (fieldType) {
-            const obj = lowerer.lowerExpr(access.expression);
+            const obj = lowerObjectReceiver();
             return { container: "class", obj, className: receiverIr.className, field: access.name.text, fieldType };
         }
         // Accessor property: either half declared anywhere on the chain
@@ -9648,7 +8345,7 @@ export function fieldTarget(lowerer, access) {
         const getF = lowerer.findMethodOn(info, `get:${access.name.text}`);
         const setF = lowerer.findMethodOn(info, `set:${access.name.text}`);
         if (getF || setF) {
-            const obj = lowerer.lowerExpr(access.expression);
+            const obj = lowerObjectReceiver();
             return {
                 container: "accessor",
                 obj,
@@ -9663,13 +8360,35 @@ export function fieldTarget(lowerer, access) {
         const shape = lowerer.shapes.get(receiverIr.shapeId);
         const fieldType = shape?.fields.find((f) => f.name === access.name.text)?.type;
         if (fieldType) {
-            const obj = lowerer.lowerExpr(access.expression);
+            let obj = lowerer.lowerExpr(access.expression);
             // A checker-record receiver whose VALUE stayed dyn (the erased
             // all-unknown-fields cast — `(err as { code?: unknown }).code`):
             // decline, and the dyn keyed-read fallback answers.
+            if (obj.type.kind === "union" && lowerer.armTag(obj.type.unionId, UNDEFINED_T) >= 0) {
+                // A nested property read such as `rows[i].value` has the same
+                // unchecked outer array-read issue as tuple indexing. Validate
+                // the record arm before fieldGet/recordGet so a missing outer
+                // value raises a catchable TypeError rather than reaching the
+                // backend with a union receiver.
+                const present = lowerer.stripUndefinedArm(obj.type);
+                const helper = present.kind === "record"
+                    ? lowerer.narrowedArmHelper(obj.type.unionId, present, locOf(access.expression))
+                    : null;
+                obj = helper
+                    ? { kind: "call", callee: helper, args: [obj], type: present, loc: locOf(access.expression) }
+                    : lowerer.maybeNarrow(obj, access.expression);
+            }
             if (obj.type.kind !== "record")
                 return null;
-            return { container: "record", obj, shapeId: receiverIr.shapeId, field: access.name.text, fieldType };
+            const actualShape = lowerer.shapes.get(obj.type.shapeId);
+            const actualField = actualShape?.fields.find((f) => f.name === access.name.text);
+            return {
+                container: "record",
+                obj,
+                shapeId: obj.type.shapeId,
+                field: access.name.text,
+                fieldType: actualField?.type ?? fieldType,
+            };
         }
         // A RECORD accessor property: either slot present makes the name an
         // accessor target (get/set share the property namespace — tsc
@@ -10102,7 +8821,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 };