@scriptc/compiler 0.0.36 → 0.1.1

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

@@ -4,6 +4,7 @@ import { InternalCompilerError } from "../../errors.js";
  * flow (if/while/for/for-of/do, switch, try/catch, jumps with the
  * finally-crossing fence), and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
+import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
 import { lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
@@ -13,7 +14,7 @@ import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sid
 import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
-import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
+import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
@@ -21,13 +22,13 @@ import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf } from
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
 import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, textCodecBindingDecl } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, matchResultNamedGroupsOf, probeLower, pureReemittable, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, probeLower, pureReemittable, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { isParseArgsDynTypeName, isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
 import { canonicalBuiltinModule } from "../builtin-modules.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { probeNodeRequireRefusal } from "../npm.js";
-import { varRef } from "../../ir/build.js";
+import { numLit, varRef } from "../../ir/build.js";
 /** `const X = /* @__PURE__ *\/ makeX()` at a module's top level: every
  * declarator initialized by a call (or `new`) carrying the bundler PURE
  * annotation in its leading trivia — the shape --provenance-sources may
@@ -1264,6 +1265,11 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
 export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
+    const present = patternSourceValue(lowerer, srcRef(), ts.isArrayBindingPattern(pattern), out, locOf(pattern), dynSpell);
+    if (!typeEquals(present.type, srcType)) {
+        lowerer.lowerBindingPattern(pattern, () => present, present.type, isLet, out, dynSpell, allowDynObject);
+        return;
+    }
     if (ts.isArrayBindingPattern(pattern)) {
         lowerer.fenceStaticHeadersIteration(pattern);
         // Tuple sources: each position is a field read of the tuple's record
@@ -1500,29 +1506,22 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             if (ts.isOmittedExpression(el) || el.name === undefined)
                 return; // hole: position skipped, like JS over an array
             const loc = locOf(el);
-            // `[current, ...rest]` over an ARRAY source: the rest binds a
-            // fresh tail copy — `arr.slice(i)`, exactly the JS surplus packing
-            // (tsc pins rest to the last position; an empty tail is `[]`) —
-            // and a NESTED rest pattern (`[...[a, b]]`) destructures the copy.
+            // Array rest drains values from the iterator, so holes become
+            // present undefined in the fresh tail. Nested rest patterns then
+            // destructure that materialized copy.
             if (el.dotDotDotToken) {
                 if (el.initializer) {
                     lowerer.unsupported("SC1031", el, "defaults on rest elements"); // tsc rejects; defensive
                 }
-                const value = {
-                    kind: "arrIntrinsic",
-                    method: "slice",
-                    receiver: srcRef(),
-                    args: [{ kind: "numLit", value: i, type: F64, loc }],
-                    type: srcType,
-                    loc,
-                };
+                const value = arrayRestValue(srcRef(), i, srcType, loc);
                 lowerer.bindPatternTarget(el.name, value, isLet, out);
                 return;
             }
-            let value = {
+            const position = { kind: "numLit", value: i, type: F64, loc };
+            let value = lowerSafeIndexRead(lowerer, srcRef(), position, loc) ?? {
                 kind: "arrayGet",
                 arr: srcRef(),
-                index: { kind: "numLit", value: i, type: F64, loc },
+                index: position,
                 type: srcType.elem,
                 loc,
             };
@@ -1842,6 +1841,33 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         lowerer.bindPatternTarget(el.name, value, isLet, out);
     }
 }
+/** Destructuring a missing array element throws before reading members.
+   * Only unwrap a union after testing every nullish arm; this also keeps
+   * dense record/tuple callbacks on their existing payload representation. */
+function patternSourceValue(lowerer, value, arrayPattern, out, loc, spelling) {
+    if (value.type.kind !== "union")
+        return value;
+    const unionId = value.type.unionId;
+    const arms = lowerer.unions.get(unionId)?.arms;
+    const present = arms?.filter((arm) => !isUnitType(arm));
+    if (!arms || present?.length !== 1 || arms.length === 1)
+        return value;
+    for (const [tag, arm] of arms.entries()) {
+        if (!isUnitType(arm))
+            continue;
+        const unit = arm.kind === "undefinedT" ? "undefined" : "null";
+        const message = arrayPattern
+            ? spelling ?? `${unit} is not iterable (cannot read property Symbol(Symbol.iterator))`
+            : `Cannot destructure ${unit}`;
+        out.push({
+            kind: "if",
+            cond: { kind: "unionIsTag", unionId, tag, value, negated: false, type: BOOL, loc },
+            then: [{ kind: "throw", value: { kind: "libCall", fn: "error.new", args: [{ kind: "strLit", value: message, type: STRING, loc }], type: { kind: "object", className: "%TypeError" }, loc }, loc }],
+            else_: null, loc,
+        });
+    }
+    return { kind: "unionNarrow", unionId, tag: lowerer.armTag(unionId, present[0]), value, type: present[0], loc };
+}
 /** The type a pattern element binds at — the checker's type of the bound
    * identifier, or of the nested pattern itself (its implied type). Null
    * when the type has no static mapping (the caller fences). */
@@ -2138,13 +2164,9 @@ function undefArmDefault(lowerer, blame, init, value, bodyT) {
     const dflt = lowerer.lowerExprExpecting(init, bodyT);
     return { kind: "ternary", cond: isUndef, then: dflt, else_: present, type: bodyT, loc };
 }
-/** `[a = dflt]` over an ARRAY source: the default fires when the position
-   * is past the end OR holds undefined (JS's one rule — both spell the
-   * read as undefined there), so the defaulted read carries a bounds test
-   * where the plain read would trap (the array divergence's carve-out).
-   * Elements with an undefined arm land in a hidden temp first (in-bounds
-   * undefined and past-the-end collapse to the same arm), then the
-   * ordinary undefined-arm default applies. */
+/** An array binding default tests the value produced by the read. Holes,
+   * out-of-range positions, and explicit undefined share the same arm.
+   * Typed-array reads retain the separate bounds check below. */
 function arrayPositionDefault(lowerer, el, read, srcRef, index, elemT, out) {
     const name = el.name; // callers skip nameless elisions
     const bodyT = patternBindingType(lowerer, name);
@@ -2157,6 +2179,11 @@ function arrayPositionDefault(lowerer, el, read, srcRef, index, elemT, out) {
    * arrives from the existing binding instead of the checker. */
 function arrayPositionDefaultValue(lowerer, blame, init, read, srcRef, index, elemT, bodyT, out) {
     const loc = read.loc;
+    if (read.type.kind === "union" && lowerer.armTag(read.type.unionId, UNDEFINED_T) >= 0) {
+        const tmp = lowerer.declareHiddenLocal("%delem", read.type);
+        out.push({ kind: "varDecl", localId: tmp.id, init: read, loc });
+        return undefArmDefault(lowerer, blame, init, varRef(tmp.id, read.type, loc), bodyT);
+    }
     // The unit-only element (a declared-empty-tuple source riding the
     // array representation): every read is undefined — the default IS the
     // binding.
@@ -2213,6 +2240,15 @@ function arrayPositionDefaultValue(lowerer, blame, init, read, srcRef, index, el
         loc,
     };
 }
+/** Array rest copies values and materializes holes. Removing the prefix
+   * through the copying splice primitive preserves the payload ABI. */
+function arrayRestValue(receiver, from, type, loc) {
+    return {
+        kind: "arrIntrinsic", method: "toSpliced", receiver,
+        args: [numLit(0, loc), numLit(from, loc), { kind: "arrayLit", elems: [], type, loc }],
+        type, loc,
+    };
+}
 /** The fresh tail for `[head, ...rest]` over a TUPLE source, packed under
    * the checker's own rest type: an ARRAY of the remaining positions (each
    * read coercing into the element type) or a tuple RECORD when the
@@ -2790,12 +2826,31 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(name));
                 return mapped === null || (lowerer.dynamic && jsvalFlavoredType(mapped));
             })();
-        const type = dynStays ? DYN : lowerer.irTypeOf(name);
+        let type = dynStays ? DYN : lowerer.runtimeOptionalBindingType(name, lowerer.irTypeOf(name)) ?? lowerer.irTypeOf(name);
         if (type.kind === "void")
             lowerer.badType(name, lowerer.typeOf(name));
+        // Array destructuring positions are ordinary indexed reads. When the
+        // checker was built without noUncheckedIndexedAccess it still spells
+        // the binding as the bare element type, but the runtime value carries
+        // the same `T | undefined` possibility as a direct array read. Adopt
+        // that union for an unannotated pattern binding so undefined survives
+        // through later locals, templates, operators, and narrowing instead
+        // of being extracted with a checked arm read.
+        let runtimeOptional = false;
+        if (!dynStays && value.type.kind === "union" &&
+            lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
+            typeEquals(lowerer.stripUndefinedArm(value.type), type)) {
+            type = value.type;
+            runtimeOptional = true;
+        }
         const coerced = lowerer.coerceInto(name, value, type);
         const local = lowerer.declareLocal(name, name.text, type, isLet);
         out.push({ kind: "varDecl", localId: local.id, init: coerced, loc });
+        if (runtimeOptional) {
+            const runtimeOptionalRoot = lowerer.runtimeOptionalRootOf(local);
+            lowerer.runtimeOptionalLocals.add(runtimeOptionalRoot);
+            lowerer.runtimeOptionalStorageLocals.add(runtimeOptionalRoot);
+        }
         return;
     }
     const tmp = lowerer.declareHiddenLocal("%destr", value.type);
@@ -3026,8 +3081,23 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // (statics are zero/NULL-initialized; uninitialized globals need no
     // statement at all).
     const declSymbol = lowerer.checker.getSymbolAtLocation(decl.name);
-    const g = declSymbol ? lowerer.globalsBySymbol.get(declSymbol) : undefined;
+    const g = ts.isIdentifier(decl.name)
+        ? lowerer.globalOf(decl.name)
+        : (declSymbol ? lowerer.globalsBySymbol.get(declSymbol) : undefined);
     if (g) {
+        let promotedGlobal = lowerer.runtimeOptionalBindingType(decl.name, g.type);
+        if (g.type.kind === "func" && decl.initializer !== undefined && ts.isIdentifier(decl.initializer)) {
+            const sig = lowerer.fnSigOf(decl.initializer);
+            if (sig) {
+                promotedGlobal = {
+                    ...g.type,
+                    params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
+                    ret: sig.returnType,
+                };
+            }
+        }
+        if (!typeEquals(promotedGlobal, g.type))
+            g.type = promotedGlobal;
         if (!decl.initializer) {
             // `let x: string | undefined;` at file scope: READABLE before any
             // assignment — JS gives undefined, so the slot must hold the
@@ -3048,7 +3118,16 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 return { kind: "assign", localId: g.id, value: wrapped, loc: locOf(decl) };
             return null;
         }
-        const init = lowerer.lowerExprExpecting(decl.initializer, g.type);
+        const raw = lowerVariableInitializer(lowerer, decl.initializer);
+        const arithmetic = raw.type.kind === "union"
+            ? lowerer.unions.get(raw.type.unionId)?.arms
+            : undefined;
+        if (g.type.kind === "string" && arithmetic?.length === 2 &&
+            arithmetic.some((a) => a.kind === "f64") && arithmetic.some((a) => a.kind === "string")) {
+            g.type = raw.type;
+            lowerer.runtimeOptionalArithmeticGlobals.add(g);
+        }
+        const init = lowerer.coerceInto(decl.initializer, raw, g.type);
         return { kind: "assign", localId: g.id, value: init, loc: locOf(decl) };
     }
     // A forward-captured const pre-declared as a TDZ box (an earlier
@@ -3108,7 +3187,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     try {
         init = immediatelyGuardedAbsenceProbe(lowerer, decl)
             ? (lowerAbsenceProbe(lowerer, decl.initializer) ?? lowerer.lowerExpr(decl.initializer))
-            : lowerer.lowerExpr(decl.initializer);
+            : lowerVariableInitializer(lowerer, decl.initializer);
     }
     catch (e) {
         if (e instanceof PoisonError) {
@@ -3194,12 +3273,30 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // and TypeScript's fresh-array probe idioms; an explicit annotation keeps
     // the caller's checked slot contract.
     let runtimeOptional = false;
-    if (!decl.type && type !== null && init.type.kind === "union" &&
+    if (type !== null && init.type.kind === "union" &&
+        lowerer.armTag(init.type.unionId, UNDEFINED_T) >= 0) {
+        const present = lowerer.stripUndefinedArm(init.type);
+        if (!typeEquals(present, type) && lowerer.widthLiftPlan(present, type) !== null) {
+            const widened = type.kind === "union" ? lowerer.withUndefinedArmOf(type) : lowerer.withUndefinedArm(type);
+            if (widened && lowerer.widthLiftPlan(init.type, widened) !== null) {
+                type = widened;
+                runtimeOptional = true;
+            }
+        }
+    }
+    if (type !== null && init.type.kind === "union" &&
         lowerer.armTag(init.type.unionId, UNDEFINED_T) >= 0 &&
         typeEquals(lowerer.stripUndefinedArm(init.type), type)) {
         type = init.type;
         runtimeOptional = true;
     }
+    if (type?.kind === "array" && init.type.kind === "array" &&
+        init.type.elem.kind === "union" &&
+        lowerer.armTag(init.type.elem.unionId, UNDEFINED_T) >= 0 &&
+        typeEquals(lowerer.stripUndefinedArm(init.type.elem), type.elem)) {
+        type = init.type;
+        runtimeOptional = true;
+    }
     // A JS binding whose checker type spells a FUNCTION but whose VALUE is
     // already checked-dynamic (`const cb = mustCall(fn)` — the helper's
     // return rides its own box): keep the box. Extracting into the spelled
@@ -3241,6 +3338,20 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     if (!type)
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
+    const arithmeticType = decl.initializer ? lowerer.runtimeOptionalArithmeticTypes.get(decl.initializer) : undefined;
+    const isStringArithmeticUnion = (t) => {
+        if (t.kind !== "union")
+            return false;
+        const arms = lowerer.unions.get(t.unionId)?.arms;
+        return !!arms && arms.length === 2 &&
+            arms.some((a) => a.kind === "f64") && arms.some((a) => a.kind === "string");
+    };
+    const runtimeStringArithmetic = type?.kind === "string" &&
+        ((arithmeticType && typeEquals(arithmeticType, init.type)) || isStringArithmeticUnion(init.type));
+    if (runtimeStringArithmetic) {
+        type = init.type;
+    }
+    type = lowerer.runtimeOptionalBindingType(decl.name, type);
     // `const x: void = undefined` / `let y: undefined = undefined`: the
     // unit-only union — the initializer's unit literal wraps into its arm
     // like any optional completion. Non-literal void initializers (a
@@ -3333,6 +3444,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
     init = lowerer.coerceInto(decl.initializer, init, type);
     const local = lowerer.declareLocal(decl.name, decl.name.text, type, isLet);
+    if (runtimeStringArithmetic && isStringArithmeticUnion(init.type)) {
+        lowerer.runtimeOptionalArithmeticLocals.add(lowerer.runtimeOptionalRootOf(local));
+    }
     if (runtimeOptional) {
         const runtimeOptionalRoot = lowerer.runtimeOptionalRootOf(local);
         lowerer.runtimeOptionalLocals.add(runtimeOptionalRoot);
@@ -3340,6 +3454,40 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
+function lowerVariableInitializer(lowerer, node) {
+    let value = node;
+    while (ts.isParenthesizedExpression(value) ||
+        ts.isAsExpression(value) ||
+        ts.isTypeAssertion(value) ||
+        ts.isSatisfiesExpression(value)) {
+        value = value.expression;
+    }
+    if (!ts.isObjectLiteralExpression(value))
+        return lowerer.lowerExpr(node);
+    const previous = new Map();
+    for (const property of value.properties) {
+        if (!ts.isPropertyAssignment(property) || !ts.isComputedPropertyName(property.name))
+            continue;
+        const keyNode = property.name.expression;
+        const optional = lowerer.runtimeOptionalIdentifierValue(keyNode)?.value ??
+            lowerAbsenceProbe(lowerer, keyNode);
+        if (!optional || lowerer.runtimeOptionalWidening(optional.type, STRING) === null)
+            continue;
+        previous.set(keyNode, lowerer.chainRecvByNode.get(keyNode));
+        lowerer.chainRecvByNode.set(keyNode, lowerer.ensureString(optional, keyNode));
+    }
+    try {
+        return lowerer.lowerExpr(node);
+    }
+    finally {
+        for (const [keyNode, prior] of previous) {
+            if (prior)
+                lowerer.chainRecvByNode.set(keyNode, prior);
+            else
+                lowerer.chainRecvByNode.delete(keyNode);
+        }
+    }
+}
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
     if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
         return false;
@@ -3432,8 +3580,8 @@ export function lowerSwitch(lowerer, stmt) {
    * exactly `disc === test`), because the backend switch compares plain
    * primitives only. The desugar is JS-exact for the shape it accepts and
    * fences everything it cannot reproduce:
-   * - the discriminant rides every test, so it must be a plain
-   *   side-effect-free read (bind it to a const first otherwise);
+   * - the discriminant evaluates exactly once; effectful values stabilize
+   *   in a hidden local that every generated equality test reuses;
    * - tests evaluate lazily in source order (the chain's short-circuit IS
    *   the switch's test order — grouped empty cases `case a: case b:` OR
    *   their tests, still in order);
@@ -3452,8 +3600,15 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
     if (disc.type.kind !== "union")
         throw new InternalCompilerError("lowerer bug: non-union disc");
     const unionType = disc.type;
-    if (!pureReemittable(disc) || !lowerer.eqComparableUnion(unionType.unionId)) {
-        lowerer.unsupported("SC1090", stmt.expression, "switch on union-typed values that aren't plain reads (the tests re-read the discriminant — bind it to a const first, or switch on a discriminant field)");
+    if (!lowerer.eqComparableUnion(unionType.unionId)) {
+        lowerer.unsupported("SC1090", stmt.expression, "switch on a union whose arms do not have static equality");
+    }
+    const prefix = [];
+    let stableDisc = disc;
+    if (!pureReemittable(disc)) {
+        const temp = lowerer.declareHiddenLocal("%switch", unionType);
+        prefix.push({ kind: "varDecl", localId: temp.id, init: disc, loc });
+        stableDisc = { kind: "varRef", localId: temp.id, type: unionType, loc };
     }
     const clauses = stmt.caseBlock.clauses;
     // An unlabeled break at a clause's END exits the switch — the chain's
@@ -3480,13 +3635,19 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
             }
         }
     }
+    const statementExits = (last) => {
+        if (!last)
+            return false;
+        if ((ts.isBreakStatement(last) && !last.label) ||
+            ts.isReturnStatement(last) ||
+            ts.isThrowStatement(last) ||
+            ts.isContinueStatement(last))
+            return true;
+        return ts.isBlock(last) && statementExits(last.statements[last.statements.length - 1]);
+    };
     const exits = (clause) => {
         const last = clause.statements[clause.statements.length - 1];
-        return (!!last &&
-            ((ts.isBreakStatement(last) && !last.label) ||
-                ts.isReturnStatement(last) ||
-                ts.isThrowStatement(last) ||
-                ts.isContinueStatement(last)));
+        return statementExits(last);
     };
     // The whole case-body sequence is ONE lexical scope, like the real
     // switch lowering.
@@ -3515,14 +3676,14 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
                 // never matches; coercing the literal into the union would hit
                 // the stranded-arm trap and throw where JS just skips the case).
                 const unitTest = test.kind === "unitLit"
-                    ? lowerer.lowerUnitComparison(disc, test, false, locOf(clause.expression))
+                    ? lowerer.lowerUnitComparison(stableDisc, test, false, locOf(clause.expression))
                     : null;
                 pendingTests.push(unitTest ?? {
                     kind: "unionEq",
                     unionId: unionType.unionId,
                     negated: false,
                     sameValue: false,
-                    left: disc,
+                    left: stableDisc,
                     right: lowerer.coerceInto(clause.expression, test, unionType),
                     type: BOOL,
                     loc: locOf(clause.expression),
@@ -3563,7 +3724,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
             }
             chain = [{ kind: "if", cond, then: g.body, else_: chain.length > 0 ? chain : null, loc }];
         }
-        return { kind: "block", body: chain, loc };
+        return { kind: "block", body: [...prefix, ...chain], loc };
     }
     finally {
         lowerer.scopes.pop();
@@ -3650,7 +3811,10 @@ function lowerDeleteStatement(lowerer, expr) {
             return { kind: "strLit", value: target.name.text, type: STRING, loc: locOf(target.name) };
         }
         const keyNode = target.argumentExpression;
-        const key = lowerer.lowerExpr(keyNode);
+        let key = lowerer.lowerExpr(keyNode);
+        if (lowerer.runtimeOptionalWidening(key.type, STRING) !== null) {
+            key = lowerer.ensureString(key, keyNode);
+        }
         if (key.type.kind !== "string") {
             lowerer.unsupported("SC1090", keyNode, `'delete' with '${lowerer.fmt(key.type)}' keys (index-signature and env keys are strings)`);
         }
@@ -4135,6 +4299,21 @@ export function lowerExprStatement(lowerer, expr) {
             if (ts.isElementAccessExpression(expr.left))
                 return lowerer.lowerElementWrite(expr);
             if (ts.isPropertyAccessExpression(expr.left)) {
+                // Native arrays have a writable length property. The runtime grows
+                // by creating holes and truncates with RC-aware removal; keep this
+                // as a statement operation so invalid lengths can use the normal
+                // pending-exception path.
+                if (!expr.left.questionDotToken && expr.left.name.text === "length") {
+                    const arrayType = lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression));
+                    if (arrayType?.kind === "array") {
+                        const arr = lowerer.lowerExpr(expr.left.expression);
+                        if (arr.type.kind !== "array") {
+                            lowerer.unsupported("SC1090", expr.left.expression, "writing the length of an array-typed value that remains an island handle");
+                        }
+                        const length = lowerer.lowerExprExpecting(expr.right, F64);
+                        return { kind: "arraySetLength", arr, length, loc: locOf(expr) };
+                    }
+                }
                 // `process.env.NAME = v` — setenv(3): later env reads and spawned
                 // children observe the write, exactly Node. Values are strings
                 // (Node stringifies everything; a non-string RHS fences instead
@@ -4571,6 +4750,7 @@ function lowerCompoundToTarget(lowerer, expr, compound, target) {
     const loc = locOf(expr);
     const read = { kind: "varRef", localId: target.id, type: target.type, loc: locOf(expr.left) };
     const rhs = lowerer.lowerExpr(expr.right);
+    const numericRhs = lowerOptionalNumber(lowerer, rhs, loc);
     let value;
     if (target.type.kind === "jsval" || rhs.type.kind === "jsval") {
         const JS_COMPOUND = { "+": "add", "-": "sub", "*": "mul", "/": "div", "%": "mod", "**": "pow" };
@@ -4587,8 +4767,8 @@ function lowerCompoundToTarget(lowerer, expr, compound, target) {
     else if (compound === "+" && target.type.kind === "string") {
         value = { kind: "strConcat", left: read, right: lowerer.ensureString(rhs, expr.right), type: STRING, loc };
     }
-    else if (target.type.kind === "f64" && rhs.type.kind === "f64") {
-        value = { kind: "bin", op: compound, left: read, right: rhs, type: F64, loc };
+    else if (target.type.kind === "f64" && numericRhs.type.kind === "f64") {
+        value = { kind: "bin", op: compound, left: read, right: numericRhs, type: F64, loc };
     }
     else if ((target.type.kind === "dyn" || rhs.type.kind === "dyn") &&
         (target.type.kind === "dyn" || target.type.kind === "f64") &&
@@ -4843,6 +5023,16 @@ export function lowerDestructuringAssignParts(lowerer, target, rhs, loc) {
    * source-spelling TypeError machinery cannot apply), `blame` the node
    * fences point at. */
 function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
+    if (init.type.kind === "union") {
+        const source = lowerer.declareHiddenLocal("%destrSource", init.type);
+        const out = [{ kind: "varDecl", localId: source.id, init, loc }];
+        const value = varRef(source.id, init.type, loc);
+        const present = patternSourceValue(lowerer, value, ts.isArrayLiteralExpression(target), out, loc);
+        if (!typeEquals(present.type, init.type)) {
+            const sub = destructuringAssignInto(lowerer, target, present, rhs, blame, loc);
+            return { stmts: [...out, ...sub.stmts], value };
+        }
+    }
     // IR-string sources in JS files split two ways the carrier type
     // cannot: a STDLIB GLOBAL (`({ subtle } = globalThis.crypto)`) — the
     // declaration path binds member identity tokens into FRESH bindings,
@@ -5316,14 +5506,10 @@ function lowerAssignTargetInto(lowerer, out, targetNode, blame, dflt, valueOf) {
                 }
                 const idx = lowerer.declareHiddenLocal("%dtIdx", F64);
                 out.push({ kind: "varDecl", localId: idx.id, init: index, loc });
-                const value = lowerer.coerceInto(blame, valueOf(recvT.elem), recvT.elem);
-                out.push({
-                    kind: "arraySet",
-                    arr: { kind: "varRef", localId: recv.id, type: arr.type, loc },
-                    index: { kind: "varRef", localId: idx.id, type: F64, loc },
-                    value,
-                    loc,
-                });
+                const value = valueOf(recvT.elem);
+                const stored = lowerer.declareHiddenLocal("%dtValue", value.type);
+                out.push({ kind: "varDecl", localId: stored.id, init: value, loc });
+                out.push(arrayValueStore(lowerer, varRef(recv.id, arr.type, loc), varRef(idx.id, F64, loc), varRef(stored.id, value.type, loc), recvT.elem, loc));
                 return;
             }
         }
@@ -5499,11 +5685,9 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
                 loc: locOf(at),
             };
         }
-        // Plain arrays read by index — a pattern wider than the runtime
-        // array traps (the arrayGet discipline, divergence 4's policy; JS
-        // would answer undefined).
+        // Assignment patterns consume the same values as binding patterns.
         const elemType = srcType.elem;
-        return { kind: "arrayGet", arr: tmpRef(), index: { kind: "numLit", value: i, type: F64, loc: locOf(at) }, type: elemType, loc: locOf(at) };
+        return arrayValueRead(lowerer, tmpRef(), numLit(i, locOf(at)), elemType, locOf(at));
     };
     elements.forEach((el, i) => {
         if (ts.isOmittedExpression(el))
@@ -5556,7 +5740,7 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
                 }
                 return isTuple
                     ? tupleTailValue(lowerer, el, tmpRef, srcType, shape, i, targetT)
-                    : { kind: "arrIntrinsic", method: "slice", receiver: tmpRef(), args: [{ kind: "numLit", value: i, type: F64, loc: locOf(el) }], type: srcType, loc: locOf(el) };
+                    : arrayRestValue(tmpRef(), i, srcType, locOf(el));
             }
             if (isTuple && defaultNode !== null && targetT !== null && !shape.fields.some((f) => f.name === String(i))) {
                 // Past the tuple's end the read is always undefined — the default
@@ -5777,6 +5961,19 @@ export function lowerForOf(lowerer, stmt) {
     }
     iterSrc ??= stmt.expression;
     let iterable = lowerer.lowerExpr(iterSrc);
+    // A nested loop receiver can be an OOB-safe array read from the outer
+    // loop (`for (const row of grid) for (const cell of row)`). The checker
+    // sees the inner value as an array, while its runtime slot is array |
+    // undefined; validate the receiver before selecting the array iterator.
+    const checkerIterable = lowerer.mapTypeOf(lowerer.typeOf(iterSrc));
+    if (iterable.type.kind === "union" && lowerer.armTag(iterable.type.unionId, UNDEFINED_T) >= 0 && checkerIterable?.kind === "array") {
+        const present = lowerer.stripUndefinedArm(iterable.type);
+        const helper = present.kind === "array"
+            ? lowerer.narrowedArmHelper(iterable.type.unionId, present, locOf(iterSrc))
+            : null;
+        if (helper)
+            iterable = { kind: "call", callee: helper, args: [iterable], type: present, loc: locOf(iterSrc) };
+    }
     if (iterable.type.kind === "bytes") {
         return lowerForOfBytes(lowerer, stmt, iterable, labels);
     }
@@ -5902,6 +6099,29 @@ export function lowerForOf(lowerer, stmt) {
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
         }
     }
+    const elemValueT = arrayValueType(lowerer, iterable.type.elem);
+    // Native arrays retain their payload ABI; the loop binds the value yielded
+    // by Get, which is undefined for both holes and present undefined slots.
+    const sourceT = iterable.type;
+    const source = lowerer.declareHiddenLocal("%arrayIterator", sourceT);
+    const cursor = lowerer.declareHiddenLocal("%arrayCursor", F64);
+    cursor.mutable = true;
+    const forValues = (localId, body) => ({
+        kind: "block",
+        body: [
+            { kind: "varDecl", localId: source.id, init: iterable, loc: locOf(stmt) },
+            {
+                kind: "for",
+                init: { kind: "varDecl", localId: cursor.id, init: numLit(0, locOf(stmt)), loc: locOf(stmt) },
+                cond: { kind: "bin", op: "<", left: varRef(cursor.id, F64, locOf(stmt)), right: { kind: "arrIntrinsic", method: "length", receiver: varRef(source.id, sourceT, locOf(stmt)), args: [], type: F64, loc: locOf(stmt) }, type: BOOL, loc: locOf(stmt) },
+                update: { kind: "assign", localId: cursor.id, value: { kind: "bin", op: "+", left: varRef(cursor.id, F64, locOf(stmt)), right: numLit(1, locOf(stmt)), type: F64, loc: locOf(stmt) }, loc: locOf(stmt) },
+                body: [{ kind: "varDecl", localId, init: arrayValueRead(lowerer, varRef(source.id, sourceT, locOf(stmt)), varRef(cursor.id, F64, locOf(stmt)), sourceT.elem, locOf(stmt)), loc: locOf(stmt) }, ...body],
+                ...(labels && { labels }),
+                loc: locOf(stmt),
+            },
+        ],
+        loc: locOf(stmt),
+    });
     if (!ts.isVariableDeclarationList(stmt.initializer)) {
         // `for (x of xs)` over a PRE-DECLARED writable binding: JS assigns
         // the existing binding once per pass — one shared binding across
@@ -5914,18 +6134,18 @@ export function lowerForOf(lowerer, stmt) {
         while (ts.isParenthesizedExpression(target))
             target = target.expression;
         if (ts.isArrayLiteralExpression(target) || ts.isObjectLiteralExpression(target)) {
-            const elemType = iterable.type.elem;
+            const elemType = elemValueT;
             const loc = locOf(target);
             const tmp = lowerer.declareHiddenLocal("%vof", elemType);
             const elemRef = { kind: "varRef", localId: tmp.id, type: elemType, loc };
             const assigns = lowerDestructuringAssign(lowerer, target, elemRef, target, loc);
             const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-            return { kind: "forOf", localId: tmp.id, iterable, body: [assigns, ...body], ...(labels && { labels }), loc: locOf(stmt) };
+            return forValues(tmp.id, [assigns, ...body]);
         }
         if (ts.isIdentifier(target)) {
             const writable = lowerer.resolveWritable(target);
             if (writable) {
-                const elemType = iterable.type.elem;
+                const elemType = elemValueT;
                 const loc = locOf(target);
                 const tmp = lowerer.declareHiddenLocal("%vof", elemType);
                 const write = {
@@ -5935,7 +6155,7 @@ export function lowerForOf(lowerer, stmt) {
                     loc,
                 };
                 const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-                return { kind: "forOf", localId: tmp.id, iterable, body: [write, ...body], ...(labels && { labels }), loc: locOf(stmt) };
+                return forValues(tmp.id, [write, ...body]);
             }
         }
         lowerer.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
@@ -5955,13 +6175,13 @@ export function lowerForOf(lowerer, stmt) {
     if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
         lowerer.scopes.push(new Map());
         try {
-            const elemType = iterable.type.elem;
+            const elemType = elemValueT;
             const loc = locOf(decl.name);
             const tmp = lowerer.declareHiddenLocal("%destr", elemType);
             const binds = [];
             lowerer.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: elemType, loc }), elemType, isLet, binds);
             const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-            return { kind: "forOf", localId: tmp.id, iterable, body: [...binds, ...body], ...(labels && { labels }), loc: locOf(stmt) };
+            return forValues(tmp.id, [...binds, ...body]);
         }
         finally {
             lowerer.scopes.pop();
@@ -5977,7 +6197,7 @@ export function lowerForOf(lowerer, stmt) {
         // after the loop (both Node-exact for var).
         const varTarget = forOfVarTarget(lowerer, decl);
         if (varTarget) {
-            const elemType = iterable.type.elem;
+            const elemType = elemValueT;
             const loc = locOf(decl.name);
             const tmp = lowerer.declareHiddenLocal("%vof", elemType);
             const write = {
@@ -5987,11 +6207,16 @@ export function lowerForOf(lowerer, stmt) {
                 loc,
             };
             const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-            return { kind: "forOf", localId: tmp.id, iterable, body: [write, ...body], ...(labels && { labels }), loc: locOf(stmt) };
+            return forValues(tmp.id, [write, ...body]);
+        }
+        const local = lowerer.declareLocal(decl.name, decl.name.text, elemValueT, isLet);
+        if (!typeEquals(elemValueT, sourceT.elem)) {
+            const root = lowerer.runtimeOptionalRootOf(local);
+            lowerer.runtimeOptionalLocals.add(root);
+            lowerer.runtimeOptionalStorageLocals.add(root);
         }
-        const local = lowerer.declareLocal(decl.name, decl.name.text, iterable.type.elem, isLet);
         const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-        return { kind: "forOf", localId: local.id, iterable, body, ...(labels && { labels }), loc: locOf(stmt) };
+        return forValues(local.id, body);
     }
     finally {
         lowerer.scopes.pop();
@@ -6087,8 +6312,9 @@ function lowerForOfStoredNumericIterator(lowerer, stmt, state, labels) {
             type: F64,
             loc,
         };
+    const valueT = sourceT.kind === "array" ? arrayValueType(lowerer, F64) : F64;
     const sourceValue = () => sourceT.kind === "array"
-        ? { kind: "arrayGet", arr: sourceRef(), index: indexRef(), type: F64, loc }
+        ? arrayValueRead(lowerer, sourceRef(), indexRef(), F64, loc)
         : {
             kind: "bytesIntrinsic",
             method: "get",
@@ -6102,9 +6328,14 @@ function lowerForOfStoredNumericIterator(lowerer, stmt, state, labels) {
     try {
         const varTarget = exprTarget ?? (decl ? forOfVarTarget(lowerer, decl) : null);
         const value = varTarget
-            ? lowerer.declareHiddenLocal("%numiterValue", F64)
-            : lowerer.declareLocal(decl.name, decl.name.text, F64, isLet);
-        const valueRef = varRef(value.id, F64, loc);
+            ? lowerer.declareHiddenLocal("%numiterValue", valueT)
+            : lowerer.declareLocal(decl.name, decl.name.text, valueT, isLet);
+        if (!varTarget && valueT.kind === "union") {
+            const root = lowerer.runtimeOptionalRootOf(value);
+            lowerer.runtimeOptionalLocals.add(root);
+            lowerer.runtimeOptionalStorageLocals.add(root);
+        }
+        const valueRef = varRef(value.id, valueT, loc);
         const blame = decl?.name ?? exprTargetNode ?? stmt.initializer;
         const head = [
             {