@scriptc/compiler 0.0.36 → 0.1.2

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

@@ -1,10 +1,12 @@
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
- * flow (if/while/for/for-of/do, switch, try/catch, jumps with the
- * finally-crossing fence), and blocked-binding poisoning. */
+ * flow (if/while/for/for-of/do, switch, try/catch, abrupt completions),
+ * explicit resource management, and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
-import { lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
+import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
+import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
+import { lowerForAwaitBuiltin } from "./lower-async-iteration.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";
 import { enforceLibBoundary } from "./lib-boundary.js";
@@ -13,21 +15,263 @@ 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 { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
+import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
-import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf } from "./lower-stream.js";
+import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 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, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.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";
+import { constituentTypes } from "../ts7/checker.js";
+import { npmStaticPackageOfPath } from "../npm-static.js";
+import { fenceNodeModuleMutation } from "./lower-node-module.js";
+/** An opted package's directly-returned empty array may take the function's
+ * explicit static return element type. This is the common JS accumulator
+ * shape (`const result = []; result.push(value); return result`) and is
+ * narrower than treating every evolving array in the function alike. */
+function npmStaticReturnedEmptyArrayType(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name) ||
+        decl.initializer === undefined ||
+        !ts.isArrayLiteralExpression(decl.initializer) ||
+        decl.initializer.elements.length !== 0 ||
+        !isJsSourceFile(decl.getSourceFile()) ||
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) === null ||
+        lowerer.ctx.returnType.kind !== "array") {
+        return null;
+    }
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (symbol === undefined)
+        return null;
+    let owner = decl.parent;
+    while (owner !== undefined && !ts.isFunctionLike(owner))
+        owner = owner.parent;
+    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    if (ownerBody === undefined || !ts.isBlock(ownerBody))
+        return null;
+    let returned = false;
+    ts.walkPreorder(ownerBody, (node) => {
+        if (node !== ownerBody && ts.isFunctionLike(node))
+            return "skip";
+        if (!ts.isReturnStatement(node) || node.expression === undefined)
+            return undefined;
+        let expression = node.expression;
+        while (ts.isParenthesizedExpression(expression))
+            expression = expression.expression;
+        if (ts.isIdentifier(expression) && lowerer.checker.getSymbolAtLocation(expression) === symbol) {
+            returned = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return returned ? lowerer.ctx.returnType : null;
+}
+/** A JS loop cursor in opted package source can be initialized with `T`
+ * and later assigned a nullable self link (`cursor = cursor.parent`). Keep
+ * that optional value in the local so the next loop condition, rather than
+ * the assignment, narrows it. */
+function npmStaticOptionalSelfWriteType(lowerer, decl, initial) {
+    if (!ts.isIdentifier(decl.name) ||
+        !isJsSourceFile(decl.getSourceFile()) ||
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) === null ||
+        initial.kind === "union") {
+        return null;
+    }
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (symbol === undefined)
+        return null;
+    let owner = decl.parent;
+    while (owner !== undefined && !ts.isFunctionLike(owner))
+        owner = owner.parent;
+    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    if (ownerBody === undefined || !ts.isBlock(ownerBody))
+        return null;
+    let candidate = null;
+    let invalid = false;
+    ts.walkPreorder(ownerBody, (node) => {
+        if (node !== ownerBody && ts.isFunctionLike(node))
+            return "skip";
+        if (ts.isBinaryExpression(node)) {
+            let left = node.left;
+            while (ts.isParenthesizedExpression(left))
+                left = left.expression;
+            if (ts.isIdentifier(left) && lowerer.checker.getSymbolAtLocation(left) === symbol) {
+                if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+                    invalid = true;
+                    return "stop";
+                }
+                const written = lowerer.mapTypeOf(lowerer.typeOf(node.right));
+                if (written !== null && typeEquals(written, initial))
+                    return undefined;
+                const arms = written?.kind === "union" ? lowerer.unions.get(written.unionId)?.arms : undefined;
+                if (written?.kind !== "union" ||
+                    arms === undefined ||
+                    !arms.some((arm) => typeEquals(arm, initial)) ||
+                    !arms.every((arm) => typeEquals(arm, initial) || isUnitType(arm)) ||
+                    (candidate !== null && !typeEquals(candidate, written))) {
+                    invalid = true;
+                    return "stop";
+                }
+                candidate = written;
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            ts.isIdentifier(node.operand) &&
+            lowerer.checker.getSymbolAtLocation(node.operand) === symbol) {
+            invalid = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return invalid ? null : candidate;
+}
+function isAwaitUsing(list) {
+    return (list.flags & ts.NodeFlags.AwaitUsing) === ts.NodeFlags.AwaitUsing;
+}
+function stdlibTypeNamed(lowerer, node, name) {
+    const visit = (t) => {
+        if (t.flags & ts.TypeFlags.Union)
+            return constituentTypes(t).some(visit);
+        const sym = t.getAliasSymbol() ?? t.getSymbol();
+        return sym?.name === name && lowerer.checker.declarationsOf(sym).some((d) => lowerer.isStdlibFile(d.getSourceFile()));
+    };
+    return visit(lowerer.typeOf(node));
+}
+function cleanupCall(lowerer, node, value, awaited) {
+    const loc = locOf(node);
+    if (value.type.kind === "object") {
+        const info = lowerer.classes.get(value.type.className);
+        if (!info)
+            lowerer.flushDeferredClass(value.type.className);
+        const asyncFound = awaited && info ? lowerer.findMethodOn(info, "sym:asyncDispose") : null;
+        const syncFound = info ? lowerer.findMethodOn(info, "sym:dispose") : null;
+        const member = asyncFound ? "sym:asyncDispose" : syncFound ? "sym:dispose" : null;
+        const found = asyncFound ?? syncFound;
+        if (!info || !member || !found)
+            return null;
+        if (found.sig.params.length !== 0) {
+            lowerer.unsupported("SC1090", node, `${member === "sym:asyncDispose" ? "[Symbol.asyncDispose]" : "[Symbol.dispose]"} methods with parameters`);
+        }
+        return {
+            call: lowerer.accessorCall(value.type.className, member, value, [], found.sig.ret, loc),
+            async: member === "sym:asyncDispose",
+        };
+    }
+    if (value.type.kind === "fileHandle") {
+        if (!awaited)
+            lowerer.unsupported("SC1090", node, "synchronous 'using' with an async-only FileHandle (use 'await using')");
+        return {
+            call: { kind: "libCall", fn: "fileHandle.close", args: [value], type: { kind: "promise", inner: VOID }, loc },
+            async: true,
+        };
+    }
+    if (value.type.kind === "child") {
+        return {
+            call: {
+                kind: "libCall",
+                fn: "child.kill",
+                args: [value, { kind: "strLit", value: "SIGTERM", type: STRING, loc }],
+                type: BOOL,
+                loc,
+            },
+            async: false,
+        };
+    }
+    if (value.type.kind === "f64") {
+        if (stdlibTypeNamed(lowerer, node, "Timeout")) {
+            return { call: { kind: "libCall", fn: "timers.clearTimeout", args: [value], type: VOID, loc }, async: false };
+        }
+        if (stdlibTypeNamed(lowerer, node, "Immediate")) {
+            return { call: { kind: "libCall", fn: "timers.clearImmediate", args: [value], type: VOID, loc }, async: false };
+        }
+        if (stdlibTypeNamed(lowerer, node, "Interface")) {
+            return { call: { kind: "libCall", fn: "rl.close", args: [value], type: VOID, loc }, async: false };
+        }
+    }
+    return null;
+}
+function cleanupForValue(lowerer, node, value, awaited) {
+    const loc = locOf(node);
+    if (isUnitType(value.type))
+        return [];
+    if (value.type.kind === "union") {
+        const def = lowerer.unions.get(value.type.unionId);
+        if (!def)
+            throw new InternalCompilerError(`lowerer bug: unknown using union ${value.type.unionId}`);
+        const out = [];
+        for (let tag = 0; tag < def.arms.length; tag++) {
+            const arm = def.arms[tag];
+            if (isUnitType(arm))
+                continue;
+            const narrowed = { kind: "unionNarrow", unionId: value.type.unionId, tag, value, type: arm, loc };
+            const body = cleanupForValue(lowerer, node, narrowed, awaited);
+            out.push({
+                kind: "if",
+                cond: { kind: "unionIsTag", unionId: value.type.unionId, tag, negated: false, value, type: BOOL, loc },
+                then: body,
+                else_: null,
+                loc,
+            });
+        }
+        return out;
+    }
+    const cleanup = cleanupCall(lowerer, node, value, awaited);
+    if (!cleanup) {
+        lowerer.unsupported("SC1090", node, `disposing values of type '${lowerer.fmt(value.type)}' (use a class with a zero-parameter [Symbol.dispose] or [Symbol.asyncDispose] method, or a supported Node resource)`);
+    }
+    const call = cleanup.call;
+    if (cleanup.async) {
+        if (call.type.kind !== "promise" || call.type.inner.kind !== "void") {
+            lowerer.unsupported("SC1090", node, "[Symbol.asyncDispose] methods whose result is not Promise<void>");
+        }
+        return [{ kind: "exprStmt", expr: { kind: "awaitExpr", value: call, type: VOID, loc }, loc }];
+    }
+    const out = [{ kind: "exprStmt", expr: call, loc }];
+    if (awaited)
+        out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "async.hop", args: [], type: VOID, loc }, loc });
+    return out;
+}
+function lowerUsingStatement(lowerer, stmt) {
+    if (ts.isSourceFile(stmt.parent)) {
+        lowerer.unsupported("SC1090", stmt, "top-level 'using' declarations (wrap the resource lifetime in a block or function)");
+    }
+    if (ts.isCaseClause(stmt.parent) || ts.isDefaultClause(stmt.parent)) {
+        lowerer.unsupported("SC1090", stmt, "'using' declarations directly in switch clauses (wrap the clause body in a block)");
+    }
+    const awaited = isAwaitUsing(stmt.declarationList);
+    if (awaited && !lowerer.ctx.isAsync) {
+        lowerer.unsupported("SC1090", stmt, "'await using' outside an async function or top-level-await module");
+    }
+    const registrations = [];
+    for (const decl of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name))
+            lowerer.unsupported("SC1031", decl.name);
+        if (decl.initializer === undefined)
+            lowerer.unsupported("SC1090", decl, "a 'using' declaration without an initializer");
+        const acquire = lowerer.lowerVarDecl(decl, false);
+        if (!acquire)
+            throw new InternalCompilerError("lowerer bug: using declaration emitted no acquisition");
+        const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+        if (!symbol)
+            throw new InternalCompilerError("lowerer bug: using declaration has no symbol");
+        const binding = lowerer.bindingIn(lowerer.ctx, symbol) ?? lowerer.globalsBySymbol.get(symbol) ?? null;
+        if (!binding)
+            throw new InternalCompilerError("lowerer bug: using declaration has no runtime binding");
+        const value = varRef(binding.id, binding.type, locOf(decl.name));
+        const cleanup = cleanupForValue(lowerer, decl.name, value, awaited);
+        registrations.push({ acquire, cleanup, loc: locOf(decl) });
+    }
+    return registrations;
+}
 /** `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
@@ -112,6 +356,7 @@ export function provenanceElidedConstDecl(lowerer, decl) {
    * `let a = 1, b = a + 1;`) but is counted once. */
 export function lowerStmts(lowerer, stmts) {
     const out = [];
+    const usingMarkers = [];
     // JAVASCRIPT sources defer their compile fences to runtime (the
     // JS-input design: no annotations exist to change what lowers, so a
     // statement whose construct has no static lowering compiles to a
@@ -143,7 +388,25 @@ export function lowerStmts(lowerer, stmts) {
             }
             const diagsBefore = lowerer.diags.length;
             try {
-                const lowered = lowerer.lowerStmt(stmt);
+                let lowered;
+                let appended = false;
+                if (ts.isVariableStatement(stmt) &&
+                    (stmt.declarationList.flags & ts.NodeFlags.Using) !== 0) {
+                    const registrations = lowerUsingStatement(lowerer, stmt);
+                    const accounting = [];
+                    for (const registration of registrations) {
+                        out.push(registration.acquire);
+                        accounting.push(registration.acquire, ...registration.cleanup);
+                        if (registration.cleanup.length > 0) {
+                            usingMarkers.push({ start: out.length, cleanup: registration.cleanup, loc: registration.loc });
+                        }
+                    }
+                    lowered = accounting;
+                    appended = true;
+                }
+                else {
+                    lowered = lowerer.lowerStmt(stmt);
+                }
                 // The lib-boundary chokepoint (lib-boundary.ts): checked-dynamic
                 // arguments that reached builtin-call slots without the checked
                 // coercion get their dynCheck here, and the uncoercible ones
@@ -152,10 +415,12 @@ export function lowerStmts(lowerer, stmts) {
                 // deferred rejection.
                 if (lowered)
                     enforceLibBoundary(lowerer, lowered);
-                if (Array.isArray(lowered))
-                    out.push(...lowered);
-                else if (lowered)
-                    out.push(lowered);
+                if (!appended) {
+                    if (Array.isArray(lowered))
+                        out.push(...lowered);
+                    else if (lowered)
+                        out.push(lowered);
+                }
                 // Island accounting (--dynamic coverage): a statement that lowered
                 // but carries island constructs compiles DYNAMICALLY — its work
                 // runs in the embedded engine, and the report says so instead of
@@ -214,6 +479,23 @@ export function lowerStmts(lowerer, stmts) {
                 }
             }
         }
+        // Each acquisition protects the remainder of its lexical statement
+        // list. Folding from the last registration outward produces the
+        // spec's LIFO nesting and ensures a later initializer failure only
+        // disposes resources acquired before it.
+        for (let i = usingMarkers.length - 1; i >= 0; i--) {
+            const marker = usingMarkers[i];
+            const body = out.splice(marker.start);
+            out.push({
+                kind: "tryCatch",
+                tryBody: body,
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: marker.cleanup,
+                suppressFinallyErrors: true,
+                loc: marker.loc,
+            });
+        }
     }
     finally {
         lowerer.activeStmtLists.pop();
@@ -588,44 +870,6 @@ export function lowerScopedBlock(lowerer, stmt) {
         lowerer.scopes.pop();
     }
 }
-/** The finally fences. `return` crossing OUT of a try/catch body guarded
-   * by a finally is SUPPORTED now (the backend's pending-return path runs
-   * every crossed finally inner-to-outer before the function returns, the
-   * value snapshotted first — Node-exact); what stays rejected is (a) any
-   * jump out of a finally BLOCK itself (a return there would REPLACE a
-   * pending completion — clearing a still-propagating exception or
-   * abandoning a pending return, a model the emitter doesn't implement),
-   * and (b) break/continue crossing a try-with-finally (their targets bind
-   * inside the function; the pending-action plumbing exists only for
-   * return, the shape real code needs). Rejected, not miscompiled. Plain
-   * try/catch is transparent to jumps (it never appears in ctl). A LABELED
-   * jump walks outward past every construct (labeled targets can be
-   * arbitrarily far out) until the entry carrying its label, applying the
-   * same finally fences to everything crossed on the way. */
-export function rejectJumpCrossingFinally(lowerer, kw, stmt, label) {
-    const ctl = lowerer.ctx.ctl;
-    for (let i = ctl.length - 1; i >= 0; i--) {
-        const c = ctl[i];
-        if (c.kind === "finallyBlock") {
-            lowerer.unsupported("SC1090", stmt, `'${kw}' out of a 'finally' block (it would replace the pending completion — restructure so the finally only cleans up)`);
-        }
-        if (c.kind === "tryFinally") {
-            if (kw !== "return") {
-                lowerer.unsupported("SC1090", stmt, `'${kw}' crossing a 'finally' block`);
-            }
-            continue; // return runs the finally on the way out — supported
-        }
-        if (kw === "return")
-            continue; // return crosses every construct
-        if (label !== undefined) {
-            if (c.labels?.includes(label))
-                return; // the labeled target — binds here
-            continue; // an inner construct the labeled jump exits
-        }
-        if (c.kind === "loop" || (kw === "break" && c.kind === "switch"))
-            return; // binds inside the region
-    }
-}
 /** `lbl: stmt` — labeled statements. A label chain collapses to one name
    * list (`a: b: while ...` — both names target the same loop, JS-exact).
    * Loops and switches take the labels DIRECTLY (a labeled continue needs
@@ -719,7 +963,6 @@ export function lowerStmt(lowerer, stmt) {
     if (ts.isLabeledStatement(stmt))
         return lowerLabeled(lowerer, stmt);
     if (ts.isReturnStatement(stmt)) {
-        lowerer.rejectJumpCrossingFinally("return", stmt);
         // Implicit-any instance RETURN INFERENCE (lower-calls'
         // resolveInferredReturn): the value lowers BARE and the statement
         // records itself — the post-pass settles the instance's return type
@@ -783,10 +1026,8 @@ export function lowerStmt(lowerer, stmt) {
             if (!target || (kw === "continue" && target.kind !== "loop")) {
                 lowerer.unsupported("SC1050", stmt, `'${kw} ${label}' targeting this statement form (the labeled statement lowers through a desugar that has no label point)`);
             }
-            lowerer.rejectJumpCrossingFinally(kw, stmt, label);
             return { kind: kw, label, loc: locOf(stmt) };
         }
-        lowerer.rejectJumpCrossingFinally(kw, stmt);
         // tsc rejects break outside loops/switches and continue outside loops,
         // so the context is always valid here (the validator re-checks).
         return { kind: kw, loc: locOf(stmt) };
@@ -1264,6 +1505,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 +1746,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 +2081,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 +2404,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 +2419,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 +2480,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 +3066,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);
@@ -2849,6 +3144,95 @@ export function lowerVarDeclList(lowerer, list) {
         throw new InternalCompilerError("lowerer bug: for-init declarator resolved to a global");
     return lowered;
 }
+/** A single static type for an initializer-less JavaScript `let` whose
+ * later plain writes all agree. An evolving JS local reads as `undefined`
+ * until control flow proves a write, so a scalar slot is sound only when
+ * every ordinary use already has that concrete flow type. Any closure
+ * capture stays checked-dynamic: it can observe the local before an outer
+ * assignment, and the checker deliberately leaves captured evolving lets
+ * broad. */
+function inferredEvolvingLetType(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name))
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    const scope = decl.parent.parent.parent;
+    if (symbol === undefined || (!ts.isBlock(scope) && !ts.isSourceFile(scope)))
+        return null;
+    const isPlainAssignmentTarget = (node) => {
+        let target = node;
+        while (ts.isParenthesizedExpression(target.parent) && target.parent.expression === target) {
+            target = target.parent;
+        }
+        const parent = target.parent;
+        return ts.isBinaryExpression(parent) &&
+            parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            parent.left === target;
+    };
+    const captures = (fn) => {
+        let captured = false;
+        ts.walkPreorder(fn, (node) => {
+            if (node !== fn &&
+                ts.isIdentifier(node) &&
+                lowerer.checker.getSymbolAtLocation(node) === symbol) {
+                captured = true;
+                return "stop";
+            }
+            return undefined;
+        });
+        return captured;
+    };
+    const writes = [];
+    const reads = [];
+    let invalid = false;
+    ts.walkPreorder(scope, (node) => {
+        if (node !== scope && ts.isFunctionLike(node)) {
+            if (captures(node))
+                invalid = true;
+            return "skip";
+        }
+        if (ts.isBinaryExpression(node)) {
+            let left = node.left;
+            while (ts.isParenthesizedExpression(left))
+                left = left.expression;
+            if (ts.isIdentifier(left) && lowerer.checker.getSymbolAtLocation(left) === symbol) {
+                if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+                    invalid = true;
+                    return "stop";
+                }
+                if (ts.isCallExpression(node.right) && implicitMethodCallInfersReturn(lowerer, node.right)) {
+                    invalid = true;
+                    return "stop";
+                }
+                const mapped = lowerer.mapTypeOf(lowerer.typeOf(node.right));
+                if (!mapped || mapped.kind === "dyn" || mapped.kind === "jsval" || mapped.kind === "void" || isUnitType(mapped)) {
+                    invalid = true;
+                    return "stop";
+                }
+                writes.push(mapped);
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            ts.isIdentifier(node.operand) &&
+            lowerer.checker.getSymbolAtLocation(node.operand) === symbol) {
+            invalid = true;
+            return "stop";
+        }
+        if (ts.isIdentifier(node) &&
+            node !== decl.name &&
+            lowerer.checker.getSymbolAtLocation(node) === symbol &&
+            !isPlainAssignmentTarget(node)) {
+            reads.push(node);
+        }
+        return undefined;
+    });
+    const first = writes[0];
+    if (invalid || first === undefined || !writes.every((write) => typeEquals(write, first)))
+        return null;
+    return reads.every((read) => {
+        const mapped = lowerer.mapTypeOf(lowerer.typeOf(read));
+        return mapped !== null && typeEquals(mapped, first);
+    }) ? first : null;
+}
 export function lowerVarDecl(lowerer, decl, isLet) {
     // --provenance-sources: an elided pure-annotated dead const emits
     // nothing (collectGlobals registered no global by the same test —
@@ -3026,8 +3410,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 +3447,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
@@ -3084,6 +3492,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         // immediately (the type covers the unassigned state), so they
         // initialize to the interned undefined arm like an omitted optional.
         let type = lowerer.irTypeOf(decl.name);
+        if (type.kind === "dyn" && isLet && isJsSourceFile(decl.getSourceFile())) {
+            type = inferredEvolvingLetType(lowerer, decl) ?? type;
+        }
         // `var v: void;` / `let x: undefined;` — a unit-only binding rides
         // the unit-only union (its undefined arm is the unassigned state,
         // which is also the only state).
@@ -3108,7 +3519,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) {
@@ -3154,6 +3565,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         (lowerer.dynamic && init.type.kind === "dyn" && jsvalFlavoredType(lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? DYN) ? DYN : null) ??
         (bindingTainted ? null : lowerer.mapTypeOf(lowerer.typeOf(decl.name))) ??
         (init.type.kind === "dyn" ? DYN : null);
+    if (lowerer.implicitParamTypes !== null &&
+        init.type.kind === "dyn" &&
+        isJsSourceFile(decl.getSourceFile()) &&
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) !== null) {
+        type = DYN;
+    }
     // A JS `let x = {}`: TS's empty-object-literal type admits ANY later
     // non-nullish assignment (`envs = {}`, later `envs =
     // Object.fromEntries(...)` — tsc accepts every such write, since
@@ -3166,6 +3583,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
+    const returnedEmptyArrayType = npmStaticReturnedEmptyArrayType(lowerer, decl);
+    if (returnedEmptyArrayType !== null) {
+        type = returnedEmptyArrayType;
+        init = lowerer.lowerExprExpecting(decl.initializer, returnedEmptyArrayType);
+    }
     // A JS `const leaked = [];` (the evolving-array idiom — test/common's
     // leak ledger): tsc types the binding by its LATER pushes, but this
     // frontend answers the declaration name with the uninhabited never[],
@@ -3175,7 +3597,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // checked-dynamic instead (the `let x = {}` stance, and lower-modules'
     // file-scope evolving-array rule): pushes ride the dyn array, typed
     // exits dynCheck.
-    if ((type === null || type.kind === "array") && isJsSourceFile(decl.getSourceFile())) {
+    if (returnedEmptyArrayType === null &&
+        (type === null || type.kind === "array") &&
+        isJsSourceFile(decl.getSourceFile())) {
         let initExpr = decl.initializer;
         while (ts.isParenthesizedExpression(initExpr))
             initExpr = initExpr.expression;
@@ -3194,12 +3618,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
@@ -3219,14 +3661,15 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // their tuple record likewise). Const only — an evolving-`any`
     // `let` may be reassigned a different shape later; genuine `any`
     // only — every other unmappable keeps its own diagnostic.
-    if (type === null && !isLet &&
-        ((lowerer.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0 ||
+    const checkerAny = (lowerer.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0;
+    if ((type === null || (type.kind === "dyn" && checkerAny)) && !isLet &&
+        (checkerAny ||
             (lowerer.checkerAnyArray(decl.name) && lowerer.isArrayValueType(init.type)) ||
             // JS declarations carry no annotations: an unmappable inferred
             // type (a union with a fence-folded arm — the typeof-'bigint'
             // dual-mode ternary) adopts the initializer's static type, the
             // same rule genuine `any` consts take.
-            isJsSourceFile(decl.getSourceFile())) &&
+            (type === null && isJsSourceFile(decl.getSourceFile()))) &&
         init.type.kind !== "void" && init.type.kind !== "caught" && init.type.kind !== "jsval" &&
         !isUnitType(init.type)) {
         type = init.type;
@@ -3241,29 +3684,51 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     if (!type)
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
+    let settledType = type;
+    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 = settledType.kind === "string" &&
+        ((arithmeticType && typeEquals(arithmeticType, init.type)) || isStringArithmeticUnion(init.type));
+    if (runtimeStringArithmetic) {
+        settledType = init.type;
+    }
+    const optionalSelfWriteType = isLet
+        ? npmStaticOptionalSelfWriteType(lowerer, decl, settledType)
+        : null;
+    settledType = lowerer.runtimeOptionalBindingType(decl.name, settledType);
+    if (optionalSelfWriteType !== null)
+        settledType = optionalSelfWriteType;
+    if (returnedEmptyArrayType !== null)
+        settledType = returnedEmptyArrayType;
     // `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
     // void CALL's result) keep their fence at the coercion below.
-    if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
-        type = unitOnlyUnion(lowerer.unions);
+    if (settledType.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
+        settledType = unitOnlyUnion(lowerer.unions);
     }
-    if (type.kind === "void")
+    if (settledType.kind === "void")
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     // A PACKAGE promise stored in a local stays an island HANDLE — the
     // engine's promise has no static promise value to coerce into. Awaits
     // and .catch/.finally chains on the local bridge per use site (each
     // bridge is an independent observer of the same settlement).
-    if (init.type.kind === "jsval" && type.kind === "promise")
-        type = JSVAL;
+    if (init.type.kind === "jsval" && settledType.kind === "promise")
+        settledType = JSVAL;
     // An island value under an `any[]`-declared LOCAL spelling stays an
     // island HANDLE too (the runtime-world rule): the jsval-element-array
     // exit is a CALL-boundary conversion (the loadPlugins param ABI) —
     // converting a local would strand the engine's own prototypes
     // (join/map/... on a native handle-element array), where the handle
     // routes every use engine-side.
-    if (init.type.kind === "jsval" && type.kind === "array" && type.elem.kind === "jsval") {
-        type = JSVAL;
+    if (init.type.kind === "jsval" && settledType.kind === "array" && settledType.elem.kind === "jsval") {
+        settledType = JSVAL;
     }
     // A STATIC array of island HANDLES under an unannotated declared type
     // spelling evolved elements (`const kept = fns.filter(...)` over an
@@ -3276,8 +3741,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // validated-boundary fence.
     if (!decl.type &&
         init.type.kind === "array" && init.type.elem.kind === "jsval" &&
-        type.kind === "array" && type.elem.kind !== "jsval") {
-        type = init.type;
+        settledType.kind === "array" && settledType.elem.kind !== "jsval") {
+        settledType = init.type;
     }
     // `const runner = options.runner || defaultRunner`: the checker types
     // the || as the union/merge of two structurally-compatible function
@@ -3287,13 +3752,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // when the parameters agree and the declared return either contains
     // the init's return as a union arm or is the opaque spawnRes the
     // adapter converts (nothing coerces INTO either declared form).
-    if (type.kind === "func" && init.type.kind === "func" && !typeEquals(type, init.type)) {
+    if (settledType.kind === "func" && init.type.kind === "func" && !typeEquals(settledType, init.type)) {
         const initFn = init.type;
-        const paramsAgree = type.params.length === initFn.params.length &&
-            type.params.every((p, i) => typeEquals(p, initFn.params[i]));
-        const retUnionArm = type.ret.kind === "union" && lowerer.armTag(type.ret.unionId, initFn.ret) >= 0;
-        if (paramsAgree && (retUnionArm || lowerer.spawnResFnAdapterPlan(type, initFn) !== null)) {
-            type = init.type;
+        const paramsAgree = settledType.params.length === initFn.params.length &&
+            settledType.params.every((p, i) => typeEquals(p, initFn.params[i]));
+        const retUnionArm = settledType.ret.kind === "union" && lowerer.armTag(settledType.ret.unionId, initFn.ret) >= 0;
+        if (paramsAgree && (retUnionArm || lowerer.spawnResFnAdapterPlan(settledType, initFn) !== null)) {
+            settledType = init.type;
         }
     }
     // The downstream twin: `const result = runner(cmd, args)` where the
@@ -3302,12 +3767,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // can narrow (spawnRes has no discriminant). The VALUE is statically
     // the record arm, so the local adopts it; flows into the union slot
     // re-wrap via the ordinary arm coercion.
-    if (type.kind === "union" && init.type.kind === "record") {
-        const arms = lowerer.unions.get(type.unionId)?.arms ?? [];
+    if (settledType.kind === "union" && init.type.kind === "record") {
+        const arms = lowerer.unions.get(settledType.unionId)?.arms ?? [];
         if (arms.length === 2 &&
             arms.some((a) => a.kind === "spawnRes") &&
             arms.some((a) => typeEquals(a, init.type))) {
-            type = init.type;
+            settledType = init.type;
         }
     }
     // `const r: Repo = new MemRepo()` over an all-generic-method
@@ -3315,8 +3780,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // (the record shape maps empty and the width copy would drop the
     // class the generic-method calls monomorphize against) — see
     // genericIfaceBindingKeepsClass.
-    if (type.kind === "record" && init.type.kind === "object" && genericIfaceBindingKeepsClass(lowerer, decl, type)) {
-        type = init.type;
+    if (settledType.kind === "record" && init.type.kind === "object" && genericIfaceBindingKeepsClass(lowerer, decl, settledType)) {
+        settledType = init.type;
     }
     // A TDZ box minted DURING this very initializer (a callback inside it
     // captured this const — predeclareForwardCapture's current-statement
@@ -3331,8 +3796,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     // Slot coercion: `const r: A | B = bValue;` wraps implicitly; width
     // 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);
+    init = lowerer.coerceInto(decl.initializer, init, settledType);
+    const local = lowerer.declareLocal(decl.name, decl.name.text, settledType, 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 +3808,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;
@@ -3397,9 +3899,8 @@ export function lowerSwitch(lowerer, stmt) {
     const labels = lowerer.takeLabels();
     const disc = lowerer.lowerExpr(stmt.expression);
     const dk = disc.type.kind;
-    if (dk === "dyn") {
-        lowerer.unsupported("SC1100", stmt.expression, "switch statements on 'unknown' values");
-    }
+    if (dk === "dyn")
+        return lowerDynSwitch(lowerer, stmt, disc);
     if (dk === "union")
         return lowerUnionSwitch(lowerer, stmt, disc);
     if (dk !== "f64" && dk !== "string" && dk !== "bool") {
@@ -3432,8 +3933,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);
@@ -3448,12 +3949,51 @@ export function lowerSwitch(lowerer, stmt) {
    *   is last).
    * Case bodies share ONE lexical scope, exactly like the real switch. */
 function lowerUnionSwitch(lowerer, stmt, disc) {
-    const loc = locOf(stmt);
     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");
+    }
+    return lowerBranchSwitch(lowerer, stmt, disc, (stableDisc, test, expression) => {
+        const unitTest = test.kind === "unitLit"
+            ? lowerer.lowerUnitComparison(stableDisc, test, false, locOf(expression))
+            : null;
+        return unitTest ?? {
+            kind: "unionEq",
+            unionId: unionType.unionId,
+            negated: false,
+            sameValue: false,
+            left: stableDisc,
+            right: lowerer.coerceInto(expression, test, unionType),
+            type: BOOL,
+            loc: locOf(expression),
+        };
+    });
+}
+/** A checked-dynamic switch whose tests have native strict-equality
+ * answers. Scalar tests use dynScalarEq; null/undefined use dyn kind tests.
+ * Other case values retain the existing unknown-switch fence. */
+function lowerDynSwitch(lowerer, stmt, disc) {
+    return lowerBranchSwitch(lowerer, stmt, disc, (stableDisc, test, expression) => {
+        if (test.kind === "unitLit") {
+            return { kind: "dynTest", test: test.unit, value: stableDisc, type: BOOL, loc: locOf(expression) };
+        }
+        if (test.type.kind !== "string" && test.type.kind !== "f64" &&
+            test.type.kind !== "bool" && test.type.kind !== "dyn") {
+            lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
+        }
+        return { kind: "dynScalarEq", left: stableDisc, right: test, type: BOOL, loc: locOf(expression) };
+    });
+}
+function lowerBranchSwitch(lowerer, stmt, disc, compare) {
+    const loc = locOf(stmt);
+    const prefix = [];
+    let stableDisc = disc;
+    if (!isSafeToRepeat(disc)) {
+        const temp = lowerer.declareHiddenLocal("%switch", disc.type);
+        prefix.push({ kind: "varDecl", localId: temp.id, init: disc, loc });
+        stableDisc = { kind: "varRef", localId: temp.id, type: disc.type, loc };
     }
     const clauses = stmt.caseBlock.clauses;
     // An unlabeled break at a clause's END exits the switch — the chain's
@@ -3480,13 +4020,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.
@@ -3506,7 +4052,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
                 // final else, so matching them changes nothing when pure).
                 if (test.kind !== "strLit" && test.kind !== "numLit" &&
                     test.kind !== "boolLit" && test.kind !== "unitLit" &&
-                    !pureReemittable(test)) {
+                    !isSafeToRepeat(test)) {
                     lowerer.unsupported("SC1090", clause.expression, "effectful case tests in a union-typed switch (bind the test value to a const first)");
                 }
                 // A unit-literal test takes the unit-comparison lowering: a tag
@@ -3514,19 +4060,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
                 // lacks it (`case null:` on a `number | undefined` — legal TS,
                 // 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))
-                    : null;
-                pendingTests.push(unitTest ?? {
-                    kind: "unionEq",
-                    unionId: unionType.unionId,
-                    negated: false,
-                    sameValue: false,
-                    left: disc,
-                    right: lowerer.coerceInto(clause.expression, test, unionType),
-                    type: BOOL,
-                    loc: locOf(clause.expression),
-                });
+                pendingTests.push(compare(stableDisc, test, clause.expression));
             }
             const isDefault = ts.isDefaultClause(clause);
             if (clause.statements.length === 0 && !isDefault && i < clauses.length - 1) {
@@ -3563,13 +4097,13 @@ 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();
     }
 }
-/** try/catch/finally. Supported subset:
+/** try/catch/finally:
    * - `catch { }` (bindingless) discards the thrown value on entry.
    * - `catch (e)` binds it as a CAUGHT local — a snapshot of the exception
    *   cell, deliberately narrower than dyn: the supported uses are the
@@ -3580,23 +4114,14 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
    *   assignment are fenced (SC1063 and friends); destructuring patterns
    *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
-   * - `finally` runs on normal completion, on exception paths, and on the
-   *   way out of a `return` in the try/catch body (the backend's
-   *   pending-return path — inner-to-outer through nested finallys, the
-   *   value snapshotted before the finally runs, Node-exact).
-   *   break/continue crossing a try-with-finally stay rejected, as does
-   *   any jump out of the finally body itself (it would replace a pending
-   *   completion — rejectJumpCrossingFinally). Plain try/catch places no
-   *   restriction on jumps.
+   * - `finally` runs on normal completion, exception paths, and every
+   *   abrupt completion that crosses it. Return values are snapshotted
+   *   before cleanup; an abrupt completion inside the finally replaces the
+   *   pending one, matching JavaScript completion-record semantics.
    * Each block is its own lexical scope (the binding lives in a scope
    * WRAPPING the catch block, like the spec's catch environment). */
 export function lowerTry(lowerer, stmt) {
-    const hasFinally = stmt.finallyBlock !== undefined;
-    // try/catch bodies are jump-fenced only when a finally guards them.
-    const lowerGuarded = (block) => hasFinally
-        ? lowerer.inCtl("tryFinally", () => lowerer.lowerScopedBlock(block))
-        : lowerer.lowerScopedBlock(block);
-    const tryBody = lowerGuarded(stmt.tryBlock);
+    const tryBody = lowerer.lowerScopedBlock(stmt.tryBlock);
     let catchBody = null;
     let catchLocalId = null;
     if (stmt.catchClause) {
@@ -3609,19 +4134,17 @@ export function lowerTry(lowerer, stmt) {
             try {
                 const local = lowerer.declareLocal(vd.name, vd.name.text, CAUGHT, false);
                 catchLocalId = local.id;
-                catchBody = lowerGuarded(stmt.catchClause.block);
+                catchBody = lowerer.lowerScopedBlock(stmt.catchClause.block);
             }
             finally {
                 lowerer.scopes.pop();
             }
         }
         else {
-            catchBody = lowerGuarded(stmt.catchClause.block);
+            catchBody = lowerer.lowerScopedBlock(stmt.catchClause.block);
         }
     }
-    const finallyBody = stmt.finallyBlock
-        ? lowerer.inCtl("finallyBlock", () => lowerer.lowerScopedBlock(stmt.finallyBlock))
-        : null;
+    const finallyBody = stmt.finallyBlock ? lowerer.lowerScopedBlock(stmt.finallyBlock) : null;
     return {
         kind: "tryCatch",
         tryBody,
@@ -3645,12 +4168,16 @@ function lowerDeleteStatement(lowerer, expr) {
     if (!ts.isElementAccessExpression(target) && !ts.isPropertyAccessExpression(target)) {
         lowerer.unsupported("SC1090", expr, "'delete' of non-property expressions");
     }
+    fenceNodeModuleMutation(lowerer, target, "delete");
     const lowerKey = () => {
         if (ts.isPropertyAccessExpression(target)) {
             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 +4662,22 @@ export function lowerExprStatement(lowerer, expr) {
             if (ts.isElementAccessExpression(expr.left))
                 return lowerer.lowerElementWrite(expr);
             if (ts.isPropertyAccessExpression(expr.left)) {
+                fenceNodeModuleMutation(lowerer, expr.left, "assignment");
+                // 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
@@ -4272,10 +4815,10 @@ export function lowerExprStatement(lowerer, expr) {
                 // chain): the dyn keyed write — the value converts INTO dyn
                 // (closures box), the runtime sets the member on OBJ receivers
                 // and throws Node's TypeErrors on the rest. The receiver is
-                // PROBED (probeLower) and claimed exactly when it lowers to
+                // PROBED (tryLowerExpression) and claimed exactly when it lowers to
                 // dyn; typed receivers keep their own lowerings and fences.
                 if (!expr.left.questionDotToken) {
-                    const recv = probeLower(lowerer, expr.left.expression);
+                    const recv = tryLowerExpression(lowerer, expr.left.expression);
                     if (recv && recv.type.kind === "dyn") {
                         const loc = locOf(expr);
                         const key = { kind: "strLit", value: expr.left.name.text, type: STRING, loc: locOf(expr.left.name) };
@@ -4571,6 +5114,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 +5131,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 +5387,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 +5870,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 +6049,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 +6104,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
@@ -5626,29 +6174,27 @@ export function lowerForOf(lowerer, stmt) {
     // desugars drop them — a labeled jump naming those loops fences at the
     // jump site (no label point exists in their desugared shape).
     const labels = lowerer.takeLabels();
-    // `for await` is ASYNC ITERATION, not the shipped async/await. ONE
-    // async iterable has a lowering: process.stdin (the piped-input
-    // pattern real CLIs use) — see lowerForAwaitStdin. Everything else is
-    // named specifically (the bare SC1070 text would claim async/await
-    // itself is missing).
+    // `for await` is ASYNC ITERATION, not the shipped async/await. Typed
+    // async generators use the generic request protocol; process.stdin
+    // and readable streams retain their dedicated next-chunk paths.
     if (stmt.awaitModifier) {
-        if (ts.isPropertyAccessExpression(stmt.expression) &&
-            lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin") {
-            return lowerForAwaitStdin(lowerer, stmt);
-        }
-        // Readable streams (the readableAsyncIterator surface): the mapped
-        // receiver class roots at a readable-sided stream class.
         {
-            const recvT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
-            if (recvT?.kind === "object") {
-                const info = lowerer.classes.get(recvT.className);
-                const sides = streamSidesOf(lowerer, info);
-                if (sides === "r" || sides === "rw") {
-                    return lowerForAwaitReadable(lowerer, stmt, recvT);
+            const genT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
+            if (genT?.kind === "generator" && genT.async) {
+                const iterable = lowerer.lowerExpr(stmt.expression);
+                if (iterable.type.kind === "generator" && iterable.type.async) {
+                    return lowerForAwaitGenerator(lowerer, stmt, iterable, labels);
                 }
             }
         }
-        lowerer.unsupported("SC1070", stmt, "'for await' (async iteration over anything but process.stdin and readable streams)");
+        if (ts.isPropertyAccessExpression(stmt.expression) &&
+            lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin") {
+            return lowerForAwaitStdin(lowerer, stmt);
+        }
+        const builtin = lowerForAwaitBuiltin(lowerer, stmt);
+        if (builtin)
+            return builtin;
+        lowerer.unsupported("SC1070", stmt, "'for await' over this value (supported: typed async generators, represented class async iterators, process.stdin, and Node/Web readable streams)");
     }
     lowerer.fenceStaticHeadersIteration(stmt.expression);
     // A stored numeric value iterator declared in this function keeps its
@@ -5777,6 +6323,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);
     }
@@ -5854,7 +6413,7 @@ export function lowerForOf(lowerer, stmt) {
                     elemT = { kind: "union", unionId: lowerer.unions.intern(arms) };
                 }
             }
-            if (elemT !== null && pureReemittable(iterable)) {
+            if (elemT !== null && isSafeToRepeat(iterable)) {
                 const loc = locOf(stmt.expression);
                 const shapeId = iterable.type.shapeId;
                 const snapshotElem = elemT;
@@ -5902,6 +6461,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 +6496,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,15 +6517,13 @@ 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 ...))");
     }
     const list = stmt.initializer;
-    if ((list.flags & ts.NodeFlags.Using) !== 0) {
-        lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
-    }
+    const resourceLoop = (list.flags & ts.NodeFlags.Using) !== 0;
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
     const decl = list.declarations[0]; // the grammar allows exactly one
     // `for (const [k, v] of pairs)` — a destructuring loop variable: the
@@ -5955,13 +6535,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 +6557,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 +6567,28 @@ 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) };
+        if (!resourceLoop)
+            return forValues(local.id, body);
+        const resource = varRef(local.id, local.type, locOf(decl.name));
+        const cleanup = cleanupForValue(lowerer, decl.name, resource, isAwaitUsing(list));
+        return forValues(local.id, [{
+                kind: "tryCatch",
+                tryBody: body,
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: cleanup,
+                suppressFinallyErrors: true,
+                loc: locOf(decl),
+            }]);
     }
     finally {
         lowerer.scopes.pop();
@@ -6087,8 +6684,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 +6700,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 = [
             {
@@ -7141,112 +7744,6 @@ function lowerForAwaitStdin(lowerer, stmt) {
         lowerer.scopes.pop();
     }
 }
-/** `for await (const chunk of readable)` — the stream async iterator
-   * (the stdin desugar's sibling): every pass awaits the runtime's
-   * next-chunk promise — buffered content, or a REJECTION carrying the
-   * stream's error (the await rethrows it, Node's iterator contract) —
-   * and exits on the EOF sentinel. Chunks are Buffers in typed code
-   * (encoded streams fence at the runtime entry); in the JS lane the
-   * chunk is checked-dynamic and boxes by runtime tag (dyn strings once
-   * an encoding applies, dyn undefined as the sentinel — chunks are
-   * never undefined). Early exit leaves the stream alive (Node's
-   * iterator return() would destroy it — a documented divergence). */
-function lowerForAwaitReadable(lowerer, stmt, recvT) {
-    if (!lowerer.ctx.isAsync) {
-        lowerer.unsupported("SC1090", stmt, "top-level 'for await' (await outside async functions)");
-    }
-    if (!ts.isVariableDeclarationList(stmt.initializer)) {
-        lowerer.unsupported("SC1090", stmt.initializer, "for-await over a pre-declared variable (declare the loop variable in the loop: for await (const chunk of ...))");
-    }
-    const list = stmt.initializer;
-    const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
-    const isLet = (list.flags & ts.NodeFlags.Let) !== 0;
-    // `for await (var chunk of ...)`: the chunk binding is per-await
-    // machinery (a fresh value each pass, fiber-parked in between) —
-    // threading it through a shared hoisted slot has no user yet.
-    if (!isConst && !isLet)
-        lowerer.unsupported("SC1030", list, "'var' loop bindings in 'for await' (use const)");
-    const decl = list.declarations[0];
-    if (!ts.isIdentifier(decl.name))
-        lowerer.unsupported("SC1031", decl.name);
-    const loc = locOf(stmt);
-    // The chunk is CHECKED-DYNAMIC in both lanes (the shim types the
-    // iterator's element as any): the runtime boxes by tag — Buffers
-    // normally, strings once an encoding applies — and the dyn surface
-    // carries the common consumptions (.length, [i], toString, +=,
-    // typeof). A statically-typed chunk would have to pick one side of
-    // the encoding question at compile time.
-    const dynLane = true;
-    const chunkT = DYN;
-    const promiseT = { kind: "promise", inner: chunkT };
-    lowerer.scopes.push(new Map());
-    try {
-        // The receiver evaluates ONCE, before the loop.
-        const recvLocal = lowerer.declareHiddenLocal("%faStream", recvT);
-        const recvDecl = {
-            kind: "varDecl",
-            localId: recvLocal.id,
-            init: lowerer.lowerExpr(stmt.expression),
-            loc,
-        };
-        const p = lowerer.declareHiddenLocal("%streamNext", promiseT);
-        const chunk = lowerer.declareLocal(decl.name, decl.name.text, chunkT, isLet);
-        const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement));
-        const chunkRef = { kind: "varRef", localId: chunk.id, type: chunkT, loc };
-        const eofCond = dynLane
-            ? { kind: "dynTest", test: "undefined", value: chunkRef, type: BOOL, loc }
-            : {
-                kind: "bin",
-                op: "===",
-                left: { kind: "bytesIntrinsic", method: "length", receiver: chunkRef, args: [], type: F64, loc },
-                right: { kind: "numLit", value: 0, type: F64, loc },
-                type: BOOL,
-                loc,
-            };
-        const head = [
-            {
-                kind: "varDecl",
-                localId: p.id,
-                init: {
-                    kind: "libCall",
-                    fn: dynLane ? "readable.nextChunkDyn" : "readable.nextChunk",
-                    args: [{ kind: "varRef", localId: recvLocal.id, type: recvT, loc }],
-                    type: promiseT,
-                    loc,
-                },
-                loc,
-            },
-            {
-                kind: "varDecl",
-                localId: chunk.id,
-                init: {
-                    kind: "awaitExpr",
-                    value: { kind: "varRef", localId: p.id, type: promiseT, loc },
-                    type: chunkT,
-                    loc,
-                },
-                loc,
-            },
-            { kind: "if", cond: eofCond, then: [{ kind: "break", loc }], else_: null, loc },
-        ];
-        return {
-            kind: "block",
-            body: [
-                recvDecl,
-                {
-                    kind: "while",
-                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
-                    body: [...head, ...body],
-                    loc,
-                },
-            ],
-            loc,
-        };
-    }
-    finally {
-        lowerer.scopes.pop();
-    }
-}
 export function lowerForStatement(lowerer, stmt) {
     const labels = lowerer.takeLabels();
     lowerer.scopes.push(new Map());