@scriptc/compiler 0.1.7 → 0.2.1

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

@@ -1,3 +1,4 @@
+import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
@@ -5,30 +6,41 @@ import { InternalCompilerError } from "../../errors.js";
  * explicit resource management, and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
 import { bindingSource } from "../binding-source.js";
-import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
+import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead } 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 { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, staticImportNamespaceType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { enforceLibBoundary } from "./lib-boundary.js";
-import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, locOf, requireSpecOf } from "../program.js";
+import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
+import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf } from "../program.js";
 import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
+import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
 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, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
-import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
+import { isCompiledPrototypeMember } from "./class-prototypes.js";
+import { classStaticDataFor } from "./class-static-data.js";
+import { objectFactorySignature } from "./object-factory-new.js";
+import { isClassCallback, lowerClassCallbackAssign } from "./class-callbacks.js";
+import { classPropertiesHelper } from "./class-dynamic-dispatch.js";
+import { genericIfaceBindingKeepsClass, staticFieldWriteTarget } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias, textCodecBindingDecl } from "./lower-builtins.js";
+import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerElementCompound, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompound, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { globalSymbolKey } from "./expressions/global-symbols.js";
+import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
+import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-exprs.js";
+import { isNativeProxyInitializer } from "./expressions/native-proxy.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 { lowerUnionFieldWrite } from "./expressions/union-field-write.js";
+import { UNSUPPORTED, checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
+import { isParseArgsDynTypeName, isUnitOnlyTsType, jsOpenObjectType, unitOnlyUnion } from "../type-mapper.js";
 import { canonicalBuiltinModule } from "../builtin-modules.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { probeNodeRequireRefusal } from "../npm.js";
@@ -56,7 +68,7 @@ function npmStaticReturnedEmptyArrayType(lowerer, decl) {
     let owner = decl.parent;
     while (owner !== undefined && !ts.isFunctionLike(owner))
         owner = owner.parent;
-    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    const ownerBody = owner !== undefined && ts.isFunctionLike(owner) ? owner.body : undefined;
     if (ownerBody === undefined || !ts.isBlock(ownerBody))
         return null;
     let returned = false;
@@ -93,7 +105,7 @@ function npmStaticOptionalSelfWriteType(lowerer, decl, initial) {
     let owner = decl.parent;
     while (owner !== undefined && !ts.isFunctionLike(owner))
         owner = owner.parent;
-    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    const ownerBody = owner !== undefined && ts.isFunctionLike(owner) ? owner.body : undefined;
     if (ownerBody === undefined || !ts.isBlock(ownerBody))
         return null;
     let candidate = null;
@@ -320,7 +332,7 @@ export function provenanceElidedConstDecl(lowerer, decl) {
     const sf = decl.getSourceFile();
     if (!isProvenanceSourceFile(sf.fileName))
         return false;
-    const stmt = decl.parent.parent;
+    const stmt = decl.parent?.parent;
     if (!ts.isVariableStatement(stmt) || !pureAnnotatedDeadConst(stmt, sf))
         return false;
     const diagsBefore = lowerer.diags.length;
@@ -414,13 +426,16 @@ export function lowerStmts(lowerer, stmts) {
                 // fence — inside this statement's poison window, so a JS fence
                 // becomes the statement's runtimeFence exactly like every other
                 // deferred rejection.
-                if (lowered)
-                    enforceLibBoundary(lowerer, lowered);
-                if (!appended) {
+                if (lowered) {
+                    const body = [];
                     if (Array.isArray(lowered))
-                        out.push(...lowered);
-                    else if (lowered)
-                        out.push(lowered);
+                        body.push(...lowered);
+                    else
+                        body.push(lowered);
+                    const rewritten = lowerSurplusCalls(lowerer, body);
+                    enforceLibBoundary(lowerer, rewritten);
+                    if (!appended)
+                        out.push(...rewritten);
                 }
                 // Island accounting (--dynamic coverage): a statement that lowered
                 // but carries island constructs compiles DYNAMICALLY — its work
@@ -509,11 +524,13 @@ export function lowerStmts(lowerer, stmts) {
    * empty-slot sentinel still works (a scalar slot has no spare state:
    * every bit pattern is a legal value — the setTimeout-handle shape,
    * `clearTimeout(timer)` captured above `const timer = setTimeout(...)`).
-   * dyn/caught/jsval keep their existing capture fences. Unit-only types
+   * Checked-dynamic values use ref boxes with their own retain/release;
+   * a NULL payload remains distinct from the allocated undefined value.
+   * caught/jsval keep their existing capture fences. Unit-only types
    * never carry a useful forward capture. */
 const TDZ_KINDS = new Set([
     "func", "string", "array", "record", "object", "union", "map", "set", "regex", "bytes",
-    "f64", "bool",
+    "f64", "bool", "dyn",
     // The runtime HANDLE kinds — heap, refcounted, pointer-backed like
     // `object`, so the box's NULL sentinel works unchanged. The canonical
     // shape is the const's own initializer capturing the const:
@@ -541,26 +558,25 @@ const TDZ_KINDS = new Set([
    * threads captures normally. The source declaration later becomes the
    * initializing `assign` (lowerVarDecl consumes tdzPredeclared). Reads
    * test the box and throw Node's exact catchable ReferenceError while it
-   * is empty. CONST ONLY: `let` would need the same trap on writes, a
-   * surface nothing yet needs. */
+   * is empty. Mutable bindings also guard writes; only the declaration's
+   * initializing assignment may leave the temporal dead zone. */
 export function predeclareForwardCapture(lowerer, symbol) {
     const decl = lowerer.checker.valueDeclarationOf(symbol);
     if (!decl || !ts.isVariableDeclaration(decl) || decl.name === undefined || !ts.isIdentifier(decl.name))
         return false;
     if (!decl.initializer)
         return false;
-    if ((ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) === 0)
+    const flags = ts.getCombinedNodeFlags(decl);
+    if ((flags & ts.NodeFlags.BlockScoped) === 0 || (flags & ts.NodeFlags.Using) !== 0)
         return false;
-    if (lowerer.tdzPredeclared.has(symbol))
-        return false; // defensive: never twice
-    // MODULE-scope consts are pre-registered globals (collectGlobals):
+    // MODULE-scope bindings are pre-registered globals (collectGlobals):
     // references resolve through globalOf after the local search fails, so
     // a TDZ box here would SHADOW the global and never fill (the top-level
     // `const id = setInterval(cb)` self-capture — the global slot is the
     // binding). Function-scope declarations have no global; they predeclare.
     if (lowerer.globalsBySymbol.has(symbol))
         return false;
-    const varStmt = decl.parent.parent;
+    const varStmt = decl.parent?.parent;
     if (!ts.isVariableStatement(varStmt))
         return false; // for-initializers stay out
     for (let i = lowerer.activeStmtLists.length - 1; i >= 0; i--) {
@@ -575,7 +591,7 @@ export function predeclareForwardCapture(lowerer, symbol) {
         // const's own initializer capturing the const (`const server =
         // createServer(h).listen(0, go)` with `go` reading `server`) is a
         // TDZ read until the initializing assign completes — JS exactly.
-        if (idx < entry.index || entry.ctx === lowerer.ctx)
+        if (idx < entry.index || entry.ctx === lowerer.ctx || entry.ctx.tdzPredeclared.has(symbol))
             return false;
         const type = lowerer.irTypeOf(decl.name);
         if (!TDZ_KINDS.has(type.kind) || isUnitType(type))
@@ -583,11 +599,14 @@ export function predeclareForwardCapture(lowerer, symbol) {
         const name = decl.name.text;
         const count = entry.ctx.localCounters.get(name) ?? 0;
         entry.ctx.localCounters.set(name, count + 1);
-        const local = { id: `${name}.${count}`, name, type, mutable: false, boxed: true, tdz: true };
+        const local = {
+            id: `${name}.${count}`, name, type,
+            mutable: (flags & ts.NodeFlags.Const) === 0, boxed: true, tdz: true,
+        };
         entry.ctx.locals.push(local);
         entry.frame.set(symbol, local);
         entry.out.push({ kind: "varDecl", localId: local.id, init: null, loc: locOf(decl) });
-        lowerer.tdzPredeclared.set(symbol, local);
+        entry.ctx.tdzPredeclared.set(symbol, local);
         return true;
     }
     return false;
@@ -599,23 +618,20 @@ export function predeclareForwardCapture(lowerer, symbol) {
    * declaration and initializing assignment are pushed before the current
    * statement's IR, registered in the list's scope frame) and the statement
    * loop skips the source statement when it arrives
-   * (lowerer.hoistedFnDecls). Same-function only: the declaration's own
-   * lowering runs under the ctx that owns its statement list, and a
-   * cross-function early capture would need lowering under a DIFFERENT
-   * ctx than the one currently open — that shape keeps the honest fence. */
+   * (the owner's hoistedFnDecls). Forward references from nested functions
+   * lower the declaration under the owning statement list's context, then
+   * resume the caller and thread its captures normally. */
 export function predeclareForwardFnDecl(lowerer, symbol) {
     const decl = lowerer.checker.valueDeclarationOf(symbol);
     if (!decl || !ts.isFunctionDeclaration(decl) || !decl.body || decl.typeParameters)
         return false;
-    if (lowerer.hoistedFnDecls.has(decl))
-        return false; // defensive: never twice
     for (let i = lowerer.activeStmtLists.length - 1; i >= 0; i--) {
         const entry = lowerer.activeStmtLists[i];
         const idx = entry.stmts.indexOf(decl);
         if (idx < 0)
             continue;
         // Not forward — already lowered; resolution would have found it.
-        if (idx <= entry.index)
+        if (idx <= entry.index || entry.ctx.hoistedFnDecls.has(decl))
             return false;
         // The declaration may live in an ENCLOSING function's open list (a
         // sibling hoisted function calling a later one — mutual recursion):
@@ -629,14 +645,14 @@ export function predeclareForwardFnDecl(lowerer, symbol) {
         const frameIdx = entry.ctx.scopes.indexOf(entry.frame);
         if (depth < 0 || frameIdx < 0)
             return false;
-        lowerer.hoistedFnDecls.add(decl);
+        entry.ctx.hoistedFnDecls.add(decl);
         const fnTail = lowerer.fnStack.splice(depth + 1);
         const scopeTail = entry.ctx.scopes.splice(frameIdx + 1);
         try {
             entry.out.push(lowerer.lowerNestedFunctionDecl(decl));
         }
         catch (e) {
-            lowerer.hoistedFnDecls.delete(decl);
+            entry.ctx.hoistedFnDecls.delete(decl);
             throw e;
         }
         finally {
@@ -651,7 +667,8 @@ export function predeclareForwardFnDecl(lowerer, symbol) {
    * was declared with `var` — no const/let/using flag anywhere on its
    * binding chain. */
 export function isVarDeclared(decl) {
-    return (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.BlockScoped) === 0;
+    const host = ts.isIdentifier(decl) ? hostVariableDeclarationOf(decl) : decl;
+    return host !== null && (ts.getCombinedNodeFlags(host) & ts.NodeFlags.BlockScoped) === 0;
 }
 /** The VariableDeclaration hosting a binding name (walking out of any
    * enclosing binding patterns), or null when the name belongs to some
@@ -688,6 +705,11 @@ export function forOfVarTarget(lowerer, decl) {
    * file rides the dyn fallback). Null when no static type can hold the
    * binding. */
 function varBindingType(lowerer, nameNode) {
+    if (ts.isVariableDeclaration(nameNode.parent) && isNativeProxyInitializer(lowerer, nameNode.parent.initializer))
+        return DYN;
+    if (isJsSourceFile(nameNode.getSourceFile()) && ts.isVariableDeclaration(nameNode.parent) &&
+        isNativeBuiltinValueInitializer(lowerer, nameNode.parent.initializer))
+        return DYN;
     let type = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
     if (type?.kind === "record" && isJsSourceFile(nameNode.getSourceFile())) {
         const shape = lowerer.shapes.get(type.shapeId);
@@ -736,13 +758,13 @@ function varBindingType(lowerer, nameNode) {
    * classic capture semantics fall out: closures made in a loop share the
    * single boxed binding, where `let` gets a fresh box per iteration. */
 function hoistVarBinding(lowerer, symbol, nameNode) {
-    const existing = lowerer.hoistedVars.get(symbol);
+    const existing = lowerer.ctx.hoistedVars.get(symbol);
     if (existing)
         return existing;
     // The parameter merge: the symbol already binds a function-root local.
     const bound = lowerer.bindingIn(lowerer.ctx, symbol);
     if (bound) {
-        lowerer.hoistedVars.set(symbol, bound);
+        lowerer.ctx.hoistedVars.set(symbol, bound);
         return bound;
     }
     const type = varBindingType(lowerer, nameNode);
@@ -762,7 +784,7 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
     // engine undefined for jsval).
     const wrapped = type.kind === "dyn" ? dynUndefinedExpr(locOf(nameNode)) : lowerer.unassignedSlotInit(type, locOf(nameNode));
     root.out.push({ kind: "varDecl", localId: local.id, init: wrapped, loc: locOf(nameNode) });
-    lowerer.hoistedVars.set(symbol, local);
+    lowerer.ctx.hoistedVars.set(symbol, local);
     return local;
 }
 /** The forward twin of hoistVarBinding, entered from resolution failure: a
@@ -779,8 +801,6 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
    * would yield if the capture ran early, and guessing "it won't" is the
    * silent-wrong-output sin. */
 export function predeclareForwardVar(lowerer, symbol) {
-    if (lowerer.hoistedVars.has(symbol))
-        return false; // would have resolved
     const decl = lowerer.checker.valueDeclarationOf(symbol);
     if (!decl || !ts.isVariableDeclaration(decl) || !isVarDeclared(decl))
         return false;
@@ -805,6 +825,8 @@ export function predeclareForwardVar(lowerer, symbol) {
     if (!owner)
         return false;
     const ctx = owner.ctx;
+    if (ctx.hoistedVars.has(symbol))
+        return false; // would have resolved
     // Only a slot that can hold `undefined` can carry the pre-
     // initialization reads: an undefined-armed union (the interned arm),
     // a checked-dynamic binding (the dyn undefined), or a jsval 'any'
@@ -823,7 +845,7 @@ export function predeclareForwardVar(lowerer, symbol) {
     ctx.locals.push(local);
     ctx.scopes[0].set(symbol, local);
     root.out.push({ kind: "varDecl", localId: local.id, init: wrapped, loc: locOf(decl) });
-    lowerer.hoistedVars.set(symbol, local);
+    ctx.hoistedVars.set(symbol, local);
     return true;
 }
 /** Records the symbols a poisoned DECLARATION statement would have bound
@@ -868,13 +890,24 @@ export function isBlockedBinding(lowerer, symbol) {
 export function lowerScopedBlock(lowerer, stmt) {
     lowerer.scopes.push(new Map());
     try {
-        const stmts = ts.isBlock(stmt) ? lowerer.lowerStmts(stmt.statements) : lowerer.lowerStmts([stmt]);
-        return stmts;
+        return withRuntimeOptionalScope(lowerer, () => ts.isBlock(stmt) ? lowerer.lowerStmts(stmt.statements) : lowerer.lowerStmts([stmt]));
     }
     finally {
         lowerer.scopes.pop();
     }
 }
+function withRuntimeOptionalScope(lowerer, lower) {
+    lowerer.runtimeOptionalLocals.beginScope();
+    try {
+        return lower();
+    }
+    finally {
+        // A guard inside one branch or loop body proves presence only for
+        // its remaining statements. Keep assignments that reactivated a
+        // slot, and restore every absence possibility from the outer scope.
+        lowerer.runtimeOptionalLocals.endScope();
+    }
+}
 /** `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
@@ -916,6 +949,15 @@ function lowerLabeled(lowerer, stmt) {
     return { kind: "block", body, labels, loc: locOf(stmt) };
 }
 export function lowerStmt(lowerer, stmt) {
+    if (ts.isClassDeclaration(stmt)) {
+        if (!stmt.name)
+            lowerer.unsupported("SC1090", stmt, "anonymous local class declarations");
+        const info = lowerer.lowerClassExpressionInfo(stmt);
+        const type = { kind: "classval", className: info.def.name };
+        const local = lowerer.declareLocal(stmt.name, stmt.name.text, type, true);
+        const init = lowerer.lowerClassExpression(stmt);
+        return { kind: "varDecl", localId: local.id, init, loc: locOf(stmt) };
+    }
     if (ts.isVariableStatement(stmt)) {
         // `declare const` — ambient: no storage, no init (collectGlobals
         // skipped it; reads throw Node's ReferenceError at the access).
@@ -939,11 +981,11 @@ export function lowerStmt(lowerer, stmt) {
         // checker only performs for consts (aliasTypeofNarrows).
         const then = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, stmt.expression, true), () => withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, stmt.expression), () => lowerer.lowerScopedBlock(stmt.thenStatement)));
         const else_ = stmt.elseStatement
-            ? lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, stmt.expression, false), () => lowerer.lowerScopedBlock(stmt.elseStatement))
+            ? lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, stmt.expression, false), () => withRuntimeOptionalNarrowed(lowerer, runtimeOptionalGuardIds(lowerer, stmt.expression, false), () => lowerer.lowerScopedBlock(stmt.elseStatement)))
             : null;
-        const narrowedAfter = falsyExitRuntimeOptionalLocal(lowerer, stmt);
-        if (narrowedAfter !== null)
-            lowerer.runtimeOptionalLocals.delete(lowerer.runtimeOptionalRootOf(narrowedAfter));
+        for (const local of falsyExitRuntimeOptionalLocals(lowerer, stmt)) {
+            lowerer.runtimeOptionalLocals.delete(lowerer.runtimeOptionalRootOf(local));
+        }
         return { kind: "if", cond, then, else_, loc: locOf(stmt) };
     }
     if (ts.isWhileStatement(stmt)) {
@@ -1093,7 +1135,7 @@ export function lowerStmt(lowerer, stmt) {
         // Already lowered eagerly by the forward-hoisting machinery
         // (predeclareForwardFnDecl) — its declaration and assignment are in
         // the list's output.
-        if (lowerer.hoistedFnDecls.has(stmt))
+        if (lowerer.ctx.hoistedFnDecls.has(stmt))
             return null;
         return lowerer.lowerNestedFunctionDecl(stmt);
     }
@@ -1111,7 +1153,7 @@ export function lowerStmt(lowerer, stmt) {
     const entry = UNSUPPORTED_STMT[stmt.kind];
     if (entry)
         lowerer.unsupported(entry.code, stmt, entry.feature);
-    lowerer.unsupported("SC1090", stmt, `syntax '${ts.SyntaxKind[stmt.kind]}'`);
+    lowerer.unsupported("SC1090", stmt, `syntax '${ts.syntaxKindName(stmt.kind)}'`);
 }
 /** A variable statement may carry several declarators (`let a = 1,
    * b = a + 1;`): each lowers to its own varDecl IN ORDER, so later
@@ -1150,6 +1192,7 @@ export function lowerVarStatement(lowerer, stmt) {
         // fence.
         if (decl.initializer !== undefined &&
             requireSpecOf(decl.initializer) !== null &&
+            !isNativeFfiRequire(lowerer, decl.initializer) &&
             isJsSourceFile(decl.getSourceFile())) {
             const spec = requireSpecOf(decl.initializer);
             if (lowerer.externalTypes.has(spec))
@@ -1253,7 +1296,7 @@ function lowerNumericIteratorDecl(lowerer, decl, isConst) {
     if (sourceNode === null)
         return null;
     const sym = lowerer.checker.getSymbolAtLocation(decl.name);
-    if (!sym || lowerer.tdzPredeclared.has(sym))
+    if (!sym || lowerer.ctx.tdzPredeclared.has(sym))
         return null;
     const source = lowerer.lowerExpr(sourceNode);
     if (!((source.type.kind === "array" && source.type.elem.kind === "f64") ||
@@ -1291,7 +1334,7 @@ function lowerMatchAllDrainDecl(lowerer, decl, isConst) {
     if (!call)
         return null;
     const sym = lowerer.checker.getSymbolAtLocation(decl.name);
-    if (!sym || lowerer.globalsBySymbol.has(sym) || lowerer.tdzPredeclared.has(sym))
+    if (!sym || lowerer.globalsBySymbol.has(sym) || lowerer.ctx.tdzPredeclared.has(sym))
         return null;
     const rowsT = arrayOf(arrayOf(STRING));
     const declared = lowerer.mapTypeOf(lowerer.typeOf(decl.name));
@@ -1523,6 +1566,13 @@ 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) {
+    if (ts.isObjectBindingPattern(pattern)) {
+        const patternType = lowerer.typeOf(pattern);
+        const patternSymbol = patternType.getSymbol();
+        allowDynObject ||= patternSymbol?.name === "SegmentData" && lowerer.isStdlibSymbol(patternSymbol);
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Object) !== 0 && lowerer.mapTypeOf(patternType)?.kind === "dyn";
+        allowDynObject ||= (patternType.flags & ts.TypeFlags.Any) !== 0;
+    }
     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);
@@ -1530,6 +1580,23 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     }
     if (ts.isArrayBindingPattern(pattern)) {
         lowerer.fenceStaticHeadersIteration(pattern);
+        if (srcType.kind === "union" && lowerer.unions.get(srcType.unionId)?.arms.every((arm) => arm.kind === "array")) {
+            for (let i = 0; i < pattern.elements.length; i++) {
+                const el = pattern.elements[i];
+                if (ts.isOmittedExpression(el) || el.name === undefined)
+                    continue;
+                if (el.dotDotDotToken)
+                    lowerer.unsupported("SC1031", el, "rest elements over a union of array layouts");
+                const loc = locOf(el);
+                let value = unionArrayValueRead(lowerer, srcRef(), numLit(i, loc), loc);
+                if (!value)
+                    lowerer.unsupported("SC1031", el, "array union elements without a common native representation");
+                if (el.initializer)
+                    value = applyBindingDefault(lowerer, el, value);
+                lowerer.bindPatternTarget(el.name, value, isLet, out);
+            }
+            return;
+        }
         // Tuple sources: each position is a field read of the tuple's record
         // shape — the positional twin of object destructuring below.
         const tupleShape = srcType.kind === "record" ? lowerer.shapes.get(srcType.shapeId) : undefined;
@@ -1665,13 +1732,13 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             out.push({
                 kind: "varDecl",
                 localId: pack.id,
-                init: {
+                init: pattern.elements.some((element) => ts.isBindingElement(element) && element.dotDotDotToken) ? {
                     kind: "libCall",
                     fn: "dyn.iterPack",
                     args: [srcRef(), { kind: "strLit", value: dynSpell ?? "", type: STRING, loc }],
                     type: DYN,
                     loc,
-                },
+                } : { kind: "dynIterN", value: srcRef(), count: pattern.elements.length, ...(dynSpell ? { notIterableMessage: dynSpell } : {}), type: DYN, loc },
                 loc,
             });
             pattern.elements.forEach((el, i) => {
@@ -1679,7 +1746,9 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     return; // hole: the position skips
                 const elLoc = locOf(el);
                 if (el.dotDotDotToken) {
-                    lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources");
+                    lowerer.bindPatternTarget(el.name, { kind: "dynInvoke", recv: varRef(pack.id, DYN, elLoc),
+                        method: "slice", calleeName: "Array.prototype.slice", args: [lowerer.coerceToExpected(numLit(i, elLoc), DYN)], type: DYN, loc: elLoc }, isLet, out);
+                    return;
                 }
                 let value = {
                     kind: "dynKeyGet",
@@ -1693,7 +1762,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     // its value converting into the checked-dynamic tree like any dyn-slot value.
                     const rl = lowerer.declareHiddenLocal("%delem", DYN);
                     out.push({ kind: "varDecl", localId: rl.id, init: value, loc: elLoc });
-                    const dflt = lowerer.coerceToExpected(lowerer.lowerExpr(el.initializer), DYN);
+                    const dflt = lowerer.coerceInto(el.initializer, lowerer.lowerExpr(el.initializer), DYN);
                     if (dflt.type.kind !== "dyn") {
                         lowerer.unsupported("SC1031", el.initializer, `defaults of '${lowerer.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the checked-dynamic tree)`);
                     }
@@ -1816,14 +1885,26 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // scoped TypeScript exception: its declared result/token types are
     // deliberately carried by the checked-dynamic tree, so their ordinary
     // object patterns use the same exact keyed-read desugar.
-    if (srcType.kind === "dyn" &&
-        (isJsSourceFile(pattern.getSourceFile()) || allowDynObject)) {
+    if (srcType.kind === "dyn") {
         for (const el of pattern.elements) {
             if (el.name === undefined)
                 continue;
             const loc = locOf(el);
             if (el.dotDotDotToken) {
-                lowerer.unsupported("SC1031", el, "rest elements over checked-dynamic sources (the remaining-fields object has no lowering yet)");
+                const keys = [];
+                for (const sibling of pattern.elements) {
+                    if (sibling === el || sibling.dotDotDotToken)
+                        continue;
+                    const key = sibling.propertyName ?? sibling.name;
+                    const name = ts.isIdentifier(key) || ts.isStringLiteralLike(key) || ts.isNumericLiteral(key) || ts.isComputedPropertyName(key)
+                        ? patternKeyNameOf(lowerer, key) : null;
+                    if (name === null)
+                        lowerer.unsupported("SC1031", sibling, "rest bindings beside runtime computed keys");
+                    keys.push({ kind: "dynFrom", value: { kind: "strLit", value: name, type: STRING, loc }, type: DYN, loc });
+                }
+                lowerer.bindPatternTarget(el.name, { kind: "libCall", fn: "dyn.objectRest", args: [srcRef(),
+                        { kind: "dynArrLit", elems: keys, type: DYN, loc }], type: DYN, loc }, isLet, out, allowDynObject);
+                continue;
             }
             const prop = el.propertyName ?? el.name;
             const propName = ts.isIdentifier(prop) || ts.isComputedPropertyName(prop) || ts.isStringLiteralLike(prop) || ts.isNumericLiteral(prop)
@@ -2058,6 +2139,17 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             lowerer.bindPatternTarget(el.name, value, isLet, out);
             continue;
         }
+        if (!fieldType && isJsSourceFile(el.getSourceFile())) {
+            // Inferred JavaScript shapes can omit optional own properties and
+            // inherit values from their prototype. Read the live checked view.
+            const loc = locOf(el);
+            let value = { kind: "dynKeyGet", value: lowerer.coerceToExpected(srcRef(), DYN),
+                key: { kind: "strLit", value: propName, type: STRING, loc }, type: DYN, loc };
+            if (el.initializer)
+                value = applyBindingDefault(lowerer, el, value);
+            lowerer.bindPatternTarget(el.name, value, isLet, out);
+            continue;
+        }
         if (!fieldType) {
             // The pattern names a field the source SHAPE does not carry —
             // `for (let {x = 1} of [{}])` (signature 08): tsc types the binding
@@ -2108,7 +2200,8 @@ function patternSourceValue(lowerer, value, arrayPattern, out, loc, spelling) {
     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)
+    if (!arms || !present?.length || present.length === arms.length ||
+        (present.length > 1 && !(arrayPattern && present.every((arm) => arm.kind === "array"))))
         return value;
     for (const [tag, arm] of arms.entries()) {
         if (!isUnitType(arm))
@@ -2124,13 +2217,18 @@ function patternSourceValue(lowerer, value, arrayPattern, out, loc, spelling) {
             else_: null, loc,
         });
     }
-    return { kind: "unionNarrow", unionId, tag: lowerer.armTag(unionId, present[0]), value, type: present[0], loc };
+    if (present.length === 1) {
+        return { kind: "unionNarrow", unionId, tag: lowerer.armTag(unionId, present[0]), value, type: present[0], loc };
+    }
+    const type = { kind: "union", unionId: lowerer.unions.intern(present) };
+    return lowerer.coerceToExpected(value, type);
 }
 /** 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). */
+   * when the type has no static mapping or checked JS fallback. */
 function patternBindingType(lowerer, name) {
-    return lowerer.mapTypeOf(lowerer.typeOf(name));
+    const type = lowerer.typeOf(name);
+    return lowerer.mapTypeOf(type) ?? (isJsSourceFile(name.getSourceFile()) ? dynFallbackType(lowerer, name, type) : null);
 }
 /** The STATIC property name of a destructuring key: identifiers spell
    * themselves, string/numeric-literal keys and COMPUTED keys fold through
@@ -2334,7 +2432,7 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             lowerer.unsupported("SC1031", el, `destructuring the member '${propName}' of the builtin global '${globalName}' (a detached member loses its receiver-keyed lowering — call it through the global)`);
         }
         const symbol = lowerer.checker.getSymbolAtLocation(el.name);
-        if (!symbol || lowerer.tdzPredeclared.has(symbol)) {
+        if (!symbol || lowerer.ctx.tdzPredeclared.has(symbol)) {
             lowerer.unsupported("SC1031", el, `bindings with predeclared slots over the builtin global '${globalName}'`);
         }
         const g = lowerer.globalsBySymbol.get(symbol);
@@ -2353,7 +2451,7 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
                 lowerer.stdlibGlobalAliases.set(symbol, b.alias);
         }
         if (b.g !== undefined) {
-            out.push({ kind: "assign", localId: b.g.id, value: lowerer.coerceInto(b.name, token, b.g.type), loc });
+            out.push({ kind: "assign", localId: b.g.id, value: lowerer.coerceInto(b.name, token, b.g.type), ...(b.g.tdz ? { initializes: true } : {}), loc });
         }
         else {
             const local = lowerer.declareLocal(b.name, b.name.text, STRING, isLet);
@@ -2372,6 +2470,14 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
    * alike (the caller's bindPatternTarget recurses through the latter). */
 function applyBindingDefault(lowerer, el, value) {
     const name = el.name; // callers skip nameless elisions
+    if (value.type.kind === "dyn") {
+        const loc = value.loc;
+        const local = lowerer.declareHiddenLocal("%bindingDefault", DYN);
+        const ref = varRef(local.id, DYN, loc);
+        const result = { kind: "ternary", cond: { kind: "dynTest", test: "undefined", value: ref, type: BOOL, loc },
+            then: lowerer.lowerExprExpecting(el.initializer, DYN), else_: ref, type: DYN, loc };
+        return { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: local.id, init: value, loc }], result, type: DYN, loc };
+    }
     if (value.type.kind !== "union")
         return value; // no undefined arm: dead default
     if (lowerer.armTag(value.type.unionId, UNDEFINED_T) < 0)
@@ -2401,7 +2507,12 @@ function undefArmDefault(lowerer, blame, init, value, bodyT) {
         return { kind: "ternary", cond: isUndef, then: dflt, else_: value, type: bodyT, loc };
     }
     let present = null;
-    if (bodyT.kind === "union") {
+    if (bodyT.kind === "dyn" && lowerer.dynConvertible(fieldType)) {
+        // The undefined arm is handled by the ternary. A present JSON-safe
+        // union can cross into the binding's checked-dynamic slot.
+        present = lowerer.coerceInto(blame, value, bodyT);
+    }
+    else if (bodyT.kind === "union") {
         const retag = lowerer.unionRetagHelper(fieldType.unionId, bodyT.unionId, loc);
         if (retag)
             present = { kind: "call", callee: retag, args: [value], type: bodyT, loc };
@@ -2644,6 +2755,9 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
    * JS skips them and so does the packing. */
 function classInstanceRestValue(lowerer, blame, srcRef, srcType, info, consumed, restT) {
     const loc = locOf(blame);
+    if (info.symbolFields?.size) {
+        lowerer.unsupported("SC1031", blame, "rest bindings over class instances with symbol-keyed fields (the copied symbols have no record form)");
+    }
     for (let c = info; c; c = c.base) {
         if (c.builtinError || c.builtinEmitter || c.builtinStream) {
             lowerer.unsupported("SC1031", blame, "rest bindings over runtime-provided class instances (Error/EventEmitter/stream internals have no record form)");
@@ -2905,7 +3019,7 @@ function enginePatternSpec(lowerer, pattern) {
                     const d = exprText(el.initializer, boundBefore);
                     if (d === null)
                         return null;
-                    sub += `=${d}`;
+                    sub = sub + `=${d}`;
                 }
                 parts.push(el.dotDotDotToken ? `...${sub}` : sub);
             }
@@ -2950,7 +3064,7 @@ function enginePatternSpec(lowerer, pattern) {
                 const d = exprText(el.initializer, boundBefore);
                 if (d === null)
                     return null;
-                sub += `=${d}`;
+                sub = sub + `=${d}`;
             }
             parts.push(`[${key}]:${sub}`);
         }
@@ -3026,7 +3140,7 @@ export function lowerJsvalBindingPattern(lowerer, pattern, srcRef, isLet, out) {
         const symbol = lowerer.checker.getSymbolAtLocation(name);
         const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
         if (g) {
-            out.push({ kind: "assign", localId: g.id, value: lowerer.coerceInto(name, value, g.type), loc: bindLoc });
+            out.push({ kind: "assign", localId: g.id, value: lowerer.coerceInto(name, value, g.type), ...(g.tdz ? { initializes: true } : {}), loc: bindLoc });
             return;
         }
         if (symbol && hostVariableDeclarationOf(name) !== null && isVarDeclared(name)) {
@@ -3056,7 +3170,7 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
         const symbol = lowerer.checker.getSymbolAtLocation(name);
         const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
         if (g) {
-            out.push({ kind: "assign", localId: g.id, value: lowerer.coerceInto(name, value, g.type), loc });
+            out.push({ kind: "assign", localId: g.id, value: lowerer.coerceInto(name, value, g.type), ...(g.tdz ? { initializes: true } : {}), loc });
             return;
         }
         // A `var`-declared pattern name assigns its function-scoped hoisted
@@ -3115,13 +3229,9 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
     out.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
     lowerer.lowerBindingPattern(name, () => ({ kind: "varRef", localId: tmp.id, type: value.type, loc }), value.type, isLet, out, undefined, allowDynObject);
 }
-/** For-loop initializers. let/const stay restricted to ONE declarator (JS
-   * per-iteration binding copies for several captured loop variables are
-   * not modeled yet); `var` initializers take any number — a `var` is ONE
-   * function-scoped binding with no per-iteration copies to model, so
-   * `for (var i = 0, n = xs.length; ...)` is just two hoisted-slot
-   * assignments (wrapped in a block when several). Statement position goes
-   * through lowerVarStatement. */
+/** For-loop initializers evaluate declarators from left to right. The LLVM
+ * loop emitter keeps their scope alive and freshens every captured let
+ * binding before the first condition and each subsequent update. */
 export function lowerVarDeclList(lowerer, list) {
     if ((list.flags & ts.NodeFlags.Using) !== 0) {
         lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
@@ -3144,23 +3254,19 @@ export function lowerVarDeclList(lowerer, list) {
             return out[0];
         return { kind: "block", body: out, loc: locOf(list) };
     }
-    if (list.declarations.length !== 1) {
-        lowerer.unsupported("SC1090", list, "multi-declaration for-loop initializers");
+    const out = [];
+    for (const decl of list.declarations) {
+        if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
+            // Destructuring produces nested initialization blocks; copying
+            // their captured bindings still needs a distinct head-scope plan.
+            lowerer.unsupported("SC1031", decl.name, "let/const destructuring in for-loop initializers (declare the pattern before the loop, or use var)");
+        }
+        const lowered = lowerer.lowerVarDecl(decl, isLet);
+        if (!lowered)
+            throw new InternalCompilerError("lowerer bug: for-init declarator resolved to a global");
+        out.push(lowered);
     }
-    const decl = list.declarations[0];
-    if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
-        // `for (let [x] = init; ...)`: the desugar is a multi-statement
-        // block, and the backend's per-iteration fresh-binding copy (what
-        // makes closures in iteration k see iteration k's let) keys off a
-        // single varDecl init — a captured destructured head would silently
-        // share one binding. `var` heads above have no per-iteration story
-        // and lower; let/const keep an honest fence.
-        lowerer.unsupported("SC1031", decl.name, "let/const destructuring in for-loop initializers (declare the pattern before the loop, or use var)");
-    }
-    const lowered = lowerer.lowerVarDecl(decl, isLet);
-    if (!lowered)
-        throw new InternalCompilerError("lowerer bug: for-init declarator resolved to a global");
-    return lowered;
+    return out.length === 1 ? out[0] : { kind: "block", body: out, loc: locOf(list) };
 }
 /** A single static type for an initializer-less JavaScript `let` whose
  * later plain writes all agree. An evolving JS local reads as `undefined`
@@ -3173,7 +3279,7 @@ function inferredEvolvingLetType(lowerer, decl) {
     if (!ts.isIdentifier(decl.name))
         return null;
     const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
-    const scope = decl.parent.parent.parent;
+    const scope = decl.parent?.parent?.parent;
     if (symbol === undefined || (!ts.isBlock(scope) && !ts.isSourceFile(scope)))
         return null;
     const isPlainAssignmentTarget = (node) => {
@@ -3313,8 +3419,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // and keep the plain-variable lowering.
     if (!decl.initializer &&
         (decl.name.text === "module" || decl.name.text === "exports") &&
-        ts.isVariableStatement(decl.parent.parent) &&
-        ts.isSourceFile(decl.parent.parent.parent) &&
+        ts.isVariableStatement(decl.parent?.parent) &&
+        ts.isSourceFile(decl.parent?.parent?.parent) &&
         !isJsSourceFile(decl.getSourceFile()) &&
         !decl.getSourceFile().statements.some((s) => ts.isImportDeclaration(s) || ts.isExportDeclaration(s) || ts.isExportAssignment(s) ||
             (ts.canHaveModifiers(s) && ts.getModifiers(s)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true))) {
@@ -3335,7 +3441,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // plumbing: each call through the binding resolves per site
     // (lowerCreateRequireCall); no storage, no code (collectGlobals
     // skipped its global by the same test).
-    if (!isLet && createRequireBindingDecl(lowerer, decl.name, decl.initializer))
+    if (createRequireBindingDecl(lowerer, decl.name, decl.initializer))
         return null;
     // `const fs = require("node:fs")` through that binding — a builtin
     // namespace import in const clothing: alias plumbing, no storage
@@ -3366,13 +3472,6 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             })());
     if (stableStdlibAlias && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
         return null;
-    // `const encoder = new TextEncoder()` and a statically-labelled
-    // TextDecoder twin: the codec has no general value representation, but calls
-    // through this stable binding resolve back to the initializer. The
-    // supported constructors are effect-free, so the declaration itself
-    // is compile-time alias plumbing with no storage or code.
-    if (!isLet && textCodecBindingDecl(lowerer, decl.name, decl.initializer))
-        return null;
     // `const f = <T>(x: T) => x` — a generic function value binding: the
     // initializer monomorphizes per call-site-resolved signature exactly
     // like a generic function declaration (bindingGenericFnInfoOf —
@@ -3478,7 +3577,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 return { kind: "assign", localId: g.id, value: wrapped, loc: locOf(decl) };
             return null;
         }
-        const raw = lowerVariableInitializer(lowerer, decl.initializer);
+        const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" && (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
+            ts.isArrayLiteralExpression(decl.initializer) || ts.isObjectLiteralExpression(decl.initializer)) ? DYN : undefined);
         const arithmetic = raw.type.kind === "union"
             ? lowerer.unions.get(raw.type.unionId)?.arms
             : undefined;
@@ -3488,17 +3588,17 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             lowerer.runtimeOptionalArithmeticGlobals.add(g);
         }
         const init = lowerer.coerceInto(decl.initializer, raw, g.type);
-        return { kind: "assign", localId: g.id, value: init, loc: locOf(decl) };
+        return { kind: "assign", localId: g.id, value: init, ...(g.tdz ? { initializes: true } : {}), loc: locOf(decl) };
     }
-    // A forward-captured const pre-declared as a TDZ box (an earlier
+    // A forward-captured binding pre-declared as a TDZ box (an earlier
     // function in this scope captured it — predeclareForwardCapture): the
     // binding and its scope-entry varDecl already exist; the source
     // declaration is the one initializing `assign` into the shared box.
-    const pre = declSymbol ? lowerer.tdzPredeclared.get(declSymbol) : undefined;
+    const pre = declSymbol ? lowerer.ctx.tdzPredeclared.get(declSymbol) : undefined;
     if (pre && decl.initializer) {
-        lowerer.tdzPredeclared.delete(declSymbol);
+        lowerer.ctx.tdzPredeclared.delete(declSymbol);
         const init = lowerer.lowerExprExpecting(decl.initializer, pre.type);
-        return { kind: "assign", localId: pre.id, value: init, loc: locOf(decl) };
+        return { kind: "assign", localId: pre.id, value: init, initializes: true, loc: locOf(decl) };
     }
     // `var x = e` — an ASSIGNMENT into the function-scoped hoisted slot
     // (hoistVarBinding mints it on first encounter and pushes its varDecl
@@ -3529,7 +3629,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         // `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).
-        if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
+        if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name), lowerer.typeParamResolver)) {
             type = unitOnlyUnion(lowerer.unions);
         }
         if (type.kind === "void")
@@ -3546,11 +3646,19 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // function (with its hint), not the unmappable declared type. If it
     // poisons, still declare the local when its type is representable, so
     // later references to this name don't produce cascading errors.
+    const inferredObjectType = isJsSourceFile(decl.getSourceFile()) ? lowerer.mapTypeOf(lowerer.typeOf(decl.name)) : null;
+    const inferredObjectArms = inferredObjectType?.kind === "union"
+        ? lowerer.unions.get(inferredObjectType.unionId)?.arms ?? [] : inferredObjectType ? [inferredObjectType] : [];
+    const expandsObject = !decl.type && !hasJsTypeAnnotation(decl) && inferredObjectType !== null &&
+        jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn" ||
+        inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm));
     let init;
     try {
-        init = immediatelyGuardedAbsenceProbe(lowerer, decl)
+        init = expandsObject || (isJsSourceFile(decl.getSourceFile()) && !decl.type &&
+            isNativeBuiltinValueInitializer(lowerer, decl.initializer)) ? lowerer.lowerExprExpecting(decl.initializer, DYN) : immediatelyGuardedAbsenceProbe(lowerer, decl)
             ? (lowerAbsenceProbe(lowerer, decl.initializer) ?? lowerer.lowerExpr(decl.initializer))
-            : lowerVariableInitializer(lowerer, decl.initializer);
+            : lowerVariableInitializer(lowerer, decl.initializer, decl.type && (lowerer.typeOf(decl.name).flags & ts.TypeFlags.Never) === 0
+                ? lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? undefined : undefined);
     }
     catch (e) {
         if (e instanceof PoisonError) {
@@ -3598,12 +3706,31 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         staticImportNamespaceType(lowerer, decl.initializer) ??
         (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) && init.type.kind === "func")
+        type = init.type;
     if (lowerer.implicitParamTypes !== null &&
         init.type.kind === "dyn" &&
         isJsSourceFile(decl.getSourceFile()) &&
         npmStaticPackageOfPath(decl.getSourceFile().fileName) !== null) {
         type = DYN;
     }
+    const preservesObjectIdentity = init.type.kind === "dyn" &&
+        (inferredObjectType?.kind === "record" || inferredObjectType?.kind === "array" ||
+            (isJsSourceFile(decl.getSourceFile()) && inferredObjectArms.some((arm) => arm.kind === "record") &&
+                inferredObjectArms.every((arm) => isUnitType(arm) || arm.kind === "record")) ||
+            (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
+                (inferredObjectType.kind === "date" || inferredObjectType.kind === "func" || inferredObjectType.kind === "object" || jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn")) ||
+            (isJsSourceFile(decl.getSourceFile()) && inferredObjectType !== null &&
+                (inferredObjectType.kind === "void" || isUnitType(inferredObjectType) || inferredObjectType.kind === "union" && lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType)))) &&
+        !decl.type && !hasJsTypeAnnotation(decl);
+    if (expandsObject || preservesObjectIdentity || (isJsSourceFile(decl.getSourceFile()) &&
+        !decl.type && isNativeBuiltinValueInitializer(lowerer, decl.initializer))) {
+        type = DYN;
+    }
+    if (isJsSourceFile(decl.getSourceFile()) && !decl.type && init.type.kind === "array" && init.type.elem.kind === "dyn" &&
+        (ts.isNewExpression(decl.initializer) || ts.isCallExpression(decl.initializer)) && lowerer.isStdlibGlobal(decl.initializer.expression, "Array")) {
+        type = init.type;
+    }
     // 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
@@ -3616,6 +3743,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
+    if (isLet && type !== null && isJsSourceFile(decl.getSourceFile()) && !decl.type && !hasJsTypeAnnotation(decl) &&
+        (type.kind === "object" || type.kind === "symbol" || jsBindingHasOpenWrites(lowerer, decl))) {
+        type = DYN;
+    }
     const returnedEmptyArrayType = npmStaticReturnedEmptyArrayType(lowerer, decl);
     if (returnedEmptyArrayType !== null) {
         type = returnedEmptyArrayType;
@@ -3681,7 +3812,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // static signature would wrap an arity-narrowing adapter that DROPS
     // arguments JS would deliver; calls through the dyn binding take the
     // boxed thunk's JS arity instead.
-    if (type?.kind === "func" && init.type.kind === "dyn" && isJsSourceFile(decl.getSourceFile())) {
+    if (type?.kind === "func" && init.type.kind === "dyn" &&
+        (isJsSourceFile(decl.getSourceFile()) ||
+            !decl.type && !hasJsTypeAnnotation(decl) && type.rest === true && type.restAbi === undefined)) {
         type = DYN;
     }
     // A checker-`any` CONST whose initializer lowered to a STATIC type
@@ -3718,6 +3851,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     if (!type)
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     let settledType = type;
+    if (!isLet && isJsSourceFile(decl.getSourceFile()) && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isNewExpression(decl.initializer)) {
+        settledType = init.type.kind === "dyn" ? DYN : objectFactorySignature(lowerer, decl.initializer)?.returnType ?? settledType;
+    }
     const arithmeticType = decl.initializer ? lowerer.runtimeOptionalArithmeticTypes.get(decl.initializer) : undefined;
     const isStringArithmeticUnion = (t) => {
         if (t.kind !== "union")
@@ -3734,16 +3870,26 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     const optionalSelfWriteType = isLet
         ? npmStaticOptionalSelfWriteType(lowerer, decl, settledType)
         : null;
-    settledType = lowerer.runtimeOptionalBindingType(decl.name, settledType);
+    settledType = expandsObject || preservesObjectIdentity ? DYN : lowerer.runtimeOptionalBindingType(decl.name, settledType);
     if (optionalSelfWriteType !== null)
         settledType = optionalSelfWriteType;
     if (returnedEmptyArrayType !== null)
         settledType = returnedEmptyArrayType;
+    // Exhaustiveness witnesses (`const unreachable: never = value`) have
+    // no useful checker layout, but their initializer still has a runtime
+    // representation. Preserve it instead of forcing never's numeric
+    // placeholder onto a recursive union or string. Keeping the value also
+    // preserves behavior when an explicit assertion makes this reachable.
+    if (!isLet && lowerer.checker.isNeverType(lowerer.typeOf(decl.name)) &&
+        init.type.kind !== "void" && !isUnitType(init.type)) {
+        settledType = init.type;
+    }
     // `const x: void = undefined` / `let y: undefined = undefined`: the
     // unit-only union — the initializer's unit literal wraps into its arm
-    // like any optional completion. Non-literal void initializers (a
-    // void CALL's result) keep their fence at the coercion below.
-    if (settledType.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
+    // like any optional completion. A generic visitor can bind the slot's
+    // T to void; consult that binding before deciding its value layout.
+    // coerceInto preserves a void call's effects before wrapping undefined.
+    if (settledType.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name), lowerer.typeParamResolver)) {
         settledType = unitOnlyUnion(lowerer.unions);
     }
     if (settledType.kind === "void")
@@ -3817,15 +3963,15 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         settledType = init.type;
     }
     // A TDZ box minted DURING this very initializer (a callback inside it
-    // captured this const — predeclareForwardCapture's current-statement
+    // captured this binding — predeclareForwardCapture's current-statement
     // case): the binding and its scope-entry varDecl already exist, so
     // this declaration is the initializing `assign` into the shared box,
     // not a fresh local.
-    const preSelf = declSymbol ? lowerer.tdzPredeclared.get(declSymbol) : undefined;
+    const preSelf = declSymbol ? lowerer.ctx.tdzPredeclared.get(declSymbol) : undefined;
     if (preSelf) {
-        lowerer.tdzPredeclared.delete(declSymbol);
+        lowerer.ctx.tdzPredeclared.delete(declSymbol);
         init = lowerer.coerceInto(decl.initializer, init, preSelf.type);
-        return { kind: "assign", localId: preSelf.id, value: init, loc: locOf(decl) };
+        return { kind: "assign", localId: preSelf.id, value: init, initializes: true, loc: locOf(decl) };
     }
     // Slot coercion: `const r: A | B = bValue;` wraps implicitly; width
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
@@ -3841,7 +3987,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
 }
-function lowerVariableInitializer(lowerer, node) {
+function lowerVariableInitializer(lowerer, node, expected) {
     let value = node;
     while (ts.isParenthesizedExpression(value) ||
         ts.isAsExpression(value) ||
@@ -3849,8 +3995,20 @@ function lowerVariableInitializer(lowerer, node) {
         ts.isSatisfiesExpression(value)) {
         value = value.expression;
     }
-    if (!ts.isObjectLiteralExpression(value))
-        return lowerer.lowerExpr(node);
+    // An explicit destination supplies the layout for fresh construction,
+    // including either arm of a conditional. Existing values still pass
+    // through the normal conversion and alias-preservation rules.
+    if (!ts.isObjectLiteralExpression(value)) {
+        // Empty Map/Set construction can use its destination, but class
+        // instances must retain their nominal layout for generic dispatch.
+        const empty = expected ? lowerer.emptyCollectionFor(node, expected) : null;
+        if (empty)
+            return lowerer.coerceInto(node, empty, expected);
+        return ts.isArrayLiteralExpression(value) || ts.isConditionalExpression(value)
+            ? lowerer.lowerExprExpecting(node, expected) : lowerer.lowerExpr(node);
+    }
+    if (expected?.kind === "dyn")
+        return lowerDynObjectLiteral(lowerer, value);
     const previous = new Map();
     for (const property of value.properties) {
         if (!ts.isPropertyAssignment(property) || !ts.isComputedPropertyName(property.name))
@@ -3864,7 +4022,7 @@ function lowerVariableInitializer(lowerer, node) {
         lowerer.chainRecvByNode.set(keyNode, lowerer.ensureString(optional, keyNode));
     }
     try {
-        return lowerer.lowerExpr(node);
+        return lowerer.lowerExprExpecting(node, expected);
     }
     finally {
         for (const [keyNode, prior] of previous) {
@@ -3875,6 +4033,118 @@ function lowerVariableInitializer(lowerer, node) {
         }
     }
 }
+/** A JS object literal's inferred fields do not close its later storage.
+ * Keep the original native object when writes add keys or delete fields;
+ * converting it to a fixed record would discard that behavior. */
+function jsObjectBindingExpands(lowerer, decl, type) {
+    if (decl.type || !decl.initializer || !ts.isIdentifier(decl.name) || !isJsSourceFile(decl.getSourceFile()))
+        return false;
+    let initializer = decl.initializer;
+    while (ts.isParenthesizedExpression(initializer))
+        initializer = initializer.expression;
+    if (!ts.isObjectLiteralExpression(initializer) && !ts.isCallExpression(initializer))
+        return false;
+    if (hasJsTypeAnnotation(decl))
+        return false;
+    // A generic clone retains its declared T contract. Its instantiated
+    // record is also the factory's return/capture layout; it is not an
+    // anonymous JavaScript object whose fields came only from inference.
+    if (lowerer.typeParamResolver(lowerer.typeOf(decl.name)) !== null)
+        return false;
+    const symbol = lowerer.resolveValueSymbol(decl.name);
+    const shape = lowerer.shapes.get(type.shapeId);
+    if (!symbol || !shape)
+        return false;
+    const names = new Set(shape.fields.map((field) => field.name));
+    let scope = decl;
+    while (scope.parent && !ts.isFunctionLike(scope) && !ts.isSourceFile(scope))
+        scope = scope.parent;
+    const aliases = new Set([symbol]);
+    const unwrap = (node) => {
+        while (ts.isParenthesizedExpression(node))
+            node = node.expression;
+        return node;
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const collect = (node) => {
+            if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && !node.type && !hasJsTypeAnnotation(node)) {
+                const source = unwrap(node.initializer);
+                const sourceSymbol = ts.isIdentifier(source) ? lowerer.resolveValueSymbol(source) : undefined;
+                const alias = lowerer.resolveValueSymbol(node.name);
+                if (sourceSymbol && aliases.has(sourceSymbol) && alias && !aliases.has(alias)) {
+                    aliases.add(alias);
+                    changed = true;
+                }
+            }
+            ts.forEachChild(node, collect);
+        };
+        collect(scope);
+    }
+    let expands = false;
+    const property = (node) => {
+        if (!ts.isPropertyAccessExpression(node) && !ts.isElementAccessExpression(node))
+            return undefined;
+        const receiver = unwrap(node.expression);
+        const receiverSymbol = ts.isIdentifier(receiver) ? lowerer.resolveValueSymbol(receiver) : undefined;
+        if (!receiverSymbol || !aliases.has(receiverSymbol))
+            return undefined;
+        if (ts.isPropertyAccessExpression(node))
+            return node.name.text;
+        return ts.isStringLiteral(node.argumentExpression) || ts.isNumericLiteral(node.argumentExpression)
+            ? node.argumentExpression.text : null;
+    };
+    const visit = (node) => {
+        if (expands)
+            return;
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
+            const name = property(node.left);
+            if (name === null || (name !== undefined && !names.has(name)))
+                expands = true;
+        }
+        if (ts.isDeleteExpression(node) && property(node.expression) !== undefined)
+            expands = true;
+        if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "setPrototypeOf" &&
+            lowerer.isStdlibGlobal(node.expression.expression, "Object")) {
+            const target = node.arguments[0];
+            const sym = target && ts.isIdentifier(target) ? lowerer.resolveValueSymbol(target) : undefined;
+            if (sym && aliases.has(sym))
+                expands = true;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(scope);
+    return expands;
+}
+export function hasJsTypeAnnotation(decl) {
+    const statement = decl.parent?.parent;
+    return !!statement && /@type\b/.test(decl.getSourceFile().text.slice(statement.pos, decl.getStart()));
+}
+/** Inferred JS scalar initializers do not constrain later writes through
+ * an any-valued callback. Keep those bindings open, including captured writes. */
+export function jsBindingHasOpenWrites(lowerer, decl) {
+    if (!isJsSourceFile(decl.getSourceFile()) || decl.type || hasJsTypeAnnotation(decl) || !ts.isIdentifier(decl.name))
+        return false;
+    const symbol = lowerer.resolveValueSymbol(decl.name);
+    if (!symbol)
+        return false;
+    let owner = decl;
+    while (owner.parent && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
+        owner = owner.parent;
+    let open = false;
+    ts.walkPreorder(owner, (node) => {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment && ts.isIdentifier(node.left) &&
+            lowerer.resolveValueSymbol(node.left) === symbol &&
+            (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+            open = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return open;
+}
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
     if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
         return false;
@@ -3899,96 +4169,71 @@ function immediatelyGuardedAbsenceProbe(lowerer, decl) {
         operand = operand.expression;
     return ts.isIdentifier(operand) && lowerer.resolveValueSymbol(operand) === lowerer.resolveValueSymbol(decl.name);
 }
-function falsyExitRuntimeOptionalLocal(lowerer, stmt) {
+function falsyExitRuntimeOptionalLocals(lowerer, stmt) {
     if (stmt.elseStatement)
-        return null;
-    let condition = stmt.expression;
-    while (ts.isParenthesizedExpression(condition))
-        condition = condition.expression;
-    if (!ts.isPrefixUnaryExpression(condition) || condition.operator !== ts.SyntaxKind.ExclamationToken)
-        return null;
-    let operand = condition.operand;
-    while (ts.isParenthesizedExpression(operand))
-        operand = operand.expression;
-    if (!ts.isIdentifier(operand))
-        return null;
-    const local = lowerer.resolveLocal(operand);
-    if (!local || !lowerer.runtimeOptionalLocals.has(lowerer.runtimeOptionalRootOf(local)))
-        return null;
-    const exits = ts.isReturnStatement(stmt.thenStatement) || ts.isThrowStatement(stmt.thenStatement) ||
-        (ts.isBlock(stmt.thenStatement) && stmt.thenStatement.statements.length > 0 &&
-            (ts.isReturnStatement(stmt.thenStatement.statements[stmt.thenStatement.statements.length - 1]) ||
-                ts.isThrowStatement(stmt.thenStatement.statements[stmt.thenStatement.statements.length - 1])));
-    return exits ? local : null;
+        return [];
+    let tail = stmt.thenStatement;
+    while (ts.isBlock(tail)) {
+        const last = tail.statements[tail.statements.length - 1];
+        if (!last)
+            return [];
+        tail = last;
+    }
+    const exits = ts.isReturnStatement(tail) || ts.isThrowStatement(tail) ||
+        ts.isContinueStatement(tail) || ts.isBreakStatement(tail);
+    return exits ? runtimeOptionalGuardIds(lowerer, stmt.expression, false) : [];
 }
 /** JS-exact switch (see docs/ir.md): one shared lexical scope for all case
    * bodies, lazy source-order test evaluation, fall-through. tsc has already
    * checked case-test comparability (TS2678) — the kind check below is the
    * backstop for cases tsc lets through (e.g. `unknown as` casts). */
 export function lowerSwitch(lowerer, stmt) {
-    // Labels consume HERE, before any nested statement can see them; the
-    // union desugar drops them (its if/else chain has no switch-end label
-    // point — labeled jumps naming this switch fence at the jump).
+    // Consume labels before a nested statement can claim them. All switch
+    // forms keep their own break target, including union comparisons.
     const labels = lowerer.takeLabels();
     const disc = lowerer.lowerExpr(stmt.expression);
-    const dk = disc.type.kind;
-    if (dk === "dyn")
-        return lowerDynSwitch(lowerer, stmt, disc);
-    if (dk === "union")
-        return lowerUnionSwitch(lowerer, stmt, disc);
-    if (dk !== "f64" && dk !== "string" && dk !== "bool") {
-        lowerer.unsupported("SC1090", stmt.expression, "switch on non-primitive values");
-    }
-    // The whole case-body sequence is ONE lexical scope in JS: a bare `let`
-    // in one case is visible in later cases.
-    lowerer.scopes.push(new Map());
-    try {
-        const cases = [];
-        for (const clause of stmt.caseBlock.clauses) {
-            let test = null;
-            if (ts.isCaseClause(clause)) {
-                test = lowerer.lowerExpr(clause.expression);
-                if (test.type.kind !== dk) {
-                    lowerer.unsupported("SC1090", clause.expression, "switch case tests of a different type than the discriminant");
+    return withRuntimeOptionalNarrowed(lowerer, runtimeOptionalGuardIds(lowerer, stmt.expression, null), () => {
+        const dk = disc.type.kind;
+        if (dk === "dyn")
+            return lowerDynSwitch(lowerer, stmt, disc, labels);
+        if (dk === "union")
+            return lowerUnionSwitch(lowerer, stmt, disc, labels);
+        if (dk !== "f64" && dk !== "string" && dk !== "bool") {
+            lowerer.unsupported("SC1090", stmt.expression, "switch on non-primitive values");
+        }
+        // The whole case-body sequence is ONE lexical scope in JS: a bare `let`
+        // in one case is visible in later cases.
+        lowerer.scopes.push(new Map());
+        try {
+            const cases = [];
+            for (const clause of stmt.caseBlock.clauses) {
+                let test = null;
+                if (ts.isCaseClause(clause)) {
+                    test = lowerer.lowerExpr(clause.expression);
+                    if (test.type.kind !== dk) {
+                        lowerer.unsupported("SC1090", clause.expression, "switch case tests of a different type than the discriminant");
+                    }
                 }
+                cases.push({ test, body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements)), labels) });
             }
-            cases.push({ test, body: lowerer.inCtl("switch", () => lowerer.lowerStmts(clause.statements), labels) });
+            return { kind: "switch", disc, cases, ...(labels && { labels }), loc: locOf(stmt) };
         }
-        return { kind: "switch", disc, cases, ...(labels && { labels }), loc: locOf(stmt) };
-    }
-    finally {
-        lowerer.scopes.pop();
-    }
+        finally {
+            lowerer.scopes.pop();
+        }
+    });
 }
-/** Switch on a UNION-typed discriminant (`switch (m.type)` over
-   * `string | undefined`): desugared to an if/else-if chain of per-union
-   * strict-equality tests (unionEq — the case value wraps into the union,
-   * 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 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);
-   * - each non-final clause must EXIT (a trailing unconditional break —
-   *   dropped, it's the chain's own exit — or a return/throw/continue):
-   *   real fall-through between bodies has no if/else shape;
-   * - any OTHER unlabeled break binding to this switch (a conditional
-   *   early break) is fenced — desugared, it would bind to an enclosing
-   *   loop instead;
-   * - `default` may sit anywhere in source (JS tests every case first;
-   *   the chain's final else reproduces that as long as its body exits or
-   *   is last).
-   * Case bodies share ONE lexical scope, exactly like the real switch. */
-function lowerUnionSwitch(lowerer, stmt, disc) {
+/** Compare a union discriminant through a boolean switch. The native switch
+ * already implements lazy case tests, shared scope, fallthrough and jumps;
+ * keeping that control-flow node avoids rebinding an early break to a loop. */
+function lowerUnionSwitch(lowerer, stmt, disc, labels) {
     if (disc.type.kind !== "union")
         throw new InternalCompilerError("lowerer bug: non-union disc");
     const unionType = disc.type;
     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) => {
+    return lowerBranchSwitch(lowerer, stmt, disc, labels, (stableDisc, test, expression) => {
         const unitTest = test.kind === "unitLit"
             ? lowerer.lowerUnitComparison(stableDisc, test, false, locOf(expression))
             : null;
@@ -4007,8 +4252,8 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
 /** 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) => {
+function lowerDynSwitch(lowerer, stmt, disc, labels) {
+    return lowerBranchSwitch(lowerer, stmt, disc, labels, (stableDisc, test, expression) => {
         if (test.kind === "unitLit") {
             return { kind: "dynTest", test: test.unit, value: stableDisc, type: BOOL, loc: locOf(expression) };
         }
@@ -4019,121 +4264,47 @@ function lowerDynSwitch(lowerer, stmt, disc) {
         return { kind: "dynScalarEq", left: stableDisc, right: test, type: BOOL, loc: locOf(expression) };
     });
 }
-function lowerBranchSwitch(lowerer, stmt, disc, compare) {
+function lowerBranchSwitch(lowerer, stmt, disc, labels, 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
-    // own exit; anywhere else (conditional early breaks) the desugar would
-    // rebind it to an enclosing loop. Walk each clause's statements without
-    // descending into nested breakable constructs or functions (their
-    // breaks are their own).
-    const findStrayBreak = (node) => {
-        if (ts.isBreakStatement(node))
-            return node;
-        if (ts.isForStatement(node) || ts.isForOfStatement(node) || ts.isForInStatement(node) ||
-            ts.isWhileStatement(node) || ts.isDoStatement(node) || ts.isSwitchStatement(node) ||
-            ts.isFunctionLike(node)) {
-            return null;
-        }
-        return ts.forEachChild(node, findStrayBreak) ?? null;
-    };
-    for (const clause of clauses) {
-        const last = clause.statements[clause.statements.length - 1];
-        for (const s of clause.statements) {
-            const stray = s === last && ts.isBreakStatement(s) && !s.label ? null : findStrayBreak(s);
-            if (stray) {
-                lowerer.unsupported("SC1090", stray, "early 'break' inside a union-typed switch (only a trailing break exits the desugared chain — restructure with if/else)");
-            }
-        }
-    }
-    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 statementExits(last);
-    };
-    // The whole case-body sequence is ONE lexical scope, like the real
-    // switch lowering.
+    // Even a plain variable must be snapshotted: a case expression can write
+    // it before the next comparison, without changing the switch value.
+    const temp = lowerer.declareHiddenLocal("%switch", disc.type);
+    const stableDisc = varRef(temp.id, disc.type, loc);
+    // Calls/assignments in a case test may mutate a captured discriminant
+    // binding. The checker still narrows that binding as if it were the
+    // snapshot. Keep the original tagged value in those case bodies.
+    const effectful = stmt.caseBlock.clauses.some((clause) => ts.isCaseClause(clause) &&
+        !ts.isStringLiteral(clause.expression) && !ts.isNumericLiteral(clause.expression) &&
+        !ts.isIdentifier(clause.expression) && clause.expression.kind !== ts.SyntaxKind.NullKeyword &&
+        clause.expression.kind !== ts.SyntaxKind.TrueKeyword && clause.expression.kind !== ts.SyntaxKind.FalseKeyword);
+    let binding = stmt.expression;
+    while (ts.isParenthesizedExpression(binding))
+        binding = binding.expression;
+    const symbol = effectful && ts.isIdentifier(binding) ? lowerer.resolveValueSymbol(binding) : undefined;
+    const alreadyUnstable = symbol != null && lowerer.unstableSwitchBindings.has(symbol);
+    if (symbol)
+        lowerer.unstableSwitchBindings.add(symbol);
     lowerer.scopes.push(new Map());
     try {
-        // Group clauses: consecutive test-only cases (empty statements) share
-        // the next body, exactly JS's grouped-case idiom.
-        const groups = [];
-        let pendingTests = [];
-        for (let i = 0; i < clauses.length; i++) {
-            const clause = clauses[i];
-            if (ts.isCaseClause(clause)) {
-                const test = lowerer.lowerExpr(clause.expression);
-                // Case tests must be side-effect-free (literals or plain reads):
-                // the chain evaluates exactly the tests JS would EXCEPT those of
-                // a default-sharing group (dropped — the shared body is the
-                // final else, so matching them changes nothing when pure).
-                if (test.kind !== "strLit" && test.kind !== "numLit" &&
-                    test.kind !== "boolLit" && test.kind !== "unitLit" &&
-                    !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
-                // test when the arm exists, the constant FALSE when the union
-                // 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).
-                pendingTests.push(compare(stableDisc, test, clause.expression));
-            }
-            const isDefault = ts.isDefaultClause(clause);
-            if (clause.statements.length === 0 && !isDefault && i < clauses.length - 1) {
-                continue; // grouped with the next clause
-            }
-            if (!exits(clause) && i < clauses.length - 1 && (clause.statements.length > 0 || isDefault)) {
-                // A non-final body that doesn't exit falls into the NEXT body in
-                // JS — no if/else shape reproduces that (an EMPTY non-final
-                // default falls through too; empty non-final cases just group).
-                lowerer.unsupported("SC1090", clause, "fall-through between case bodies in a union-typed switch (end each case with break/return/throw/continue)");
-            }
-            const last = clause.statements[clause.statements.length - 1];
-            const stmts = last && ts.isBreakStatement(last)
-                ? clause.statements.slice(0, -1)
-                : clause.statements.slice();
-            const body = lowerer.lowerStmts(stmts);
-            groups.push({ tests: pendingTests, body, isDefault });
-            pendingTests = [];
-        }
-        // A default clause anywhere lands in the chain's final else; JS
-        // reaches it only after every case test fails, which the chain
-        // reproduces because default bodies that don't exit were fenced
-        // above (unless last in source, where falling out is falling out).
-        const defaultBody = groups.find((g) => g.isDefault)?.body ?? null;
-        const caseGroups = groups.filter((g) => !g.isDefault);
-        let chain = defaultBody ?? [];
-        for (let i = caseGroups.length - 1; i >= 0; i--) {
-            const g = caseGroups[i];
-            let cond = g.tests[0];
-            if (!cond)
-                continue; // a default-adjacent group with no tests (defensive)
-            for (const t of g.tests.slice(1)) {
-                cond = { kind: "logical", op: "||", left: cond, right: t, type: BOOL, loc };
-            }
-            chain = [{ kind: "if", cond, then: g.body, else_: chain.length > 0 ? chain : null, loc }];
-        }
-        return { kind: "block", body: [...prefix, ...chain], loc };
+        const cases = stmt.caseBlock.clauses.map((clause) => ({
+            test: ts.isCaseClause(clause)
+                ? compare(stableDisc, lowerer.lowerExpr(clause.expression), clause.expression)
+                : null,
+            body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements)), labels),
+        }));
+        return {
+            kind: "block",
+            body: [
+                { kind: "varDecl", localId: temp.id, init: disc, loc },
+                { kind: "switch", disc: { kind: "boolLit", value: true, type: BOOL, loc }, cases, ...(labels && { labels }), loc },
+            ],
+            loc,
+        };
     }
     finally {
         lowerer.scopes.pop();
+        if (symbol && !alreadyUnstable)
+            lowerer.unstableSwitchBindings.delete(symbol);
     }
 }
 /** try/catch/finally:
@@ -4143,9 +4314,10 @@ function lowerBranchSwitch(lowerer, stmt, disc, compare) {
    *   narrowing tests (`e instanceof C` over hierarchy classes, `typeof e
    *   === "string"/"number"/"boolean"`), reads under a proven narrow
    *   (caughtRead bridges them with caughtNarrow, trust-the-checker like
-   *   unionNarrow), and rethrow (`throw e`). Raw uses, captures, and
-   *   assignment are fenced (SC1063 and friends); destructuring patterns
-   *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
+   *   unionNarrow), and rethrow (`throw e`). Unsupported raw uses and
+   *   assignments are fenced (SC1063 and friends); destructuring patterns
+   *   are SC1062. Captures retain the snapshot beyond the catch scope.
+   *   The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
    * - `finally` runs on normal completion, exception paths, and every
    *   abrupt completion that crosses it. Return values are snapshotted
@@ -4187,6 +4359,28 @@ export function lowerTry(lowerer, stmt) {
         loc: locOf(stmt),
     };
 }
+function hasUseStrictDirective(statements) {
+    for (const statement of statements) {
+        if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression))
+            return false;
+        if (statement.expression.text === "use strict")
+            return true;
+    }
+    return false;
+}
+function isStrictDelete(node) {
+    for (let parent = node.parent; parent; parent = parent.parent) {
+        if (ts.isClassDeclaration(parent) || ts.isClassExpression(parent))
+            return true;
+        if (ts.isFunctionLike(parent) && parent.body && ts.isBlock(parent.body) && hasUseStrictDirective(parent.body.statements))
+            return true;
+        if (ts.isSourceFile(parent)) {
+            return hasUseStrictDirective(parent.statements) ||
+                (!isCjsJsFile(parent) && (isNodeEsmFile(parent) || ts.isExternalModule(parent)));
+        }
+    }
+    return false;
+}
 /** Statement-position `delete`: process.env keys → process.envUnset
    * (unsetenv), pure `Record<string, T>` keys → recordKeyDelete (the
    * overflow Map delete), declared OPTIONAL fields → the undefined-arm
@@ -4202,12 +4396,24 @@ function lowerDeleteStatement(lowerer, expr) {
         lowerer.unsupported("SC1090", expr, "'delete' of non-property expressions");
     }
     fenceNodeModuleMutation(lowerer, target, "delete");
+    if (ts.isPropertyAccessExpression(target) && target.name.text === "cause") {
+        const field = lowerer.fieldTarget(target);
+        if (field?.container === "errorCause") {
+            return { kind: "exprStmt", expr: { kind: "libCall", fn: "error.deleteCause", args: [field.obj], type: VOID, loc }, loc };
+        }
+    }
+    const globalKey = ts.isElementAccessExpression(target) ? globalSymbolKey(lowerer, target.expression, target.argumentExpression) : null;
+    if (globalKey)
+        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.globalSymbolDelete", args: [globalKey], type: VOID, loc }, loc };
     const lowerKey = () => {
         if (ts.isPropertyAccessExpression(target)) {
             return { kind: "strLit", value: target.name.text, type: STRING, loc: locOf(target.name) };
         }
         const keyNode = target.argumentExpression;
-        let key = lowerer.lowerExpr(keyNode);
+        let key = lowerer.isProcessEnv(target.expression) ? lowerEnvironmentKey(lowerer, keyNode) : lowerer.lowerExpr(keyNode);
+        if (key.type.kind === "dyn") {
+            key = { kind: "libCall", fn: "dyn.toStringCoerce", args: [key], type: STRING, loc: key.loc };
+        }
         if (lowerer.runtimeOptionalWidening(key.type, STRING) !== null) {
             key = lowerer.ensureString(key, keyNode);
         }
@@ -4223,7 +4429,28 @@ function lowerDeleteStatement(lowerer, expr) {
             loc,
         };
     }
-    const obj = lowerer.lowerExpr(target.expression);
+    let obj = lowerer.lowerExpr(target.expression);
+    if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "object") {
+        const info = lowerer.classes.get(obj.type.className);
+        const keyType = ts.isElementAccessExpression(target) ? lowerer.typeOf(target.argumentExpression) : null;
+        const name = ts.isPropertyAccessExpression(target) ? target.name.text
+            : keyType?.isStringLiteralType() ? keyType.value : null;
+        if (info && name !== null && isClassCallback(lowerer, info, name)) {
+            obj = { kind: "call", callee: classPropertiesHelper(lowerer, loc).name,
+                args: [lowerer.coerceToExpected(obj, DYN)], type: DYN, loc };
+        }
+    }
+    if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "func" && lowerer.dynConvertible(obj.type)) {
+        obj = lowerer.coerceToExpected(obj, DYN);
+    }
+    if (obj.type.kind === "dyn") {
+        const strict = { kind: "boolLit", value: isStrictDelete(expr), type: BOOL, loc };
+        if (ts.isElementAccessExpression(target)) {
+            const key = lowerer.lowerExprExpecting(target.argumentExpression, DYN);
+            return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keyDeleteComputed", args: [obj, key, strict], type: VOID, loc }, loc };
+        }
+        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keyDelete", args: [obj, lowerKey(), strict], type: VOID, loc }, loc };
+    }
     if (obj.type.kind === "record") {
         const shape = lowerer.shapes.get(obj.type.shapeId);
         if (shape?.indexValue && shape.fields.length === 0 && !shape.tuple) {
@@ -4520,7 +4747,7 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
         const exportSym = lowerer.checker.getSymbolAtLocation(expr.left);
         if (exportSym && !lowerer.classBySymbol.has(exportSym))
             lowerer.classBySymbol.set(exportSym, info);
-        return { kind: "block", body: [], loc };
+        return { kind: "exprStmt", expr: lowerer.lowerClassExpression(rhs), loc };
     }
     const g = lowerer.globalsByDeclNode.get(expr);
     if (!g)
@@ -4597,7 +4824,7 @@ export function lowerExprStatement(lowerer, expr) {
         }
     }
     // `yield* inner();` — statement-position delegation desugars to the
-    // forwarding loop (lower-generators); value positions keep the fence.
+    // forwarding loop (lower-generators), dropping the completed value.
     {
         const delegated = lowerYieldStarStatement(lowerer, expr);
         if (delegated)
@@ -4653,7 +4880,7 @@ export function lowerExprStatement(lowerer, expr) {
         // site (message with the one-entry require stack), CATCHABLE — the
         // optional-dependency try/require pattern. The compiled statement
         // IS that throw, wherever it sits.
-        if (isCjsJsFile(sf)) {
+        if (isCjsJsFile(sf, lowerer.program)) {
             if (!isRelativeSpecifier(spec) &&
                 canonicalBuiltinModule(spec) === null) {
                 const refusal = probeNodeRequireRefusal(sf.fileName, spec);
@@ -4673,7 +4900,7 @@ export function lowerExprStatement(lowerer, expr) {
                 }
             }
         }
-        if (isCjsJsFile(sf)) {
+        if (isCjsJsFile(sf, lowerer.program)) {
             const init = lowerer.requireInitStmt(spec, expr);
             if (init)
                 return init;
@@ -4728,6 +4955,9 @@ export function lowerExprStatement(lowerer, expr) {
             };
         }
         if (opKind === ts.SyntaxKind.EqualsToken) {
+            const callableWrite = lowerNativeFunctionAssignment(lowerer, expr);
+            if (callableWrite)
+                return { kind: "exprStmt", expr: callableWrite, loc: locOf(expr) };
             // Expando function members (`foo.bar = 12`, `foo[SYM] = v` on a
             // module-level function/callable const): the member's module
             // global (lower-expando.ts) — claimed by symbol identity before
@@ -4845,13 +5075,20 @@ export function lowerExprStatement(lowerer, expr) {
                 // SUBCLASS name (`D.x = v` creates an OWN property on D in JS —
                 // different storage) and through class VALUES (the same dynamic
                 // story) are named fences, never a silently-wrong global write.
-                if (!expr.left.questionDotToken && ts.isIdentifier(expr.left.expression)) {
+                if (!expr.left.questionDotToken && (ts.isIdentifier(expr.left.expression) || expr.left.expression.kind === ts.SyntaxKind.ThisKeyword)) {
                     // The receiver must BE the class exactly (its name, or a
                     // const binding holding a class expression) — a general class
                     // VALUE could hold a subclass, where JS creates an own
                     // property instead of writing this storage.
                     const classInfo = lowerer.exactClassOfReceiver(expr.left.expression);
                     if (classInfo) {
+                        const data = classStaticDataFor(lowerer, classInfo, expr.left.name.text, locOf(expr.left));
+                        if (data) {
+                            const loc = locOf(expr);
+                            const key = { kind: "strLit", value: expr.left.name.text, type: STRING, loc };
+                            const value = lowerer.lowerExprExpecting(expr.right, DYN);
+                            return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [data, key, value], type: VOID, loc }, loc };
+                        }
                         const found = lowerer.findStaticOn(classInfo, expr.left.name.text);
                         if (found?.field !== undefined) {
                             if (found.declarer !== classInfo) {
@@ -4952,17 +5189,50 @@ export function lowerExprStatement(lowerer, expr) {
                     if (viaStream)
                         return viaStream;
                 }
+                if (expr.left.name.text === "lastIndex" && lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression))?.kind === "regex") {
+                    const loc = locOf(expr);
+                    return { kind: "exprStmt", expr: { kind: "libCall", fn: "regex.resetLastIndex",
+                            args: [lowerer.lowerExpr(expr.left.expression), lowerer.lowerExprExpecting(expr.right, F64)], type: VOID, loc }, loc };
+                }
+                const unionWrite = lowerUnionFieldWrite(lowerer, expr.left, expr.right);
+                if (unionWrite)
+                    return unionWrite;
                 const target = lowerer.fieldTarget(expr.left);
                 if (target) {
                     const value = lowerer.lowerExprExpecting(expr.right, target.fieldType);
                     return lowerer.fieldSetStmt(target, value, locOf(expr), expr.left);
                 }
+                const callback = lowerClassCallbackAssign(lowerer, expr);
+                if (callback)
+                    return callback;
                 // A write to an ABSTRACT property through an abstract-typed
                 // receiver: the read fence's write twin (the declaration is
                 // erased at runtime — no shared slot exists to write).
                 if (abstractPropertyDeclOf(lowerer, expr.left)) {
                     lowerer.unsupported("SC1090", expr.left, `writing the abstract property '${expr.left.name.text}' through a '${lowerer.checker.typeToString(lowerer.typeOf(expr.left.expression))}'-typed receiver (abstract property declarations are erased at runtime, so no shared slot exists — type the receiver as the concrete class, or declare an abstract accessor pair instead)`);
                 }
+                if (!expr.left.questionDotToken) {
+                    const recv = tryLowerExpression(lowerer, expr.left.expression);
+                    if (recv?.type.kind === "object" && recv.type.className === "%Error") {
+                        const loc = locOf(expr);
+                        return { kind: "exprStmt", expr: { kind: "libCall", fn: "dyn.keySet", args: [
+                                    lowerer.coerceToExpected(recv, DYN), { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                    lowerer.lowerExprExpecting(expr.right, DYN),
+                                ], type: VOID, loc }, loc };
+                    }
+                    if (recv && isDynTypedRefType(recv.type)) {
+                        const info = lowerer.classes.get(recv.type.className);
+                        if (info && !info.def.runtime && !info.builtinError && !info.builtinEmitter && !info.builtinStream &&
+                            !isCompiledPrototypeMember(lowerer, info, expr.left.name.text)) {
+                            const loc = locOf(expr);
+                            return { kind: "exprStmt", expr: {
+                                    kind: "libCall", fn: "dyn.keySet", args: [lowerer.coerceToExpected(recv, DYN),
+                                        { kind: "strLit", value: expr.left.name.text, type: STRING, loc }, lowerer.lowerExprExpecting(expr.right, DYN)],
+                                    type: VOID, loc,
+                                }, loc };
+                        }
+                    }
+                }
                 // Dot WRITE to an undeclared key of an index-signature shape:
                 // the same deliberate fence as the dotted read, with the same
                 // fix in the message (brackets are the index-signature form).
@@ -5005,34 +5275,9 @@ export function lowerExprStatement(lowerer, expr) {
                 lowerer.runtimeOptionalLocals.add(runtimeOptionalRoot);
             return { kind: "assign", localId: target.id, value, loc: locOf(expr) };
         }
-        if (opKind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
-            // `x ??= e` on a VARIABLE, statement position: desugar to
-            // `x = x ?? e` (x read once, e lazy). For a plain variable JS's
-            // assign-only-when-nullish is unobservable — the value written back
-            // on the non-nullish path is the same box. Property targets keep a
-            // distinct fence: accessors would make the always-write observable.
-            if (!ts.isIdentifier(expr.left)) {
-                lowerer.unsupported("SC1090", expr.left, "'??=' on non-variable targets (write it out: if (o.f === undefined) o.f = v)");
-            }
-            const target = lowerer.resolveWritable(expr.left);
-            if (!target)
-                lowerer.rejectUnresolved(expr.left, `assignment to '${expr.left.text}' (not a writable local or module global)`);
-            const loc = locOf(expr);
-            if (target.type.kind !== "union") {
-                // The checker says never nullish: JS neither evaluates e nor
-                // assigns — the statement is a no-op (lowerNullishCoalesce's
-                // trust-the-checker fold, statement form).
-                return { kind: "block", body: [], loc };
-            }
-            const def = lowerer.unions.get(target.type.unionId);
-            if (!def)
-                lowerer.badType(expr.left, lowerer.typeOf(expr.left));
-            if (!def.arms.some(isUnitType))
-                return { kind: "block", body: [], loc };
-            const read = { kind: "varRef", localId: target.id, type: target.type, loc: locOf(expr.left) };
-            const right = lowerer.lowerExprExpecting(expr.right, target.type);
-            const value = { kind: "nullish", left: read, right, type: target.type, loc };
-            return { kind: "assign", localId: target.id, value, loc };
+        if (opKind === ts.SyntaxKind.QuestionQuestionEqualsToken ||
+            opKind === ts.SyntaxKind.AmpersandAmpersandEqualsToken || opKind === ts.SyntaxKind.BarBarEqualsToken) {
+            return { kind: "exprStmt", expr: lowerShortCircuitAssignment(lowerer, expr), loc: locOf(expr) };
         }
         const compound = COMPOUND_ASSIGN_OPS[opKind];
         if (compound !== undefined) {
@@ -5071,8 +5316,7 @@ export function lowerExprStatement(lowerer, expr) {
         }
         if (opKind >= ts.SyntaxKind.FirstCompoundAssignment &&
             opKind <= ts.SyntaxKind.LastCompoundAssignment) {
-            // Everything else is covered above; what remains is &&= and ||=.
-            lowerer.unsupported("SC1090", expr, "logical assignment (&&=, ||=) — write the if out");
+            lowerer.unsupported("SC1090", expr, "this compound assignment operator");
         }
     }
     if ((ts.isPrefixUnaryExpression(expr) || ts.isPostfixUnaryExpression(expr)) &&
@@ -5086,6 +5330,9 @@ export function lowerExprStatement(lowerer, expr) {
             // increment (the member's global IS the variable); expando
             // function members (`foo.count++`) are module globals too.
             if (ts.isPropertyAccessExpression(expr.operand) && !expr.operand.questionDotToken) {
+                const staticTarget = staticFieldWriteTarget(lowerer, expr.operand);
+                if (staticTarget)
+                    return lowerIncDecToTarget(lowerer, expr, staticTarget);
                 const exT = expandoWritableTarget(lowerer, expr.operand);
                 if (exT)
                     return lowerIncDecToTarget(lowerer, expr, exT);
@@ -5198,44 +5445,12 @@ function lowerIncDecToTarget(lowerer, expr, target) {
    * identifier form and the namespace-qualified spelling (`N.x += v`),
    * whose target is the member's module global. */
 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" };
-        const jop = JS_COMPOUND[compound];
-        if (jop === undefined)
-            lowerer.unsupported("SC1043", expr);
-        const wrapped = {
-            kind: "jsOp", op: jop,
-            args: [lowerer.jsvalIn(read, expr.left), lowerer.jsvalIn(rhs, expr.right)],
-            type: JSVAL, loc,
-        };
-        value = lowerer.coerceInto(expr, wrapped, target.type);
-    }
-    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" && 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") &&
-        (rhs.type.kind === "dyn" || rhs.type.kind === "f64") &&
-        isJsSourceFile(expr.getSourceFile())) {
-        // JS any-origin operands: check to number and compute natively
-        // (the binary-operator stance) — the dyn target takes the result
-        // back through the usual dyn conversion.
-        const checkNum = (e) => e.type.kind === "dyn" ? { kind: "dynCheck", value: e, type: F64, loc: e.loc } : e;
-        const computed = { kind: "bin", op: compound, left: checkNum(read), right: checkNum(rhs), type: F64, loc };
-        value = target.type.kind === "dyn" ? { kind: "dynFrom", value: computed, type: DYN, loc } : computed;
-    }
-    else {
-        lowerer.unsupported("SC1043", expr);
-    }
-    return { kind: "assign", localId: target.id, value, loc };
+    return {
+        kind: "assign",
+        localId: target.id,
+        value: lowerCompoundValueToTarget(lowerer, expr, compound, target),
+        loc: locOf(expr),
+    };
 }
 /** One destructuring-assignment pattern the island can run: empty object/
    * array patterns and flat identifier targets — shorthand `{ x }`,
@@ -5428,14 +5643,23 @@ export function lowerDestructuringAssign(lowerer, target, init, blame, loc) {
 }
 /** V8's spelling of a destructuring RHS in its TypeError message
    * ("Cannot destructure 'a' as it is undefined.") — plain identifiers
-   * spell their name (parens unwrap); everything else is V8's
-   * CallPrinter reconstruction, which is not reproduced — null keeps a
-   * fence at the caller. */
+   * spell their name (parens unwrap), and calls append an ellipsis to a
+   * supported callee spelling. Other CallPrinter forms keep a fence. */
 function destrSpellingOf(rhs) {
     let e = rhs;
     while (ts.isParenthesizedExpression(e))
         e = e.expression;
-    return ts.isIdentifier(e) ? e.text : null;
+    if (ts.isIdentifier(e))
+        return e.text;
+    if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) {
+        const base = destrSpellingOf(e.expression);
+        return base === null ? null : `${base}.${e.name.text}`;
+    }
+    if (ts.isCallExpression(e) && !e.questionDotToken) {
+        const callee = destrSpellingOf(e.expression);
+        return callee === null ? null : `${callee}(...)`;
+    }
+    return null;
 }
 /** Destructuring ASSIGNMENT (existing bindings — the declaration twin is
    * lowerDestructuringDecl): the RHS evaluates ONCE into a hidden temp,
@@ -5537,7 +5761,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
         if (!checkedByInner) {
             const spelling = rhs === null ? null : destrSpellingOf(rhs);
             if (spelling === null) {
-                lowerer.unsupported("SC1031", blame, "destructuring assignment from a checked-dynamic source that is not a plain variable (V8's TypeError spells the source expression — assign it to a variable first)");
+                lowerer.unsupported("SC1031", blame, "destructuring assignment from a checked-dynamic source whose expression spelling is unsupported (use a variable, ordinary property chain, or ordinary call)");
             }
             let firstProp;
             const p0 = target.properties[0];
@@ -6261,10 +6485,11 @@ 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. Typed
-    // async generators use the generic request protocol; process.stdin
-    // and readable streams retain their dedicated next-chunk paths.
-    if (stmt.awaitModifier) {
+    // A synchronous array iterator is also valid in `for await`. Its values
+    // take the async-from-sync path below; other async sources retain their
+    // dedicated request protocols.
+    const awaitArray = !!stmt.awaitModifier && lowerer.mapTypeOf(lowerer.typeOf(stmt.expression))?.kind === "array";
+    if (stmt.awaitModifier && !awaitArray) {
         {
             const genT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
             if (genT?.kind === "generator" && genT.async) {
@@ -6283,6 +6508,9 @@ export function lowerForOf(lowerer, stmt) {
             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)");
     }
+    if (awaitArray && !lowerer.ctx.isAsync) {
+        lowerer.unsupported("SC1090", stmt, "top-level 'for await' (await outside async functions)");
+    }
     lowerer.fenceStaticHeadersIteration(stmt.expression);
     // A stored numeric value iterator declared in this function keeps its
     // built-in protocol state in hidden locals (lowerVarStatement). The
@@ -6295,7 +6523,7 @@ export function lowerForOf(lowerer, stmt) {
         if (ts.isIdentifier(src)) {
             const sym = lowerer.resolveValueSymbol(src);
             const state = sym ? lowerer.numericIterators.get(sym) : undefined;
-            if (state?.ctx === lowerer.ctx) {
+            if (state && state.ctx === lowerer.ctx) {
                 return lowerForOfStoredNumericIterator(lowerer, stmt, state, labels);
             }
         }
@@ -6412,16 +6640,20 @@ export function lowerForOf(lowerer, stmt) {
     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.
+    // sees the inner value as an array, while its runtime slot retains
+    // undefined. An Array.isArray guard can also select the array from a
+    // node | node[] | undefined slot. Map lookups and optional fields also
+    // retain nullable runtime slots after a guard selects a concrete
+    // iterable. Validate the selected arm before choosing its iteration
+    // protocol; unchecked null assertions still throw at runtime.
     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 (iterable.type.kind === "union" && checkerIterable !== null &&
+        (checkerIterable.kind === "array" || checkerIterable.kind === "map" || checkerIterable.kind === "set" ||
+            checkerIterable.kind === "bytes" || checkerIterable.kind === "string" || checkerIterable.kind === "searchParams" ||
+            checkerIterable.kind === "generator" || checkerIterable.kind === "object")) {
+        const helper = lowerer.narrowedArmHelper(iterable.type.unionId, checkerIterable, locOf(iterSrc));
         if (helper)
-            iterable = { kind: "call", callee: helper, args: [iterable], type: present, loc: locOf(iterSrc) };
+            iterable = { kind: "call", callee: helper, args: [iterable], type: checkerIterable, loc: locOf(iterSrc) };
     }
     if (iterable.type.kind === "bytes") {
         return lowerForOfBytes(lowerer, stmt, iterable, labels);
@@ -6539,8 +6771,7 @@ export function lowerForOf(lowerer, stmt) {
         }
         // A CHECKED-DYNAMIC iterable (`unknown[]`, the collapsed
         // `(string | object)[]`, JSON-parsed values, wrapped engine
-        // values): the source packs ONCE through the spread walk and a
-        // hidden index loop binds each element as a dyn value.
+        // values): a checked IteratorRecord binds each yielded dyn value.
         if (iterable.type.kind === "dyn") {
             return lowerForOfDyn(lowerer, stmt, iterable, labels);
         }
@@ -6548,29 +6779,132 @@ export function lowerForOf(lowerer, stmt) {
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
         }
     }
-    const elemValueT = arrayValueType(lowerer, iterable.type.elem);
+    const yieldedT = arrayValueType(lowerer, iterable.type.elem);
+    let elemValueT = yieldedT;
+    let awaitPromiseTag = null;
+    if (awaitArray) {
+        let promiseElem = null;
+        if (iterable.type.elem.kind === "promise") {
+            promiseElem = iterable.type.elem;
+        }
+        else if (iterable.type.elem.kind === "union") {
+            const arms = lowerer.unions.get(iterable.type.elem.unionId)?.arms;
+            if (arms?.length === 2 && arms.some((arm) => arm.kind === "undefinedT")) {
+                const arm = arms.find((candidate) => candidate.kind === "promise");
+                if (arm?.kind === "promise")
+                    promiseElem = arm;
+            }
+        }
+        const nonThenable = (type) => {
+            if (type.kind === "union") {
+                const arms = lowerer.unions.get(type.unionId)?.arms;
+                return arms !== undefined && arms.every(nonThenable);
+            }
+            if (type.kind === "record") {
+                const shape = lowerer.shapes.get(type.shapeId);
+                return shape !== undefined && !shape.indexValue && !shape.fields.some((field) => field.name === "then");
+            }
+            return type.kind === "f64" || type.kind === "bigint" || type.kind === "string" ||
+                type.kind === "bool" || type.kind === "symbol" || type.kind === "array" ||
+                type.kind === "undefinedT" || type.kind === "nullT";
+        };
+        if (promiseElem && yieldedT.kind === "union" &&
+            !["void", "union", "dyn", "jsval", "undefinedT", "nullT"].includes(promiseElem.inner.kind)) {
+            awaitPromiseTag = lowerer.armTag(yieldedT.unionId, promiseElem);
+            elemValueT = lowerer.withUndefinedArm(promiseElem.inner);
+        }
+        else if (!nonThenable(iterable.type.elem)) {
+            lowerer.unsupported("SC1070", stmt.expression, "for-await over array values that may be promises or thenables");
+        }
+    }
     // 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),
-    });
+    const forValues = (localId, body) => {
+        const loc = locOf(stmt);
+        const needsClose = awaitArray ? lowerer.declareHiddenLocal("%arrayIteratorNeedsClose", BOOL) : null;
+        if (needsClose)
+            needsClose.mutable = true;
+        const yielded = arrayValueRead(lowerer, varRef(source.id, sourceT, loc), varRef(cursor.id, F64, loc), sourceT.elem, loc);
+        const init = awaitPromiseTag === null ? yielded : {
+            kind: "awaitUnionExpr", value: yielded, promiseTag: awaitPromiseTag, type: elemValueT, loc,
+        };
+        const hops = awaitArray ? (awaitPromiseTag === null ? 2 : 1) : 0;
+        const hop = () => ({
+            kind: "exprStmt", expr: { kind: "libCall", fn: "async.hop", args: [], type: VOID, loc }, loc,
+        });
+        const nextError = awaitPromiseTag !== null ? lowerer.declareHiddenLocal("%arrayIteratorNextError", CAUGHT) : null;
+        const awaitedValue = nextError ? lowerer.declareHiddenLocal("%arrayIteratorValue", elemValueT) : null;
+        if (awaitedValue)
+            awaitedValue.mutable = true;
+        const readValue = awaitedValue
+            ? { kind: "assign", localId: awaitedValue.id, value: init, loc }
+            : { kind: "varDecl", localId, init, loc };
+        const nextValue = nextError ? {
+            kind: "tryCatch",
+            tryBody: [readValue],
+            // Async-from-sync iteration has a continuation reaction between a
+            // rejected element promise and the loop's rejected next result.
+            catchBody: [hop(), { kind: "rethrow", localId: nextError.id, loc }],
+            catchLocalId: nextError.id,
+            finallyBody: null,
+            loc,
+        } : readValue;
+        const length = () => ({
+            kind: "arrIntrinsic", method: "length", receiver: varRef(source.id, sourceT, loc), args: [], type: F64, loc,
+        });
+        const loop = {
+            kind: "for",
+            init: { kind: "varDecl", localId: cursor.id, init: numLit(0, loc), loc },
+            cond: awaitArray
+                ? { kind: "boolLit", value: true, type: BOOL, loc }
+                : { kind: "bin", op: "<", left: varRef(cursor.id, F64, loc), right: length(), type: BOOL, loc },
+            update: { kind: "assign", localId: cursor.id, value: { kind: "bin", op: "+", left: varRef(cursor.id, F64, loc), right: numLit(1, loc), type: F64, loc }, loc },
+            body: [
+                ...(needsClose ? [{
+                        kind: "assign", localId: needsClose.id,
+                        value: { kind: "boolLit", value: false, type: BOOL, loc }, loc,
+                    }] : []),
+                ...(needsClose ? [{
+                        kind: "if",
+                        cond: { kind: "bin", op: ">=", left: varRef(cursor.id, F64, loc), right: length(), type: BOOL, loc },
+                        then: [hop(), hop(), { kind: "break", loc }],
+                        else_: null,
+                        loc,
+                    }] : []),
+                ...(awaitedValue ? [{ kind: "varDecl", localId: awaitedValue.id, init: null, loc }] : []),
+                nextValue,
+                ...(awaitedValue ? [{ kind: "varDecl", localId, init: varRef(awaitedValue.id, elemValueT, loc), loc }] : []),
+                ...Array.from({ length: hops }, hop),
+                // A rejected next value has no iterator close. Once a value has
+                // arrived, an abrupt completion in the body does await close.
+                ...(needsClose ? [{
+                        kind: "assign", localId: needsClose.id,
+                        value: { kind: "boolLit", value: true, type: BOOL, loc }, loc,
+                    }] : []),
+                ...body,
+            ],
+            ...(labels && { labels }),
+            loc,
+        };
+        return {
+            kind: "block",
+            body: [
+                { kind: "varDecl", localId: source.id, init: iterable, loc },
+                ...(needsClose ? [{ kind: "varDecl", localId: needsClose.id, init: { kind: "boolLit", value: false, type: BOOL, loc }, loc }] : []),
+                needsClose ? {
+                    kind: "tryCatch",
+                    tryBody: [loop], catchBody: null, catchLocalId: null,
+                    finallyBody: [{ kind: "if", cond: varRef(needsClose.id, BOOL, loc), then: [hop()], else_: null, loc }],
+                    loc,
+                } : loop,
+            ],
+            loc,
+        };
+    };
     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
@@ -6657,7 +6991,9 @@ export function lowerForOf(lowerer, stmt) {
             return forValues(tmp.id, [write, ...body]);
         }
         const local = lowerer.declareLocal(decl.name, decl.name.text, elemValueT, isLet);
-        if (!typeEquals(elemValueT, sourceT.elem)) {
+        const declaredElement = lowerer.mapTypeOf(lowerer.typeOf(decl.name));
+        if (!typeEquals(elemValueT, sourceT.elem) ||
+            (declaredElement !== null && lowerer.runtimeOptionalWidening(elemValueT, declaredElement) !== null)) {
             const root = lowerer.runtimeOptionalRootOf(local);
             lowerer.runtimeOptionalLocals.add(root);
             lowerer.runtimeOptionalStorageLocals.add(root);
@@ -7115,66 +7451,46 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
         lowerer.scopes.pop();
     }
 }
-/** for-of over an ISLAND value (see lowerForOf's jsval arm): the
- * engine's iterator protocol desugared over jsOps —
- *
- *   it = iterNew(v);            // GetIterator (prelude; may throw)
- *   while (true) {
- *     r = it.next();            // callMethod
- *     if (truthy(r.done)) break;
- *     <bind loop var(s) from r.value>  // getProp
- *     ...body
- *   }
- *
- * The loop variable's ELEMENT is an island handle (jsval — exactly what
- * the checker's package-typed element maps to); identifier heads bind
- * it per iteration, destructuring heads run the jsval pattern desugar,
- * pre-declared and var heads keep their fences (the array path's
- * stories don't carry over mechanically). IteratorClose on early exit
- * (break/return out of a partial iteration calling it.return()) is NOT
- * run — a divergence only a custom island iterator with a return()
- * method can observe. */
-/** For-of over a CHECKED-DYNAMIC iterable: the source packs ONCE
- * through the spread walk (dyn.iterPack — dyn arrays element-by-
- * element, strings by code point, bytes by byte; a WRAPPED engine
- * value drains through the ENGINE's own iterator protocol via the
- * iter_drain arm; every other kind throws V8's not-iterable
- * TypeError, the identifier spelling when the head has one), then a
- * hidden index loop binds each element as a dyn value. The pack is an
- * eager SNAPSHOT (the matchAll stance): body mutations of a dyn-array
- * source don't extend the iteration where JS's live array iterator
- * would — documented divergence; engine sources drain through their
- * own protocol, so generators/Maps/Sets step exactly once like Node. */
+/** A checked IteratorRecord stays live throughout the loop. Cache next once,
+ * read done before value, and close only after a yielded value has arrived.
+ * Abrupt body throws retain precedence over errors raised by return(). */
 function lowerForOfDyn(lowerer, stmt, iterable, labels) {
     const loc = locOf(stmt);
-    const head = stmt.expression;
-    // V8's for-of CallPrinter spellings: named sources (identifiers and
-    // plain property chains) read "<src> is not iterable", call heads
-    // with a nameable callee "<callee> is not a function or its return
-    // value is not iterable"; everything else keeps the runtime kind
-    // wording. The runtime uses the spelling VERBATIM when non-empty.
     const headText = (e) => {
         if (ts.isIdentifier(e))
             return e.text;
         if (ts.isPropertyAccessExpression(e) && !e.questionDotToken && ts.isIdentifier(e.name)) {
             const base = headText(e.expression);
-            return base !== null ? `${base}.${e.name.text}` : null;
+            return base === null ? null : `${base}.${e.name.text}`;
         }
         return null;
     };
-    const headName = headText(head);
-    const calleeName = ts.isCallExpression(head) ? headText(head.expression) : null;
-    const spell = headName !== null
-        ? `${headName} is not iterable`
-        : calleeName !== null
-            ? `${calleeName} is not a function or its return value is not iterable`
-            : "";
-    const pack = lowerer.declareHiddenLocal("%dofpack", DYN);
-    const idx = lowerer.declareHiddenLocal("%dofi", F64);
-    idx.mutable = true;
-    const packRef = () => ({ kind: "varRef", localId: pack.id, type: DYN, loc });
-    const iRef = () => ({ kind: "varRef", localId: idx.id, type: F64, loc });
-    const elemInit = () => ({ kind: "libCall", fn: "dyn.arrAt", args: [packRef(), iRef()], type: DYN, loc });
+    const name = headText(stmt.expression);
+    const callee = ts.isCallExpression(stmt.expression) ? headText(stmt.expression.expression) : null;
+    const spell = name !== null ? `${name} is not iterable` : callee !== null ? `${callee} is not a function or its return value is not iterable` : "";
+    const iterator = lowerer.declareHiddenLocal("%dofIterator", DYN);
+    const next = lowerer.declareHiddenLocal("%dofNext", DYN);
+    const step = lowerer.declareHiddenLocal("%dofStep", DYN);
+    const value = lowerer.declareHiddenLocal("%dofValue", DYN);
+    const returned = lowerer.declareHiddenLocal("%dofReturn", DYN);
+    const needsClose = lowerer.declareHiddenLocal("%dofNeedsClose", BOOL);
+    needsClose.mutable = true;
+    const error = lowerer.declareHiddenLocal("%dofError", CAUGHT);
+    const get = (source, key) => ({
+        kind: "dynKeyGet", value: source, key: { kind: "strLit", value: key, type: STRING, loc }, type: DYN, loc,
+    });
+    const check = (value) => ({ kind: "libCall", fn: "dyn.iteratorResult", args: [value], type: DYN, loc });
+    const call = (callee) => check({
+        kind: "dynCall", callee, receiver: varRef(iterator.id, DYN, loc), calleeName: "iterator method", args: [], type: DYN, loc,
+    });
+    const setClose = (value) => ({ kind: "assign", localId: needsClose.id, value: { kind: "boolLit", value, type: BOOL, loc }, loc });
+    const close = () => [
+        { kind: "varDecl", localId: returned.id, init: get(varRef(iterator.id, DYN, loc), "return"), loc },
+        { kind: "if", cond: { kind: "unary", op: "!", operand: { kind: "dynTest", test: "nullish", value: varRef(returned.id, DYN, loc), type: BOOL, loc }, type: BOOL, loc }, then: [
+                { kind: "exprStmt", expr: call(varRef(returned.id, DYN, loc)), loc },
+            ], else_: null, loc },
+    ];
+    const elemInit = () => varRef(value.id, DYN, loc);
     lowerer.scopes.push(new Map());
     try {
         const binds = [];
@@ -7242,40 +7558,35 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
             }
         }
         const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
+        const loop = {
+            kind: "while", cond: { kind: "boolLit", value: true, type: BOOL, loc },
+            body: [
+                setClose(false),
+                { kind: "varDecl", localId: step.id, init: call(varRef(next.id, DYN, loc)), loc },
+                { kind: "if", cond: { kind: "dynTest", test: "truthy", value: get(varRef(step.id, DYN, loc), "done"), type: BOOL, loc }, then: [{ kind: "break", loc }], else_: null, loc },
+                { kind: "varDecl", localId: value.id, init: get(varRef(step.id, DYN, loc), "value"), loc },
+                setClose(true),
+                ...binds, ...body,
+            ],
+            ...(labels && { labels }), loc,
+        };
         return {
             kind: "block",
             body: [
+                { kind: "varDecl", localId: iterator.id, init: check({ kind: "libCall", fn: "dyn.iterator", args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }], type: DYN, loc }), loc },
+                { kind: "varDecl", localId: next.id, init: get(varRef(iterator.id, DYN, loc), "next"), loc },
+                { kind: "varDecl", localId: needsClose.id, init: { kind: "boolLit", value: false, type: BOOL, loc }, loc },
                 {
-                    kind: "varDecl",
-                    localId: pack.id,
-                    init: {
-                        kind: "libCall",
-                        fn: "dyn.iterPack",
-                        args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }],
-                        type: DYN,
-                        loc,
-                    },
-                    loc,
-                },
-                {
-                    kind: "for",
-                    init: { kind: "varDecl", localId: idx.id, init: { kind: "numLit", value: 0, type: F64, loc }, loc },
-                    cond: {
-                        kind: "bin",
-                        op: "<",
-                        left: iRef(),
-                        right: { kind: "libCall", fn: "dyn.arrLen", args: [packRef()], type: F64, loc },
-                        type: BOOL,
-                        loc,
-                    },
-                    update: {
-                        kind: "assign",
-                        localId: idx.id,
-                        value: { kind: "bin", op: "+", left: iRef(), right: { kind: "numLit", value: 1, type: F64, loc }, type: F64, loc },
-                        loc,
-                    },
-                    body: [...binds, ...body],
-                    ...(labels && { labels }),
+                    kind: "tryCatch", tryBody: [loop],
+                    catchBody: [
+                        { kind: "if", cond: varRef(needsClose.id, BOOL, loc), then: [
+                                setClose(false),
+                                { kind: "tryCatch", tryBody: close(), catchBody: [], catchLocalId: null, finallyBody: null, loc },
+                            ], else_: null, loc },
+                        { kind: "rethrow", localId: error.id, loc },
+                    ],
+                    catchLocalId: error.id,
+                    finallyBody: [{ kind: "if", cond: varRef(needsClose.id, BOOL, loc), then: close(), else_: null, loc }],
                     loc,
                 },
             ],
@@ -7286,6 +7597,25 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
         lowerer.scopes.pop();
     }
 }
+/** for-of over an ISLAND value (see lowerForOf's jsval arm): the
+ * engine's iterator protocol desugared over jsOps —
+ *
+ *   it = iterNew(v);            // GetIterator (prelude; may throw)
+ *   while (true) {
+ *     r = it.next();            // callMethod
+ *     if (truthy(r.done)) break;
+ *     <bind loop var(s) from r.value>  // getProp
+ *     ...body
+ *   }
+ *
+ * The loop variable's ELEMENT is an island handle (jsval — exactly what
+ * the checker's package-typed element maps to); identifier heads bind
+ * it per iteration, destructuring heads run the jsval pattern desugar,
+ * pre-declared and var heads keep their fences (the array path's
+ * stories don't carry over mechanically). IteratorClose on early exit
+ * (break/return out of a partial iteration calling it.return()) is NOT
+ * run — a divergence only a custom island iterator with a return()
+ * method can observe. */
 function lowerForOfIsland(lowerer, stmt, iterable, labels) {
     const loc = locOf(stmt);
     if (!ts.isVariableDeclarationList(stmt.initializer)) {
@@ -7505,13 +7835,25 @@ function lowerForIn(lowerer, stmt) {
     if (stdlibGlobalNameOf(lowerer, stmt.expression) === "globalThis") {
         return { kind: "block", body: [], loc };
     }
-    const recvT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
-    if (recvT?.kind === "array")
-        return lowerForInArray(lowerer, stmt, labels);
+    const receiver = lowerer.lowerExpr(stmt.expression);
+    const recvT = receiver.type;
+    if (recvT.kind === "dyn") {
+        const recv = lowerer.declareHiddenLocal("%indyn", DYN);
+        const ref = { kind: "varRef", localId: recv.id, type: DYN, loc };
+        const keys = {
+            kind: "dynCheck", value: { kind: "libCall", fn: "dyn.forInKeys", args: [ref], type: DYN, loc },
+            type: arrayOf(STRING), loc,
+        };
+        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => ({
+            kind: "libCall", fn: "dyn.hasKey", args: [ref, key], type: BOOL, loc,
+        }));
+        return { kind: "block", body: [{ kind: "varDecl", localId: recv.id, init: receiver, loc }, loop], loc };
+    }
+    if (recvT.kind === "array")
+        return lowerForInArray(lowerer, stmt, labels, receiver);
     if (recvT?.kind === "record") {
         const shape = lowerer.shapes.get(recvT.shapeId);
         if (shape && !shape.tuple) {
-            const receiver = lowerer.lowerExpr(stmt.expression);
             if (receiver.type.kind !== "record")
                 lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
             const rShape = lowerer.shapes.get(receiver.type.shapeId);
@@ -7640,9 +7982,8 @@ function lowerForInOverKeys(lowerer, stmt, keys, labels, guard) {
    * live-length guard is the per-visit presence check (keys removed by
    * pops are skipped, exactly Node's HasProperty re-check; indices are
    * dense, so `i < length` IS presence). */
-function lowerForInArray(lowerer, stmt, labels) {
+function lowerForInArray(lowerer, stmt, labels, arrExpr) {
     const loc = locOf(stmt);
-    const arrExpr = lowerer.lowerExpr(stmt.expression);
     if (arrExpr.type.kind !== "array")
         lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
     lowerer.scopes.push(new Map());