@scriptc/compiler 0.2.7 → 0.2.9

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

@@ -2,6 +2,7 @@ import { generatorDrain } from "./iterator-adapters.js";
 import { lowerUnionEquality, tagEqualityMayMissAlias } from "./strict-equality.js";
 import { isOptionalProcessStreamProperty } from "./builtins/process.js";
 import { lowerWorkerMetadata } from "./builtins/workers.js";
+import { threadsImportOf } from "../threads-import.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 import { SYMBOL_T } from "../../ir/ir.js";
@@ -17,9 +18,9 @@ import * as ts from "../ts7/adapter.js";
 import { constituentTypes } from "../ts7/checker.js";
 import { dirname } from "node:path";
 import * as posix from "node:path/posix";
-import { checkedClassAssertion } from "./class-assertions.js";
+import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-assertions.js";
 import { narrowClassUnion, narrowStoredClassValue } from "./class-unions.js";
-import { lowerUnionFieldWrite } from "./expressions/union-field-write.js";
+import { lowerUnionFieldRead, lowerUnionFieldWrite } from "./expressions/union-fields.js";
 import { captureContextArguments } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
@@ -29,7 +30,7 @@ import { ARRAY_METHODS, builtinConstLit, builtinFenceHintOf, builtinModuleConstO
 import { UNSUPPORTED, blockedBindingUseDiag, requiresDynamicPackageDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, neverTaintedJsType, own } from "./lowerer.js";
 import { lowerCollectionSpread } from "./containers/collection-methods.js";
-import { arrayValueRead, arrayValueStore, arrayValueType, lowerSafeIndexRead, tryLowerIndexTruthiness, tryLowerNumericIndexRead, } from "./array-values.js";
+import { arrayValueRead, arrayValueStore, arrayValueType, lowerSafeIndexRead, tryLowerIndexTruthiness, tryLowerNumericIndexRead, lowerSafeBytesRead, } from "./array-values.js";
 import { strCharsCall } from "./containers/array-construction.js";
 import { lowerOptionalStringIndex } from "./string-index.js";
 import { tryLowerIndexedComparison } from "./indexed-comparison.js";
@@ -166,7 +167,14 @@ export function lowerExpr(lowerer, expr) {
     }
     lowerExprDepth++;
     try {
-        const lowered = lowerExprInner(lowerer, expr);
+        let lowered = lowerExprInner(lowerer, expr);
+        const nanCoded = lowerer.nanCodedReads;
+        if (nanCoded) {
+            if (lowered.type.kind === "f64" && nanCoded.reboxes(expr))
+                lowered = reboxNanCoded(lowerer, lowered, locOf(expr));
+            else if (lowered.type.kind === "union" && nanCoded.convertsSource(expr))
+                lowered = lowerOptionalNumber(lowerer, lowered, locOf(expr));
+        }
         if (lowered.type.kind === "void" && (lowerer.typeOf(expr).flags & ts.TypeFlags.Never) !== 0)
             lowerer.neverValued.add(lowered);
         return lowered;
@@ -175,6 +183,27 @@ export function lowerExpr(lowerer, expr) {
         lowerExprDepth--;
     }
 }
+/** `number | undefined` from a NaN-coded double whose slot never holds a
+ * genuine NaN (nan-coded-reads.ts): NaN is exactly undefined. */
+function reboxNanCoded(lowerer, value, loc) {
+    const optional = lowerer.withUndefinedArm(F64);
+    const stmts = [];
+    let stable = value;
+    if (value.kind !== "varRef") {
+        const tmp = lowerer.declareHiddenLocal("%nanCoded", F64);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        stable = varRef(tmp.id, F64, loc);
+    }
+    const result = {
+        kind: "ternary",
+        cond: { kind: "libCall", fn: "num.isNaN", args: [stable], type: BOOL, loc },
+        then: lowerer.wrappedUndefined(optional, loc),
+        else_: lowerer.coerceToExpected(stable, optional),
+        type: optional,
+        loc,
+    };
+    return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: optional, loc };
+}
 function lowerExprInner(lowerer, expr) {
     const loc = locOf(expr);
     // An optional chain's guarded receiver: already evaluated by the
@@ -294,6 +323,14 @@ function lowerExprInner(lowerer, expr) {
     // traps. Sub-union assertions and non-union inners keep their
     // historic erasure (the widening sites re-tag with traps already).
     if (ts.isNonNullExpression(expr)) {
+        // An asserted element read forwarded into a slot that holds undefined
+        // (see analyzeRuntimeOptionalArrayReads) reads without the bounds trap.
+        if (lowerer.runtimeOptionalAssertions.has(expr) &&
+            ts.isElementAccessExpression(expr.expression)) {
+            const probe = lowerAbsenceProbe(lowerer, expr.expression);
+            if (probe?.type.kind === "union")
+                return probe;
+        }
         const inner = lowerer.lowerExpr(expr.expression);
         if (inner.type.kind === "union") {
             // `!` performs no runtime check: a missing array element stays
@@ -301,14 +338,20 @@ function lowerExprInner(lowerer, expr) {
             if (ts.isElementAccessExpression(expr.expression) &&
                 assertedElementKeepsUndefined(lowerer, expr))
                 return inner;
+            // A forwarded assertion whose destination was promoted to hold
+            // undefined (see analyzeRuntimeOptionalArrayReads), or an equality
+            // operand, keeps the value: `!` performs no runtime check.
+            const target = lowerer.mapTypeOf(lowerer.typeOf(expr));
+            if (lowerer.runtimeOptionalAssertions.has(expr) ||
+                (target?.kind === "object" && isEqualityOperand(expr)))
+                return inner;
             const use = runtimeOptionalUseOf(expr);
             if (runtimeOptionalAssertionErases(lowerer, expr, inner, use))
                 return inner;
-            const target = lowerer.mapTypeOf(lowerer.typeOf(expr));
             if (target && target.kind !== "union" && !typeEquals(target, inner.type)) {
                 const helper = lowerer.narrowedArmHelper(inner.type.unionId, target, loc);
                 if (helper) {
-                    return { kind: "call", callee: helper, args: [inner], type: target, loc };
+                    return lowerer.checkedNarrowCall(helper, inner, target, loc);
                 }
             }
             return inner;
@@ -730,7 +773,7 @@ function lowerExprInner(lowerer, expr) {
         // A known static result type fixes typeof's answer, but its producer
         // still evaluates: calls, getters, and checked reads can have effects
         // or throw. Only trivial operands may disappear.
-        let operand = lowerer.lowerExpr(expr.expression);
+        let operand = deferredSlotOr(lowerer, runtimeOptionalStorageOperand(lowerer, expr.expression) ?? lowerer.lowerExpr(expr.expression));
         if (operand.type.kind === "jsval") {
             return { kind: "jsOp", op: "typeof", args: [operand], type: STRING, loc };
         }
@@ -949,13 +992,7 @@ function lowerExprInner(lowerer, expr) {
                                 ? 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 lowerer.checkedNarrowCall(helper, varRef(local.id, local.type, loc), narrowed, loc);
                         }
                     }
                 }
@@ -993,7 +1030,10 @@ function lowerExprInner(lowerer, expr) {
             // that does not exist. The blocked-binding cascade names the use;
             // without this the validator's registration check ICEs on the live
             // reference (`@this {T}` inference — signature 07).
-            if (lowerer.typeNamesUnregisteredClass(g.type)) {
+            const unregistered = lowerer.unregisteredClassOf(g.type, new Set());
+            if (unregistered !== null) {
+                // The class's own rejection is the root cause the cascade names.
+                lowerer.flushDeferredClass(unregistered);
                 lowerer.pushDiag(blockedBindingUseDiag(expr.text, loc));
                 throw new PoisonError();
             }
@@ -1026,7 +1066,7 @@ function lowerExprInner(lowerer, expr) {
                     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 };
+                        return lowerer.checkedNarrowCall(helper, ref, narrowed, loc);
                 }
                 const use = runtimeOptionalUseOf(expr);
                 // The enclosing logical/conditional expression consumes the union
@@ -1124,6 +1164,14 @@ function lowerExprInner(lowerer, expr) {
         // as interned string literals; functions have no closure
         // representation (they lower to libCall at call sites only); members
         // with no lowering at all fence with the module-qualified name.
+        {
+            const member = threadsImportOf(lowerer.program, expr);
+            // scriptc delivers published graphs by reference.
+            if (member === "sharesPublishedGraphs")
+                return { kind: "boolLit", value: true, type: BOOL, loc };
+            if (member === "publish")
+                lowerer.noLowering("publish (@scriptc/threads) as a value", expr, "call publish(value) directly");
+        }
         {
             const bi = lowerer.builtinImportOf(expr);
             if (bi) {
@@ -2189,6 +2237,11 @@ function lowerExprInner(lowerer, expr) {
                 handled.kind === "recordGet" &&
                 lowerer.isRuntimeOptionalField(handled.shapeId, handled.field))
                 return handled;
+            // A class field assigned a missing read: the checker narrows this
+            // read to the assigned value's bare type, but the stored undefined
+            // arm is real (`obj.n = bytes[i]; obj.n` is undefined in Node).
+            if (runtimeOptionalClassField(lowerer, handled, expr))
+                return handled;
             return lowerer.maybeNarrow(handled, expr);
         }
         // `globalThis.<name>` that no lowering above claimed
@@ -3299,13 +3352,7 @@ function runtimeOptionalReceiverRead(lowerer, expr, local, property, 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,
-        };
+        return lowerer.checkedNarrowCall(helper, varRef(local.id, local.type, loc), narrowed, loc);
     }
     // A predicate can strengthen a record's fields or narrow a base class
     // to a subclass without changing the slot's stored value arm. Extract
@@ -3438,6 +3485,18 @@ function runtimeOptionalElementKey(expr) {
         return expr.text;
     return null;
 }
+/** An operand of `===`, `!==`, `==` or `!=` (through parentheses). */
+function isEqualityOperand(node) {
+    let outer = node;
+    while (ts.isParenthesizedExpression(outer.parent))
+        outer = outer.parent;
+    const parent = outer.parent;
+    return (ts.isBinaryExpression(parent) &&
+        (parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+            parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+            parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+            parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken));
+}
 /** Whether `xs[i]!` lands where an absent element's undefined is
  * representable: array storage (a literal element, a push/unshift
  * argument, an element assignment — arrays record the undefined state),
@@ -3505,6 +3564,17 @@ export function lowerUnitComparison(lowerer, left, right, negated, loc) {
         // Two unit literals (`undefined === undefined`): statically decided.
         return { kind: "boolLit", value: (other.unit === unit.unit) !== negated, type: BOOL, loc };
     }
+    const slot = lowerer.deferredFieldSlot(other);
+    if (slot)
+        return lowerUnitComparison(lowerer, slot, unit, negated, loc);
+    // A binding the checker narrowed past the unit can still hold it at
+    // runtime when its value came from an unassigned deferred-init field;
+    // the stored tag answers either way.
+    if (other.kind === "unionNarrow" &&
+        other.value.kind === "varRef" &&
+        other.value.type.kind === "union" &&
+        lowerer.armTag(other.value.type.unionId, unit.type) >= 0)
+        return lowerUnitComparison(lowerer, other.value, unit, negated, loc);
     if (other.type.kind === "union") {
         const tag = lowerer.armTag(other.type.unionId, unit.type);
         if (tag < 0) {
@@ -3612,7 +3682,7 @@ function lowerLooseNullCompare(lowerer, expr, loc) {
     if (!leftIsNull && right.kind !== ts.SyntaxKind.NullKeyword)
         return null;
     const otherNode = leftIsNull ? right : left;
-    const other = lowerer.lowerExpr(otherNode);
+    const other = lowerPresenceOperand(lowerer, otherNode);
     if (isUnitType(other.type)) {
         // `null == null`, `undefined == null`: units are mutually loose-equal.
         return { kind: "boolLit", value: !negated, type: BOOL, loc };
@@ -3717,13 +3787,84 @@ export function lowerNullishCoalesce(lowerer, expr, loc) {
         parents.push(first);
         first = first.left;
     }
-    let result = lowerNullishPair(lowerer, first, first === expr ? loc : locOf(first), lowerAbsenceProbe(lowerer, first.left) ?? lowerer.lowerExpr(first.left));
+    let result = lowerNullishPair(lowerer, first, first === expr ? loc : locOf(first), assertedPresenceOperand(lowerer, first.left));
     for (let i = parents.length - 1; i >= 0; i--) {
         const parent = parents[i];
         result = lowerNullishPair(lowerer, parent, parent === expr ? loc : locOf(parent), result);
     }
     return result;
 }
+/** The left side of `??` (see lowerPresenceOperand). The absence probe
+ * reads optional storage beneath erased assertions; a union assertion that
+ * narrows a stored class arm still applies its checked class view, so
+ * `(node.parent as Sub | undefined) ?? node` sees the asserted arm on both
+ * sides of the default. */
+function assertedPresenceOperand(lowerer, node) {
+    const probe = lowerAbsenceProbe(lowerer, node);
+    if (probe === null)
+        return runtimeOptionalStorageOperand(lowerer, node) ?? lowerer.lowerExpr(node);
+    if (probe.type.kind !== "union" && probe.type.kind !== "object")
+        return probe;
+    let outer = node;
+    while (ts.isParenthesizedExpression(outer))
+        outer = outer.expression;
+    if (!ts.isAsExpression(outer) && !ts.isTypeAssertion(outer))
+        return probe;
+    const target = lowerer.mapTypeOf(lowerer.checker.getTypeFromTypeNode(outer.type));
+    if (target?.kind !== "union" || typeEquals(target, probe.type))
+        return probe;
+    return checkedClassUnionAssertion(lowerer, probe, target, locOf(outer)) ?? probe;
+}
+/** Read-modify-write updates read the member first: an unassigned
+ * deferred-init receiver throws Node's member-read TypeError. */
+function checkDeferredMemberReceiver(lowerer, target, access) {
+    if (target.container !== "class" ||
+        !ts.isPropertyAccessExpression(access) ||
+        target.obj.type.kind !== "object" ||
+        lowerer.deferredFieldSlot(target.obj) === null)
+        return;
+    target.obj =
+        lowerer.runtimeOptionalPropertyReceiver(access.expression, target.obj, target.obj.type, target.field) ?? target.obj;
+}
+/** Whether evaluating `expr` cannot store anything or run other code:
+ * reads, arithmetic, tests and checked extractions (which at most throw). */
+function writeFree(expr) {
+    switch (expr.kind) {
+        case "numLit":
+        case "strLit":
+        case "boolLit":
+        case "unitLit":
+        case "varRef":
+            return true;
+        case "fieldGet":
+        case "recordGet":
+            return writeFree(expr.obj);
+        case "bin":
+        case "logical":
+            return writeFree(expr.left) && writeFree(expr.right);
+        case "unary":
+        case "toBool":
+            return writeFree(expr.operand);
+        case "ternary":
+            return writeFree(expr.cond) && writeFree(expr.then) && writeFree(expr.else_);
+        case "unionIsTag":
+        case "unionNarrow":
+        case "unionWrap":
+            return writeFree(expr.value);
+        case "libCall":
+            return expr.fn === "error.nodeThrow";
+        default:
+            return false;
+    }
+}
+/** The TypeError of a deferred-init field read that finds the field
+ * unassigned where its declared type cannot hold undefined. */
+export const DEFERRED_READ_MESSAGE = "undefined is not representable in the target union (a value narrowed or asserted past it still held it)";
+/** The undefined-armed slot behind a checked deferred-init field read, or
+ * the value itself (Lowerer.deferredFieldSlot). */
+function deferredSlotOr(lowerer, value) {
+    return lowerer.deferredFieldSlot(value) ?? value;
+}
 /** A plain value read that may be runtime-optional: an unchecked element
  * read, or a binding, member or call that carries one. Lowering these
  * without a destination type is the same as lowering them into one. */
@@ -3844,6 +3985,24 @@ function lowerNullishPair(lowerer, expr, loc, left) {
             return nullishBranches(lowerer, left, left.type, def.arms, type, loc, () => lowerer.lowerExprExpecting(expr.right, type), (stable) => ({ kind: "call", callee: helper, args: [stable], type, loc }));
         }
     }
+    // A subclass value defaulted to a base-class value (`circle ?? shape`):
+    // the present arm upcasts after the original nullish test, and the
+    // default lowers lazily into the base-class result.
+    const present = rest.length === 1 ? rest[0] : null;
+    if (present?.kind === "object" &&
+        type.kind === "object" &&
+        present.className !== type.className &&
+        lowerer.isSubclassOf(present.className, type.className)) {
+        const helper = lowerer.narrowedArmHelper(left.type.unionId, present, loc);
+        if (helper !== null) {
+            return nullishBranches(lowerer, left, left.type, def.arms, type, loc, () => lowerer.lowerExprExpecting(expr.right, type), (stable) => ({
+                kind: "upcast",
+                value: { kind: "call", callee: helper, args: [stable], type: present, loc },
+                type,
+                loc,
+            }));
+        }
+    }
     // A default may change the union or widen its records. Test the
     // original tag before coercing: converting the whole left first can
     // lose nullish arms, and evaluating the default eagerly loses laziness.
@@ -3957,7 +4116,7 @@ export function lowerCondition(lowerer, expr) {
             };
         }
     }
-    const value = lowerAbsenceProbe(lowerer, expr) ?? lowerer.lowerExpr(expr);
+    const value = lowerPresenceOperand(lowerer, expr);
     return (tryLowerIndexTruthiness(lowerer, value, expr, locOf(expr)) ?? lowerer.ensureBool(value, expr));
 }
 function lowerPromiseThenPresence(lowerer, access, result) {
@@ -3997,13 +4156,7 @@ function lowerPromiseThenPresence(lowerer, access, result) {
             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,
-            };
+            receiver = lowerer.checkedNarrowCall(helper, receiver, promiseType, receiver.loc);
         }
     }
     if (receiver.type.kind === "dyn") {
@@ -4691,13 +4844,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
                     ? 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.checkedNarrowCall(helper, receiver, present, locOf(expr.expression))
                     : lowerer.maybeNarrow(receiver, expr.expression);
             }
             // An island handle behind a typed-array .d.ts surface: the engine
@@ -4791,13 +4938,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
                 ? 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.checkedNarrowCall(helper, receiver, present, locOf(expr.expression))
                 : lowerer.maybeNarrow(receiver, expr.expression);
         }
         // An island handle behind an array-typed .d.ts surface
@@ -5097,7 +5238,30 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
         }
         lowerer.badType(expr, tsType);
     }
-    const type = mapped;
+    let type = mapped;
+    // An inferred array of records takes the layout of an element literal
+    // whose fields widened for missing-element reads; the other elements
+    // build that layout directly. An explicit destination keeps its own.
+    if (!expected && type.elem.kind === "record") {
+        let variant = null;
+        for (const candidate of expr.elements) {
+            let x = candidate;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (!ts.isObjectLiteralExpression(x))
+                continue;
+            const probe = tryLowerExpression(lowerer, x);
+            if (!probe || !lowerer.isRuntimeOptionalRecordVariant(probe.type, type.elem))
+                continue;
+            if (variant !== null && !typeEquals(variant, probe.type)) {
+                variant = null;
+                break;
+            }
+            variant = probe.type;
+        }
+        if (variant !== null)
+            type = arrayOf(variant);
+    }
     // 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
@@ -5262,8 +5426,21 @@ export function lowerArrayLiteral(lowerer, expr, expected) {
     }
     const out = lowerer.declareHiddenLocal("%arrayLit", type);
     const outRef = varRef(out.id, type, loc);
+    // Dense capacity for the elements the statements below store.
+    const capacity = Math.min(elems.length - spreads.length, 1024);
     const body = [
-        { kind: "varDecl", localId: out.id, init: { kind: "arrayLit", elems: [], type, loc }, loc },
+        {
+            kind: "varDecl",
+            localId: out.id,
+            init: {
+                kind: "arrayLit",
+                elems: [],
+                ...(capacity > 0 ? { capacity } : {}),
+                type,
+                loc,
+            },
+            loc,
+        },
     ];
     const spreadSet = new Set(spreads);
     const currentLength = () => ({
@@ -5438,6 +5615,34 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
         ? value
         : { kind: "seqExpr", stmts: prefix, result: value, type: F64, loc };
 }
+/** A number argument of a builtin that converts it with ToNumber (Math
+ * functions, String.fromCharCode, the global isNaN/isFinite, DataView
+ * offsets and values). ToNumber(undefined) is NaN, so a missing value — an
+ * out-of-range read, a local or field holding one, or a hole — converts to
+ * NaN instead of trusting the checker's number type. */
+export function lowerToNumberArgument(lowerer, node) {
+    let inner = node;
+    while (ts.isParenthesizedExpression(inner))
+        inner = inner.expression;
+    const loc = locOf(inner);
+    const isOptionalNumber = (value) => value.type.kind === "union" &&
+        lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
+        lowerer.stripUndefinedArm(value.type).kind === "f64";
+    const optional = ts.isIdentifier(inner)
+        ? runtimeOptionalStorageOperand(lowerer, inner)
+        : ts.isElementAccessExpression(inner)
+            ? lowerAbsenceProbe(lowerer, inner)
+            : null;
+    if (optional && isOptionalNumber(optional))
+        return lowerOptionalNumber(lowerer, optional, loc, inner);
+    // A conditional builds each branch for the destination.
+    if (ts.isConditionalExpression(inner))
+        return lowerer.lowerExprExpecting(node, F64);
+    const value = lowerer.lowerExpr(node);
+    if (isOptionalNumber(value))
+        return lowerOptionalNumber(lowerer, value, loc, inner);
+    return lowerer.coerceInto(node, value, F64);
+}
 /** `a[i]` reads. Only f64 indices into array receivers are modeled; JS
  * string-key element access (`a["length"]`) and string indexing (`s[0]`
  * typechecks against the lib's index signature; use .charAt) stay out. */
@@ -5686,7 +5891,7 @@ export function lowerElementAccess(lowerer, expr) {
                 ? 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.checkedNarrowCall(helper, recv, present, locOf(expr.expression))
                 : lowerer.maybeNarrow(recv, expr.expression);
         }
         // A typed-array .d.ts surface whose VALUE is an island handle
@@ -5719,14 +5924,24 @@ export function lowerElementAccess(lowerer, expr) {
         if (index.type.kind !== "f64") {
             lowerer.unsupported("SC1090", expr.argumentExpression, "indexing with non-number keys");
         }
-        return {
-            kind: "bytesIntrinsic",
-            method: "get",
-            receiver: recv,
-            args: [index],
-            type: F64,
-            loc: locOf(expr),
-        };
+        // `t[i]!` asserts presence: the numeric element read (NaN when
+        // invalid). Every other read answers undefined for an invalid index,
+        // like Node.
+        // A read whose every consumer treats undefined like NaN (see
+        // nan-coded-reads.ts) is the same plain numeric read.
+        if ((ts.isNonNullExpression(expr.parent) && expr.parent.expression === expr) ||
+            lowerer.nanCodedReads?.isNumericRead(expr) === true) {
+            return {
+                kind: "bytesIntrinsic",
+                method: "get",
+                receiver: recv,
+                args: [index],
+                type: F64,
+                loc: locOf(expr),
+                invalidNaN: true,
+            };
+        }
+        return lowerSafeBytesRead(lowerer, recv, index, locOf(expr));
     }
     // Tuple element read `t[0]`: a positional-field read of the tuple's
     // record shape — LITERAL indices only (the checker's per-index types
@@ -5769,13 +5984,7 @@ export function lowerElementAccess(lowerer, expr) {
                     ? 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.checkedNarrowCall(helper, obj, present, locOf(expr.expression))
                     : lowerer.maybeNarrow(obj, expr.expression);
             }
             const idx = tupleLiteralIndex(expr.argumentExpression);
@@ -5957,6 +6166,17 @@ export function lowerElementAccess(lowerer, expr) {
             const recv = lowerer.lowerExpr(expr.expression);
             const index = lowerOptionalNumber(lowerer, lowerer.lowerExpr(expr.argumentExpression), locOf(expr.argumentExpression), expr.argumentExpression);
             if (index.type.kind === "f64" && recv.type.kind === "string") {
+                // A proven in-bounds integer index always names a code unit, where
+                // charAt and the property read agree.
+                if (lowerer.stringIndexBounds.inBounds(expr))
+                    return {
+                        kind: "strIntrinsic",
+                        method: "charAt",
+                        receiver: recv,
+                        args: [index],
+                        type: STRING,
+                        loc: locOf(expr),
+                    };
                 return lowerOptionalStringIndex(lowerer, recv, index, lowerer.withUndefinedArm(STRING), locOf(expr));
             }
             lowerer.unsupported("SC1090", expr, "string indexing with this index/result shape (expected a number index and a string or string | undefined result)");
@@ -6020,7 +6240,7 @@ export function lowerElementAccess(lowerer, expr) {
             ? 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.checkedNarrowCall(helper, arr, present, locOf(expr.expression))
             : lowerer.maybeNarrow(arr, expr.expression);
     }
     // The checker sees an array but the VALUE is an island handle (an
@@ -6330,6 +6550,74 @@ function lowerRecordPropertyKey(lowerer, key, node) {
     }
     return key;
 }
+/** The stored value of an identifier whose storage holds an undefined arm
+ * that the checker's type at this use has dropped. An assignment from an
+ * unchecked indexed read narrows the declared type even though the value
+ * can be absent at runtime, so presence tests (`=== undefined`, `== null`,
+ * truthiness, `??`, `typeof`) read the storage tag instead of trusting
+ * that narrowing. A guard-proven use answers the same way at runtime. */
+export function runtimeOptionalStorageOperand(lowerer, node) {
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isIdentifier(expr))
+        return null;
+    // Only storage that can actually receive an absent value without the
+    // checker seeing it qualifies; other declared-optional bindings keep the
+    // checker's assignment and guard narrowing.
+    const symbol = lowerer.resolveValueSymbol(expr);
+    const local = lowerer.resolveLocal(expr);
+    const global = local ? undefined : lowerer.globalOf(expr);
+    const root = local ? lowerer.runtimeOptionalRootOf(local) : null;
+    if (root && lowerer.runtimeOptionalStorageLocals.has(root)) {
+        // These locals track guards: a branch that proved presence removes
+        // the binding from the active set, and its reads stay narrowed. A
+        // captured binding can be reassigned between calls, so a capture
+        // never inherits a guard (the identifier read's own rule).
+        const captured = local.boxed === true ||
+            (!!symbol && lowerer.ctx.captureBySymbol.get(symbol) === local) ||
+            root !== local;
+        if (!captured && !lowerer.runtimeOptionalLocals.has(root))
+            return null;
+    }
+    else if (!(symbol && lowerer.runtimeOptionalAssignedSymbols.has(symbol)) &&
+        !(symbol && lowerer.runtimeOptionalBindingTypes.has(symbol)) &&
+        !(global && lowerer.isRuntimeOptionalGlobal(global)))
+        return null;
+    const optional = lowerer.runtimeOptionalIdentifierValue(expr);
+    if (optional === null)
+        return null;
+    const checked = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    if (checked === null ||
+        (checked.kind === "union" && lowerer.armTag(checked.unionId, UNDEFINED_T) >= 0))
+        return null;
+    return optional.value;
+}
+/** A `T | undefined` class field read that the checker narrowed to `T`
+ * where the field was assigned a value that may be missing (an unchecked
+ * indexed read). TypeScript's assignment narrowing is not a runtime fact
+ * there, so the read keeps the stored union instead of extracting `T`. */
+function runtimeOptionalClassField(lowerer, value, node) {
+    if (value.kind !== "fieldGet" || value.type.kind !== "union")
+        return false;
+    if (lowerer.armTag(value.type.unionId, UNDEFINED_T) < 0)
+        return false;
+    if ((lowerer.unions.get(value.type.unionId)?.arms.length ?? 0) !== 2)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(node.name);
+    if (!symbol || !lowerer.runtimeOptionalAssignedSymbols.has(symbol))
+        return false;
+    const narrowed = lowerer.mapTypeOf(lowerer.typeOf(node));
+    return narrowed !== null && typeEquals(narrowed, lowerer.stripUndefinedArm(value.type));
+}
+/** A presence-test operand: an absence-aware element or field read, an
+ * identifier's runtime-optional storage, or the ordinary lowering. */
+export function lowerPresenceOperand(lowerer, node) {
+    // An unassigned deferred-init field observes its undefined slot too.
+    return deferredSlotOr(lowerer, lowerAbsenceProbe(lowerer, node) ??
+        runtimeOptionalStorageOperand(lowerer, node) ??
+        lowerer.lowerExpr(node));
+}
 /** 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
@@ -6542,13 +6830,7 @@ export function lowerElementCompound(lowerer, expr, op) {
             ? lowerer.narrowedArmHelper(receiver.type.unionId, present, locOf(target.expression))
             : null;
         if (helper)
-            receiver = {
-                kind: "call",
-                callee: helper,
-                args: [receiver],
-                type: present,
-                loc: locOf(target.expression),
-            };
+            receiver = lowerer.checkedNarrowCall(helper, receiver, present, locOf(target.expression));
     }
     if (receiver.type.kind !== receiverType.kind) {
         lowerer.unsupported("SC1090", target.expression, "compound assignment through a non-native array or byte view");
@@ -6563,12 +6845,15 @@ export function lowerElementCompound(lowerer, expr, op) {
     const oldValue = receiver.type.kind === "array"
         ? arrayValueRead(lowerer, receiverRef(), indexRef(), receiver.type.elem, locOf(target))
         : {
+            // An invalid index reads undefined in Node, which every numeric
+            // compound operator turns into NaN; the write is then ignored.
             kind: "bytesIntrinsic",
             method: "get",
             receiver: receiverRef(),
             args: [indexRef()],
             type: F64,
             loc: locOf(target),
+            invalidNaN: true,
         };
     const oldLocal = lowerer.declareHiddenLocal("%compoundOld", oldValue.type);
     const oldRef = () => varRef(oldLocal.id, oldValue.type, loc);
@@ -7184,13 +7469,7 @@ export function lowerElementWrite(lowerer, expr) {
             ? 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),
-            };
+            arr = lowerer.checkedNarrowCall(helper, arr, present, locOf(target.expression));
         }
     }
     if (arr.type.kind !== "array") {
@@ -7308,7 +7587,7 @@ export function ensureString(lowerer, e, node) {
                 narrowed.kind === "bigint")) {
             const helper = lowerer.narrowedArmHelper(e.type.unionId, narrowed, e.loc);
             if (helper) {
-                return ensureString(lowerer, { kind: "call", callee: helper, args: [e], type: narrowed, loc: e.loc }, node);
+                return ensureString(lowerer, lowerer.checkedNarrowCall(helper, e, narrowed, e.loc), node);
             }
         }
         if (narrowed?.kind === "union" &&
@@ -7581,10 +7860,20 @@ export function lowerAsExpression(lowerer, expr) {
             if (target && target.kind !== "union" && !typeEquals(target, inner.type)) {
                 const helper = lowerer.narrowedArmHelper(inner.type.unionId, target, locOf(expr));
                 if (helper) {
-                    return { kind: "call", callee: helper, args: [inner], type: target, loc: locOf(expr) };
+                    return lowerer.checkedNarrowCall(helper, inner, target, locOf(expr));
                 }
             }
         }
+        // `node.parent as Sub | undefined`: a union target whose class arm is
+        // narrower than the stored class gets the same checked class view as
+        // `node.parent as Sub`; the other arms keep their identical tags.
+        if (target?.kind === "union" &&
+            (inner.type.kind === "union" || inner.type.kind === "object") &&
+            !typeEquals(target, inner.type)) {
+            const asserted = checkedClassUnionAssertion(lowerer, inner, target, locOf(expr));
+            if (asserted)
+                return asserted;
+        }
         return inner; // erasure, unchanged
     }
     if (inner.type.kind === "jsval") {
@@ -7711,7 +8000,7 @@ export function lowerPrefixUnary(lowerer, expr) {
         }
         case ts.SyntaxKind.ExclamationToken: {
             // `!x` is ToBoolean-then-negate: f64/string operands go through toBool.
-            const operand = lowerer.ensureBool(lowerer.lowerExpr(expr.operand), expr.operand);
+            const operand = lowerer.ensureBool(deferredSlotOr(lowerer, runtimeOptionalStorageOperand(lowerer, expr.operand) ?? lowerer.lowerExpr(expr.operand)), expr.operand);
             return { kind: "unary", op: "!", operand, type: BOOL, loc };
         }
         case ts.SyntaxKind.TildeToken: {
@@ -7816,7 +8105,15 @@ export function lowerIncDec(lowerer, expr, prefix) {
             const type = raw.type;
             const read = type.kind === "array"
                 ? arrayValueRead(lowerer, receiver, index, type.elem, loc)
-                : { kind: "bytesIntrinsic", method: "get", receiver, args: [index], type: F64, loc };
+                : {
+                    kind: "bytesIntrinsic",
+                    method: "get",
+                    receiver,
+                    args: [index],
+                    type: F64,
+                    loc,
+                    invalidNaN: true,
+                };
             return finish(read, (value) => type.kind === "array"
                 ? arrayValueStore(lowerer, receiver, index, lowerer.coerceInto(access, value, type.elem), type.elem, loc)
                 : {
@@ -7848,6 +8145,7 @@ export function lowerIncDec(lowerer, expr, prefix) {
             ? lowerer.fieldTarget(access)
             : symbolFieldTarget(lowerer, access);
         if (target && lowerer.dynConvertible(target.fieldType)) {
+            checkDeferredMemberReceiver(lowerer, target, access);
             target.obj = save(target.obj, "%incrementReceiver");
             return finish(lowerer.fieldGetExpr(target, loc, access), (value) => lowerer.fieldSetStmt(target, lowerer.coerceInto(access, value, target.fieldType), loc, access));
         }
@@ -8081,12 +8379,75 @@ export function lowerCompoundValueToTarget(lowerer, expr, compound, target) {
     }
     lowerer.unsupported("SC1043", expr);
 }
+/** Equality of two NaN-coded values (nan-coded-reads.ts), each of which may
+ * stand for undefined and never holds a genuine NaN: Node's undefined equals
+ * undefined, so two NaNs compare equal here. Operands evaluate once, in
+ * order. */
+function lowerNanCodedEquality(lowerer, expr) {
+    const loc = locOf(expr);
+    const left = lowerer.lowerExpr(expr.left);
+    const right = lowerer.lowerExpr(expr.right);
+    if (left.type.kind !== "f64" || right.type.kind !== "f64") {
+        throw new InternalCompilerError("NaN-coded equality operand is not a plain number");
+    }
+    const stmts = [];
+    const stable = (value, name) => {
+        if (value.kind === "varRef" || value.kind === "numLit")
+            return value;
+        const tmp = lowerer.declareHiddenLocal(name, F64);
+        stmts.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
+        return varRef(tmp.id, F64, loc);
+    };
+    const a = stable(left, "%eqLeft");
+    const b = stable(right, "%eqRight");
+    const isNaN = (value) => ({
+        kind: "libCall",
+        fn: "num.isNaN",
+        args: [value],
+        type: BOOL,
+        loc,
+    });
+    const bothUndefined = {
+        kind: "logical",
+        op: "&&",
+        left: isNaN(a),
+        right: isNaN(b),
+        type: BOOL,
+        loc,
+    };
+    const op = expr.operatorToken.kind;
+    const negated = op === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+        op === ts.SyntaxKind.ExclamationEqualsToken;
+    const result = negated
+        ? {
+            kind: "logical",
+            op: "&&",
+            left: { kind: "bin", op: "!==", left: a, right: b, type: BOOL, loc },
+            right: { kind: "unary", op: "!", operand: bothUndefined, type: BOOL, loc },
+            type: BOOL,
+            loc,
+        }
+        : {
+            kind: "logical",
+            op: "||",
+            left: { kind: "bin", op: "===", left: a, right: b, type: BOOL, loc },
+            right: bothUndefined,
+            type: BOOL,
+            loc,
+        };
+    return stmts.length === 0 ? result : { kind: "seqExpr", stmts, result, type: BOOL, 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 (lowerer.nanCodedReads?.needsUndefinedEquality(expr)) {
+        const undefinedEquality = lowerNanCodedEquality(lowerer, expr);
+        if (undefinedEquality)
+            return undefinedEquality;
+    }
     if (op === ts.SyntaxKind.EqualsToken ||
         (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment)) {
         const urlWrite = lowerUrlAssignment(lowerer, expr);
@@ -8362,7 +8723,7 @@ export function lowerBinary(lowerer, expr) {
         const nullTest = lowerLooseNullCompare(lowerer, expr, loc);
         if (nullTest)
             return nullTest;
-        const loose = lowerAbstractEquality(lowerer, lowerer.lowerExpr(expr.left), lowerer.lowerExpr(expr.right), op === ts.SyntaxKind.ExclamationEqualsToken, loc);
+        const loose = lowerAbstractEquality(lowerer, deferredSlotOr(lowerer, lowerer.lowerExpr(expr.left)), deferredSlotOr(lowerer, lowerer.lowerExpr(expr.right)), op === ts.SyntaxKind.ExclamationEqualsToken, loc);
         if (loose)
             return loose;
         lowerer.unsupported("SC1040", expr, undefined, "object-to-primitive loose equality can call user-defined valueOf/toString methods — compare explicit primitive conversions instead");
@@ -8409,12 +8770,26 @@ export function lowerBinary(lowerer, expr) {
     }
     const strictEquality = op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
         op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
+    // An identifier whose storage is runtime-optional is compared by its
+    // stored value: the checker's narrowing to the present arm is not a
+    // runtime proof. Identifier reads are pure, so taking the stored value
+    // after both operands lowered keeps the evaluation order. A union on
+    // the other side keeps the narrowed read (union-to-union comparison
+    // has no lowering).
     let left = strictEquality
         ? (lowerAbsenceProbe(lowerer, expr.left) ?? lowerer.lowerExpr(expr.left))
         : lowerer.lowerExpr(expr.left);
     let right = strictEquality
         ? (lowerAbsenceProbe(lowerer, expr.right) ?? lowerer.lowerExpr(expr.right))
         : lowerer.lowerExpr(expr.right);
+    if (strictEquality) {
+        const storedLeft = runtimeOptionalStorageOperand(lowerer, expr.left);
+        const storedRight = runtimeOptionalStorageOperand(lowerer, expr.right);
+        if (storedLeft !== null && right.type.kind !== "union")
+            left = storedLeft;
+        if (storedRight !== null && left.type.kind !== "union")
+            right = storedRight;
+    }
     if (strictEquality && (left.type.kind === "caught" || right.type.kind === "caught")) {
         if (left.type.kind === "caught")
             left = { kind: "caughtToDyn", value: left, type: DYN, loc: left.loc };
@@ -9266,7 +9641,9 @@ function lowerLogicalChain(lowerer, expr) {
             current = left;
             continue;
         }
-        result = lowerLogicalPair(lowerer, current, lowerAbsenceProbe(lowerer, left) ?? lowerer.lowerExpr(left));
+        result = lowerLogicalPair(lowerer, current, current.operatorToken.kind === ts.SyntaxKind.BarBarToken
+            ? lowerPresenceOperand(lowerer, left)
+            : (lowerAbsenceProbe(lowerer, left) ?? lowerer.lowerExpr(left)));
         break;
     }
     for (let i = parents.length - 1; i >= 0; i--) {
@@ -9921,11 +10298,12 @@ function lowerUnionTypeofTest(lowerer, expr, loc) {
     for (const [a, b] of operandPairs(expr)) {
         if (!ts.isTypeOfExpression(a))
             continue;
-        if (lowerer.mapTypeOf(lowerer.typeOf(a.expression))?.kind !== "union")
+        const stored = runtimeOptionalStorageOperand(lowerer, a.expression);
+        if (stored === null && lowerer.mapTypeOf(lowerer.typeOf(a.expression))?.kind !== "union")
             continue;
         if (!ts.isStringLiteral(b))
             continue; // bare-typeof + strEq handles pure operands
-        const value = lowerer.lowerExpr(a.expression);
+        const value = stored ?? lowerer.lowerExpr(a.expression);
         if (value.type.kind !== "union")
             continue; // defensive: an already-narrowed use
         const unionId = value.type.unionId;
@@ -12012,6 +12390,11 @@ export function lowerUnionProperty(lowerer, expr) {
         const helper = lowerer.narrowedRetagHelper(expr.expression, value.type.unionId, receiverIr.unionId, locOf(expr));
         if (helper)
             value = { kind: "call", callee: helper, args: [value], type: receiverIr, loc: locOf(expr) };
+        // Optional storage of a base class (a runtime-optional binding holding
+        // `Base | undefined`) that `instanceof` narrowed to several subclasses:
+        // extract the instance and test its class, as typed slots do.
+        else
+            value = narrowStoredClassValue(lowerer, value, receiverIr) ?? value;
     }
     // A checker-union receiver whose VALUE lowered to a plain RECORD (the
     // merged-signature fiction — `runner(cmd, args)` where runner joined
@@ -12088,13 +12471,7 @@ export function lowerUnionProperty(lowerer, expr) {
             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),
-                    };
+                    receiver = lowerer.checkedNarrowCall(helper, value, objectType, locOf(expr.expression));
             }
             if (receiver !== null) {
                 return {
@@ -12140,6 +12517,11 @@ export function lowerUnionProperty(lowerer, expr) {
     const keyed = lowerUnionKeyedRead(lowerer, expr, value.type.unionId, value, key, field);
     if (keyed)
         return keyed;
+    // Class arms declaring the field with compatible but different types
+    // (`T | undefined` beside `T`): per-arm slot reads widened to one type.
+    const widened = lowerUnionFieldRead(lowerer, expr, value);
+    if (widened)
+        return widened;
     // JavaScript overloads commonly inspect a class brand on a scalar-or-
     // instance argument (e.g. Matrix4.makeTranslation). Preserve primitive
     // missing-property semantics and dispatch class data through its native
@@ -12304,15 +12686,14 @@ function classFieldTarget(lowerer, receiverNode, receiverType, fieldName, saved)
     const lowerObjectReceiver = () => {
         let obj = represented;
         if (obj.type.kind === "union") {
+            // A receiver that may hold a missing value (a field assigned an
+            // unchecked read): Node's member-read TypeError for the unit arm.
+            const present = lowerer.runtimeOptionalPropertyReceiver(receiverNode, obj, receiverType, fieldName);
+            if (present)
+                return present;
             const helper = lowerer.narrowedArmHelper(obj.type.unionId, receiverType, locOf(receiverNode));
             obj = helper
-                ? {
-                    kind: "call",
-                    callee: helper,
-                    args: [obj],
-                    type: receiverType,
-                    loc: locOf(receiverNode),
-                }
+                ? lowerer.checkedNarrowCall(helper, obj, receiverType, locOf(receiverNode))
                 : lowerer.maybeNarrow(obj, receiverNode);
         }
         return lowerer.coerceInto(receiverNode, obj, receiverType);
@@ -12476,13 +12857,7 @@ export function fieldTarget(lowerer, access) {
                     ? 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.checkedNarrowCall(helper, obj, present, locOf(access.expression))
                     : lowerer.maybeNarrow(obj, access.expression);
             }
             if (obj.type.kind !== "record")
@@ -12689,6 +13064,16 @@ function symbolFieldTarget(lowerer, expr) {
  * tsc-clean (the property types as the setter's param), but Node yields
  * undefined, which these property types cannot represent. */
 export function fieldGetExpr(lowerer, target, loc, blame) {
+    // A member read through an unassigned deferred-init field throws Node's
+    // member-read TypeError instead of the generic checked extraction.
+    if (target.container === "class" &&
+        ts.isPropertyAccessExpression(blame) &&
+        target.obj.type.kind === "object" &&
+        lowerer.deferredFieldSlot(target.obj) !== null) {
+        const checked = lowerer.runtimeOptionalPropertyReceiver(blame.expression, target.obj, target.obj.type, target.field);
+        if (checked)
+            target = { ...target, obj: checked };
+    }
     if (target.container === "dynamic")
         return lowerer.coerceInto(blame, {
             kind: "dynKeyGet",
@@ -12812,6 +13197,34 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
         if (lowerer.classes.get(target.className)?.deferredInitFields?.has(target.field) === true &&
             target.fieldType.kind === "union") {
             const inner = lowerer.stripUndefinedArm(target.fieldType);
+            // Reference arms over a stable receiver check inline: the present
+            // arm is a plain projection of the slot, so ordinary reads keep their
+            // borrowed form and only an unassigned slot reaches the throw.
+            const unionId = target.fieldType.unionId;
+            const presentTag = lowerer.armTag(unionId, inner);
+            const undefTag = lowerer.armTag(unionId, UNDEFINED_T);
+            if (inner.kind === "object" &&
+                presentTag >= 0 &&
+                undefTag >= 0 &&
+                lowerer.unions.get(unionId)?.arms.length === 2 &&
+                isSafeToRepeat(read)) {
+                return {
+                    kind: "ternary",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId,
+                        tag: undefTag,
+                        negated: false,
+                        value: read,
+                        type: BOOL,
+                        loc,
+                    },
+                    then: nodeThrowExpr(1, "", DEFERRED_READ_MESSAGE, inner, loc),
+                    else_: { kind: "unionNarrow", unionId, tag: presentTag, value: read, type: inner, loc },
+                    type: inner,
+                    loc,
+                };
+            }
             const helper = lowerer.deferredReadHelper(target.fieldType.unionId, inner, loc);
             if (helper)
                 return { kind: "call", callee: helper, args: [read], type: inner, loc };
@@ -12831,6 +13244,75 @@ export function fieldGetExpr(lowerer, target, loc, blame) {
  * call). A write to a getter-only property never gets here in a clean
  * program (tsc's TS2540 is the fence); the rejection is the backstop. */
 export function fieldSetStmt(lowerer, target, value, loc, blame) {
+    // A member write through an unassigned deferred-init field: the value
+    // still evaluates first, then the write throws Node's TypeError.
+    const deferredSlot = target.container === "class" &&
+        !((target.field === "message" || target.field === "name") &&
+            (target.className === "%Error" || lowerer.isSubclassOf(target.className, "%Error")))
+        ? lowerer.deferredFieldSlot(target.obj)
+        : null;
+    if (target.container === "class" && deferredSlot?.type.kind === "union") {
+        const unionId = deferredSlot.type.unionId;
+        const undefTag = lowerer.armTag(unionId, UNDEFINED_T);
+        const presentTag = lowerer.armTag(unionId, target.obj.type);
+        if (undefTag >= 0 && presentTag >= 0) {
+            // A value that cannot write anything leaves the field unchanged, so
+            // the field is read after it (no snapshot of the slot).
+            const late = isSafeToRepeat(deferredSlot) && writeFree(value);
+            const receiver = late
+                ? null
+                : lowerer.declareHiddenLocal("%deferredWriteObject", deferredSlot.type);
+            const stored = lowerer.declareHiddenLocal("%deferredWriteValue", value.type);
+            const receiverRef = receiver ? varRef(receiver.id, receiver.type, loc) : deferredSlot;
+            const result = varRef(stored.id, stored.type, loc);
+            const write = {
+                kind: "fieldSet",
+                obj: {
+                    kind: "unionNarrow",
+                    unionId,
+                    tag: presentTag,
+                    value: receiverRef,
+                    type: target.obj.type,
+                    loc,
+                },
+                className: target.className,
+                field: target.field,
+                value: result,
+                loc,
+            };
+            return {
+                kind: "exprStmt",
+                expr: {
+                    kind: "seqExpr",
+                    stmts: [
+                        ...(receiver
+                            ? [{ kind: "varDecl", localId: receiver.id, init: deferredSlot, loc }]
+                            : []),
+                        { kind: "varDecl", localId: stored.id, init: value, loc },
+                    ],
+                    result: {
+                        kind: "ternary",
+                        cond: {
+                            kind: "unionIsTag",
+                            unionId,
+                            tag: undefTag,
+                            value: receiverRef,
+                            negated: false,
+                            type: BOOL,
+                            loc,
+                        },
+                        then: nodeThrowExpr(1, "", `Cannot set properties of undefined (setting '${target.field}')`, result.type, loc),
+                        else_: { kind: "seqExpr", stmts: [write], result, type: result.type, loc },
+                        type: result.type,
+                        loc,
+                    },
+                    type: result.type,
+                    loc,
+                },
+                loc,
+            };
+        }
+    }
     if (target.container === "dynamic")
         return {
             kind: "exprStmt",
@@ -13148,6 +13630,7 @@ function lowerFieldCompoundValue(lowerer, access, op, rhsNode, loc) {
     const target = targetOf();
     if (!target)
         lowerer.unsupported("SC1090", access, "compound assignment to unsupported field targets");
+    checkDeferredMemberReceiver(lowerer, target, access);
     target.obj = save(target.obj, "%compoundReceiver");
     // Accessors observe getter, RHS side effects, then setter, all through
     // the saved receiver.