@scriptc/compiler 0.1.1 → 0.1.3

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

@@ -1,11 +1,12 @@
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
  * declarations including destructuring patterns, scoped blocks, control
- * flow (if/while/for/for-of/do, switch, try/catch, jumps with the
- * finally-crossing fence), and blocked-binding poisoning. */
+ * flow (if/while/for/for-of/do, switch, try/catch, abrupt completions),
+ * explicit resource management, and blocked-binding poisoning. */
 import * as ts from "../ts7/adapter.js";
 import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.js";
-import { lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
+import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
+import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
@@ -15,20 +16,262 @@ 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, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
-import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf } from "./lower-stream.js";
+import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
 import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, textCodecBindingDecl } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, probeLower, pureReemittable, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
+import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { isParseArgsDynTypeName, isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
 import { canonicalBuiltinModule } from "../builtin-modules.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { probeNodeRequireRefusal } from "../npm.js";
 import { numLit, varRef } from "../../ir/build.js";
+import { constituentTypes } from "../ts7/checker.js";
+import { npmStaticPackageOfPath } from "../npm-static.js";
+import { fenceNodeModuleMutation } from "./lower-node-module.js";
+/** An opted package's directly-returned empty array may take the function's
+ * explicit static return element type. This is the common JS accumulator
+ * shape (`const result = []; result.push(value); return result`) and is
+ * narrower than treating every evolving array in the function alike. */
+function npmStaticReturnedEmptyArrayType(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name) ||
+        decl.initializer === undefined ||
+        !ts.isArrayLiteralExpression(decl.initializer) ||
+        decl.initializer.elements.length !== 0 ||
+        !isJsSourceFile(decl.getSourceFile()) ||
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) === null ||
+        lowerer.ctx.returnType.kind !== "array") {
+        return null;
+    }
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (symbol === undefined)
+        return null;
+    let owner = decl.parent;
+    while (owner !== undefined && !ts.isFunctionLike(owner))
+        owner = owner.parent;
+    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    if (ownerBody === undefined || !ts.isBlock(ownerBody))
+        return null;
+    let returned = false;
+    ts.walkPreorder(ownerBody, (node) => {
+        if (node !== ownerBody && ts.isFunctionLike(node))
+            return "skip";
+        if (!ts.isReturnStatement(node) || node.expression === undefined)
+            return undefined;
+        let expression = node.expression;
+        while (ts.isParenthesizedExpression(expression))
+            expression = expression.expression;
+        if (ts.isIdentifier(expression) && lowerer.checker.getSymbolAtLocation(expression) === symbol) {
+            returned = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return returned ? lowerer.ctx.returnType : null;
+}
+/** A JS loop cursor in opted package source can be initialized with `T`
+ * and later assigned a nullable self link (`cursor = cursor.parent`). Keep
+ * that optional value in the local so the next loop condition, rather than
+ * the assignment, narrows it. */
+function npmStaticOptionalSelfWriteType(lowerer, decl, initial) {
+    if (!ts.isIdentifier(decl.name) ||
+        !isJsSourceFile(decl.getSourceFile()) ||
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) === null ||
+        initial.kind === "union") {
+        return null;
+    }
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (symbol === undefined)
+        return null;
+    let owner = decl.parent;
+    while (owner !== undefined && !ts.isFunctionLike(owner))
+        owner = owner.parent;
+    const ownerBody = owner !== undefined && "body" in owner ? owner.body : undefined;
+    if (ownerBody === undefined || !ts.isBlock(ownerBody))
+        return null;
+    let candidate = null;
+    let invalid = false;
+    ts.walkPreorder(ownerBody, (node) => {
+        if (node !== ownerBody && ts.isFunctionLike(node))
+            return "skip";
+        if (ts.isBinaryExpression(node)) {
+            let left = node.left;
+            while (ts.isParenthesizedExpression(left))
+                left = left.expression;
+            if (ts.isIdentifier(left) && lowerer.checker.getSymbolAtLocation(left) === symbol) {
+                if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+                    invalid = true;
+                    return "stop";
+                }
+                const written = lowerer.mapTypeOf(lowerer.typeOf(node.right));
+                if (written !== null && typeEquals(written, initial))
+                    return undefined;
+                const arms = written?.kind === "union" ? lowerer.unions.get(written.unionId)?.arms : undefined;
+                if (written?.kind !== "union" ||
+                    arms === undefined ||
+                    !arms.some((arm) => typeEquals(arm, initial)) ||
+                    !arms.every((arm) => typeEquals(arm, initial) || isUnitType(arm)) ||
+                    (candidate !== null && !typeEquals(candidate, written))) {
+                    invalid = true;
+                    return "stop";
+                }
+                candidate = written;
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            ts.isIdentifier(node.operand) &&
+            lowerer.checker.getSymbolAtLocation(node.operand) === symbol) {
+            invalid = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return invalid ? null : candidate;
+}
+function isAwaitUsing(list) {
+    return (list.flags & ts.NodeFlags.AwaitUsing) === ts.NodeFlags.AwaitUsing;
+}
+function stdlibTypeNamed(lowerer, node, name) {
+    const visit = (t) => {
+        if (t.flags & ts.TypeFlags.Union)
+            return constituentTypes(t).some(visit);
+        const sym = t.getAliasSymbol() ?? t.getSymbol();
+        return sym?.name === name && lowerer.checker.declarationsOf(sym).some((d) => lowerer.isStdlibFile(d.getSourceFile()));
+    };
+    return visit(lowerer.typeOf(node));
+}
+function cleanupCall(lowerer, node, value, awaited) {
+    const loc = locOf(node);
+    if (value.type.kind === "object") {
+        const info = lowerer.classes.get(value.type.className);
+        if (!info)
+            lowerer.flushDeferredClass(value.type.className);
+        const asyncFound = awaited && info ? lowerer.findMethodOn(info, "sym:asyncDispose") : null;
+        const syncFound = info ? lowerer.findMethodOn(info, "sym:dispose") : null;
+        const member = asyncFound ? "sym:asyncDispose" : syncFound ? "sym:dispose" : null;
+        const found = asyncFound ?? syncFound;
+        if (!info || !member || !found)
+            return null;
+        if (found.sig.params.length !== 0) {
+            lowerer.unsupported("SC1090", node, `${member === "sym:asyncDispose" ? "[Symbol.asyncDispose]" : "[Symbol.dispose]"} methods with parameters`);
+        }
+        return {
+            call: lowerer.accessorCall(value.type.className, member, value, [], found.sig.ret, loc),
+            async: member === "sym:asyncDispose",
+        };
+    }
+    if (value.type.kind === "fileHandle") {
+        if (!awaited)
+            lowerer.unsupported("SC1090", node, "synchronous 'using' with an async-only FileHandle (use 'await using')");
+        return {
+            call: { kind: "libCall", fn: "fileHandle.close", args: [value], type: { kind: "promise", inner: VOID }, loc },
+            async: true,
+        };
+    }
+    if (value.type.kind === "child") {
+        return {
+            call: {
+                kind: "libCall",
+                fn: "child.kill",
+                args: [value, { kind: "strLit", value: "SIGTERM", type: STRING, loc }],
+                type: BOOL,
+                loc,
+            },
+            async: false,
+        };
+    }
+    if (value.type.kind === "f64") {
+        if (stdlibTypeNamed(lowerer, node, "Timeout")) {
+            return { call: { kind: "libCall", fn: "timers.clearTimeout", args: [value], type: VOID, loc }, async: false };
+        }
+        if (stdlibTypeNamed(lowerer, node, "Immediate")) {
+            return { call: { kind: "libCall", fn: "timers.clearImmediate", args: [value], type: VOID, loc }, async: false };
+        }
+        if (stdlibTypeNamed(lowerer, node, "Interface")) {
+            return { call: { kind: "libCall", fn: "rl.close", args: [value], type: VOID, loc }, async: false };
+        }
+    }
+    return null;
+}
+function cleanupForValue(lowerer, node, value, awaited) {
+    const loc = locOf(node);
+    if (isUnitType(value.type))
+        return [];
+    if (value.type.kind === "union") {
+        const def = lowerer.unions.get(value.type.unionId);
+        if (!def)
+            throw new InternalCompilerError(`lowerer bug: unknown using union ${value.type.unionId}`);
+        const out = [];
+        for (let tag = 0; tag < def.arms.length; tag++) {
+            const arm = def.arms[tag];
+            if (isUnitType(arm))
+                continue;
+            const narrowed = { kind: "unionNarrow", unionId: value.type.unionId, tag, value, type: arm, loc };
+            const body = cleanupForValue(lowerer, node, narrowed, awaited);
+            out.push({
+                kind: "if",
+                cond: { kind: "unionIsTag", unionId: value.type.unionId, tag, negated: false, value, type: BOOL, loc },
+                then: body,
+                else_: null,
+                loc,
+            });
+        }
+        return out;
+    }
+    const cleanup = cleanupCall(lowerer, node, value, awaited);
+    if (!cleanup) {
+        lowerer.unsupported("SC1090", node, `disposing values of type '${lowerer.fmt(value.type)}' (use a class with a zero-parameter [Symbol.dispose] or [Symbol.asyncDispose] method, or a supported Node resource)`);
+    }
+    const call = cleanup.call;
+    if (cleanup.async) {
+        if (call.type.kind !== "promise" || call.type.inner.kind !== "void") {
+            lowerer.unsupported("SC1090", node, "[Symbol.asyncDispose] methods whose result is not Promise<void>");
+        }
+        return [{ kind: "exprStmt", expr: { kind: "awaitExpr", value: call, type: VOID, loc }, loc }];
+    }
+    const out = [{ kind: "exprStmt", expr: call, loc }];
+    if (awaited)
+        out.push({ kind: "exprStmt", expr: { kind: "libCall", fn: "async.hop", args: [], type: VOID, loc }, loc });
+    return out;
+}
+function lowerUsingStatement(lowerer, stmt) {
+    if (ts.isSourceFile(stmt.parent)) {
+        lowerer.unsupported("SC1090", stmt, "top-level 'using' declarations (wrap the resource lifetime in a block or function)");
+    }
+    if (ts.isCaseClause(stmt.parent) || ts.isDefaultClause(stmt.parent)) {
+        lowerer.unsupported("SC1090", stmt, "'using' declarations directly in switch clauses (wrap the clause body in a block)");
+    }
+    const awaited = isAwaitUsing(stmt.declarationList);
+    if (awaited && !lowerer.ctx.isAsync) {
+        lowerer.unsupported("SC1090", stmt, "'await using' outside an async function or top-level-await module");
+    }
+    const registrations = [];
+    for (const decl of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name))
+            lowerer.unsupported("SC1031", decl.name);
+        if (decl.initializer === undefined)
+            lowerer.unsupported("SC1090", decl, "a 'using' declaration without an initializer");
+        const acquire = lowerer.lowerVarDecl(decl, false);
+        if (!acquire)
+            throw new InternalCompilerError("lowerer bug: using declaration emitted no acquisition");
+        const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+        if (!symbol)
+            throw new InternalCompilerError("lowerer bug: using declaration has no symbol");
+        const binding = lowerer.bindingIn(lowerer.ctx, symbol) ?? lowerer.globalsBySymbol.get(symbol) ?? null;
+        if (!binding)
+            throw new InternalCompilerError("lowerer bug: using declaration has no runtime binding");
+        const value = varRef(binding.id, binding.type, locOf(decl.name));
+        const cleanup = cleanupForValue(lowerer, decl.name, value, awaited);
+        registrations.push({ acquire, cleanup, loc: locOf(decl) });
+    }
+    return registrations;
+}
 /** `const X = /* @__PURE__ *\/ makeX()` at a module's top level: every
  * declarator initialized by a call (or `new`) carrying the bundler PURE
  * annotation in its leading trivia — the shape --provenance-sources may
@@ -113,6 +356,7 @@ export function provenanceElidedConstDecl(lowerer, decl) {
    * `let a = 1, b = a + 1;`) but is counted once. */
 export function lowerStmts(lowerer, stmts) {
     const out = [];
+    const usingMarkers = [];
     // JAVASCRIPT sources defer their compile fences to runtime (the
     // JS-input design: no annotations exist to change what lowers, so a
     // statement whose construct has no static lowering compiles to a
@@ -144,7 +388,25 @@ export function lowerStmts(lowerer, stmts) {
             }
             const diagsBefore = lowerer.diags.length;
             try {
-                const lowered = lowerer.lowerStmt(stmt);
+                let lowered;
+                let appended = false;
+                if (ts.isVariableStatement(stmt) &&
+                    (stmt.declarationList.flags & ts.NodeFlags.Using) !== 0) {
+                    const registrations = lowerUsingStatement(lowerer, stmt);
+                    const accounting = [];
+                    for (const registration of registrations) {
+                        out.push(registration.acquire);
+                        accounting.push(registration.acquire, ...registration.cleanup);
+                        if (registration.cleanup.length > 0) {
+                            usingMarkers.push({ start: out.length, cleanup: registration.cleanup, loc: registration.loc });
+                        }
+                    }
+                    lowered = accounting;
+                    appended = true;
+                }
+                else {
+                    lowered = lowerer.lowerStmt(stmt);
+                }
                 // The lib-boundary chokepoint (lib-boundary.ts): checked-dynamic
                 // arguments that reached builtin-call slots without the checked
                 // coercion get their dynCheck here, and the uncoercible ones
@@ -153,10 +415,12 @@ export function lowerStmts(lowerer, stmts) {
                 // deferred rejection.
                 if (lowered)
                     enforceLibBoundary(lowerer, lowered);
-                if (Array.isArray(lowered))
-                    out.push(...lowered);
-                else if (lowered)
-                    out.push(lowered);
+                if (!appended) {
+                    if (Array.isArray(lowered))
+                        out.push(...lowered);
+                    else if (lowered)
+                        out.push(lowered);
+                }
                 // Island accounting (--dynamic coverage): a statement that lowered
                 // but carries island constructs compiles DYNAMICALLY — its work
                 // runs in the embedded engine, and the report says so instead of
@@ -215,6 +479,23 @@ export function lowerStmts(lowerer, stmts) {
                 }
             }
         }
+        // Each acquisition protects the remainder of its lexical statement
+        // list. Folding from the last registration outward produces the
+        // spec's LIFO nesting and ensures a later initializer failure only
+        // disposes resources acquired before it.
+        for (let i = usingMarkers.length - 1; i >= 0; i--) {
+            const marker = usingMarkers[i];
+            const body = out.splice(marker.start);
+            out.push({
+                kind: "tryCatch",
+                tryBody: body,
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: marker.cleanup,
+                suppressFinallyErrors: true,
+                loc: marker.loc,
+            });
+        }
     }
     finally {
         lowerer.activeStmtLists.pop();
@@ -237,7 +518,7 @@ const TDZ_KINDS = new Set([
     // shape is the const's own initializer capturing the const:
     // `const server = http.createServer(h).listen(0, done)` with `done`
     // reading `server` — a TDZ read until the assign completes, JS exactly.
-    "child", "childStream", "netServer", "netSocket", "dgramSocket", "testCtx",
+    "child", "childStream", "childWriter", "netServer", "netSocket", "dgramSocket", "testCtx",
     "httpReq", "httpRes", "httpClientReq",
     // The h2 handles — `const client = http2.connect(url, mustCall(() =>
     // ...client...))` is the suite's canonical self-capturing const.
@@ -313,10 +594,11 @@ export function predeclareForwardCapture(lowerer, symbol) {
 /** The FUNCTION-DECLARATION twin of predeclareForwardCapture: JS hoists a
    * nested `function f() {}` to scope entry — the binding is LIVE from the
    * first statement, so a reference lexically above the declaration in the
-   * SAME function lowers the declaration eagerly at the reference (varDecl
-   * 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
+   * SAME function lowers the declaration eagerly at the reference (storage
+   * 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. */
@@ -589,44 +871,6 @@ export function lowerScopedBlock(lowerer, stmt) {
         lowerer.scopes.pop();
     }
 }
-/** The finally fences. `return` crossing OUT of a try/catch body guarded
-   * by a finally is SUPPORTED now (the backend's pending-return path runs
-   * every crossed finally inner-to-outer before the function returns, the
-   * value snapshotted first — Node-exact); what stays rejected is (a) any
-   * jump out of a finally BLOCK itself (a return there would REPLACE a
-   * pending completion — clearing a still-propagating exception or
-   * abandoning a pending return, a model the emitter doesn't implement),
-   * and (b) break/continue crossing a try-with-finally (their targets bind
-   * inside the function; the pending-action plumbing exists only for
-   * return, the shape real code needs). Rejected, not miscompiled. Plain
-   * try/catch is transparent to jumps (it never appears in ctl). A LABELED
-   * jump walks outward past every construct (labeled targets can be
-   * arbitrarily far out) until the entry carrying its label, applying the
-   * same finally fences to everything crossed on the way. */
-export function rejectJumpCrossingFinally(lowerer, kw, stmt, label) {
-    const ctl = lowerer.ctx.ctl;
-    for (let i = ctl.length - 1; i >= 0; i--) {
-        const c = ctl[i];
-        if (c.kind === "finallyBlock") {
-            lowerer.unsupported("SC1090", stmt, `'${kw}' out of a 'finally' block (it would replace the pending completion — restructure so the finally only cleans up)`);
-        }
-        if (c.kind === "tryFinally") {
-            if (kw !== "return") {
-                lowerer.unsupported("SC1090", stmt, `'${kw}' crossing a 'finally' block`);
-            }
-            continue; // return runs the finally on the way out — supported
-        }
-        if (kw === "return")
-            continue; // return crosses every construct
-        if (label !== undefined) {
-            if (c.labels?.includes(label))
-                return; // the labeled target — binds here
-            continue; // an inner construct the labeled jump exits
-        }
-        if (c.kind === "loop" || (kw === "break" && c.kind === "switch"))
-            return; // binds inside the region
-    }
-}
 /** `lbl: stmt` — labeled statements. A label chain collapses to one name
    * list (`a: b: while ...` — both names target the same loop, JS-exact).
    * Loops and switches take the labels DIRECTLY (a labeled continue needs
@@ -720,7 +964,6 @@ export function lowerStmt(lowerer, stmt) {
     if (ts.isLabeledStatement(stmt))
         return lowerLabeled(lowerer, stmt);
     if (ts.isReturnStatement(stmt)) {
-        lowerer.rejectJumpCrossingFinally("return", stmt);
         // Implicit-any instance RETURN INFERENCE (lower-calls'
         // resolveInferredReturn): the value lowers BARE and the statement
         // records itself — the post-pass settles the instance's return type
@@ -784,10 +1027,8 @@ export function lowerStmt(lowerer, stmt) {
             if (!target || (kw === "continue" && target.kind !== "loop")) {
                 lowerer.unsupported("SC1050", stmt, `'${kw} ${label}' targeting this statement form (the labeled statement lowers through a desugar that has no label point)`);
             }
-            lowerer.rejectJumpCrossingFinally(kw, stmt, label);
             return { kind: kw, label, loc: locOf(stmt) };
         }
-        lowerer.rejectJumpCrossingFinally(kw, stmt);
         // tsc rejects break outside loops/switches and continue outside loops,
         // so the context is always valid here (the validator re-checks).
         return { kind: kw, loc: locOf(stmt) };
@@ -846,7 +1087,8 @@ export function lowerStmt(lowerer, stmt) {
         return null;
     if (ts.isFunctionDeclaration(stmt)) {
         // Already lowered eagerly by the forward-hoisting machinery
-        // (predeclareForwardFnDecl) — the varDecl is in the list's output.
+        // (predeclareForwardFnDecl) — its declaration and assignment are in
+        // the list's output.
         if (lowerer.hoistedFnDecls.has(stmt))
             return null;
         return lowerer.lowerNestedFunctionDecl(stmt);
@@ -2904,6 +3146,95 @@ export function lowerVarDeclList(lowerer, list) {
         throw new InternalCompilerError("lowerer bug: for-init declarator resolved to a global");
     return lowered;
 }
+/** A single static type for an initializer-less JavaScript `let` whose
+ * later plain writes all agree. An evolving JS local reads as `undefined`
+ * until control flow proves a write, so a scalar slot is sound only when
+ * every ordinary use already has that concrete flow type. Any closure
+ * capture stays checked-dynamic: it can observe the local before an outer
+ * assignment, and the checker deliberately leaves captured evolving lets
+ * broad. */
+function inferredEvolvingLetType(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name))
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    const scope = decl.parent.parent.parent;
+    if (symbol === undefined || (!ts.isBlock(scope) && !ts.isSourceFile(scope)))
+        return null;
+    const isPlainAssignmentTarget = (node) => {
+        let target = node;
+        while (ts.isParenthesizedExpression(target.parent) && target.parent.expression === target) {
+            target = target.parent;
+        }
+        const parent = target.parent;
+        return ts.isBinaryExpression(parent) &&
+            parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            parent.left === target;
+    };
+    const captures = (fn) => {
+        let captured = false;
+        ts.walkPreorder(fn, (node) => {
+            if (node !== fn &&
+                ts.isIdentifier(node) &&
+                lowerer.checker.getSymbolAtLocation(node) === symbol) {
+                captured = true;
+                return "stop";
+            }
+            return undefined;
+        });
+        return captured;
+    };
+    const writes = [];
+    const reads = [];
+    let invalid = false;
+    ts.walkPreorder(scope, (node) => {
+        if (node !== scope && ts.isFunctionLike(node)) {
+            if (captures(node))
+                invalid = true;
+            return "skip";
+        }
+        if (ts.isBinaryExpression(node)) {
+            let left = node.left;
+            while (ts.isParenthesizedExpression(left))
+                left = left.expression;
+            if (ts.isIdentifier(left) && lowerer.checker.getSymbolAtLocation(left) === symbol) {
+                if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+                    invalid = true;
+                    return "stop";
+                }
+                if (ts.isCallExpression(node.right) && implicitMethodCallInfersReturn(lowerer, node.right)) {
+                    invalid = true;
+                    return "stop";
+                }
+                const mapped = lowerer.mapTypeOf(lowerer.typeOf(node.right));
+                if (!mapped || mapped.kind === "dyn" || mapped.kind === "jsval" || mapped.kind === "void" || isUnitType(mapped)) {
+                    invalid = true;
+                    return "stop";
+                }
+                writes.push(mapped);
+            }
+        }
+        if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            ts.isIdentifier(node.operand) &&
+            lowerer.checker.getSymbolAtLocation(node.operand) === symbol) {
+            invalid = true;
+            return "stop";
+        }
+        if (ts.isIdentifier(node) &&
+            node !== decl.name &&
+            lowerer.checker.getSymbolAtLocation(node) === symbol &&
+            !isPlainAssignmentTarget(node)) {
+            reads.push(node);
+        }
+        return undefined;
+    });
+    const first = writes[0];
+    if (invalid || first === undefined || !writes.every((write) => typeEquals(write, first)))
+        return null;
+    return reads.every((read) => {
+        const mapped = lowerer.mapTypeOf(lowerer.typeOf(read));
+        return mapped !== null && typeEquals(mapped, first);
+    }) ? first : null;
+}
 export function lowerVarDecl(lowerer, decl, isLet) {
     // --provenance-sources: an elided pure-annotated dead const emits
     // nothing (collectGlobals registered no global by the same test —
@@ -3163,6 +3494,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         // immediately (the type covers the unassigned state), so they
         // initialize to the interned undefined arm like an omitted optional.
         let type = lowerer.irTypeOf(decl.name);
+        if (type.kind === "dyn" && isLet && isJsSourceFile(decl.getSourceFile())) {
+            type = inferredEvolvingLetType(lowerer, decl) ?? type;
+        }
         // `var v: void;` / `let x: undefined;` — a unit-only binding rides
         // the unit-only union (its undefined arm is the unassigned state,
         // which is also the only state).
@@ -3233,6 +3567,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         (lowerer.dynamic && init.type.kind === "dyn" && jsvalFlavoredType(lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? DYN) ? DYN : null) ??
         (bindingTainted ? null : lowerer.mapTypeOf(lowerer.typeOf(decl.name))) ??
         (init.type.kind === "dyn" ? DYN : null);
+    if (lowerer.implicitParamTypes !== null &&
+        init.type.kind === "dyn" &&
+        isJsSourceFile(decl.getSourceFile()) &&
+        npmStaticPackageOfPath(decl.getSourceFile().fileName) !== null) {
+        type = DYN;
+    }
     // A JS `let x = {}`: TS's empty-object-literal type admits ANY later
     // non-nullish assignment (`envs = {}`, later `envs =
     // Object.fromEntries(...)` — tsc accepts every such write, since
@@ -3245,6 +3585,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
+    const returnedEmptyArrayType = npmStaticReturnedEmptyArrayType(lowerer, decl);
+    if (returnedEmptyArrayType !== null) {
+        type = returnedEmptyArrayType;
+        init = lowerer.lowerExprExpecting(decl.initializer, returnedEmptyArrayType);
+    }
     // A JS `const leaked = [];` (the evolving-array idiom — test/common's
     // leak ledger): tsc types the binding by its LATER pushes, but this
     // frontend answers the declaration name with the uninhabited never[],
@@ -3254,7 +3599,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // checked-dynamic instead (the `let x = {}` stance, and lower-modules'
     // file-scope evolving-array rule): pushes ride the dyn array, typed
     // exits dynCheck.
-    if ((type === null || type.kind === "array") && isJsSourceFile(decl.getSourceFile())) {
+    if (returnedEmptyArrayType === null &&
+        (type === null || type.kind === "array") &&
+        isJsSourceFile(decl.getSourceFile())) {
         let initExpr = decl.initializer;
         while (ts.isParenthesizedExpression(initExpr))
             initExpr = initExpr.expression;
@@ -3316,14 +3663,15 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // their tuple record likewise). Const only — an evolving-`any`
     // `let` may be reassigned a different shape later; genuine `any`
     // only — every other unmappable keeps its own diagnostic.
-    if (type === null && !isLet &&
-        ((lowerer.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0 ||
+    const checkerAny = (lowerer.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0;
+    if ((type === null || (type.kind === "dyn" && checkerAny)) && !isLet &&
+        (checkerAny ||
             (lowerer.checkerAnyArray(decl.name) && lowerer.isArrayValueType(init.type)) ||
             // JS declarations carry no annotations: an unmappable inferred
             // type (a union with a fence-folded arm — the typeof-'bigint'
             // dual-mode ternary) adopts the initializer's static type, the
             // same rule genuine `any` consts take.
-            isJsSourceFile(decl.getSourceFile())) &&
+            (type === null && isJsSourceFile(decl.getSourceFile()))) &&
         init.type.kind !== "void" && init.type.kind !== "caught" && init.type.kind !== "jsval" &&
         !isUnitType(init.type)) {
         type = init.type;
@@ -3338,6 +3686,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     if (!type)
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
+    let settledType = type;
     const arithmeticType = decl.initializer ? lowerer.runtimeOptionalArithmeticTypes.get(decl.initializer) : undefined;
     const isStringArithmeticUnion = (t) => {
         if (t.kind !== "union")
@@ -3346,35 +3695,42 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         return !!arms && arms.length === 2 &&
             arms.some((a) => a.kind === "f64") && arms.some((a) => a.kind === "string");
     };
-    const runtimeStringArithmetic = type?.kind === "string" &&
+    const runtimeStringArithmetic = settledType.kind === "string" &&
         ((arithmeticType && typeEquals(arithmeticType, init.type)) || isStringArithmeticUnion(init.type));
     if (runtimeStringArithmetic) {
-        type = init.type;
+        settledType = init.type;
     }
-    type = lowerer.runtimeOptionalBindingType(decl.name, type);
+    const optionalSelfWriteType = isLet
+        ? npmStaticOptionalSelfWriteType(lowerer, decl, settledType)
+        : null;
+    settledType = lowerer.runtimeOptionalBindingType(decl.name, settledType);
+    if (optionalSelfWriteType !== null)
+        settledType = optionalSelfWriteType;
+    if (returnedEmptyArrayType !== null)
+        settledType = returnedEmptyArrayType;
     // `const x: void = undefined` / `let y: undefined = undefined`: the
     // unit-only union — the initializer's unit literal wraps into its arm
     // like any optional completion. Non-literal void initializers (a
     // void CALL's result) keep their fence at the coercion below.
-    if (type.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
-        type = unitOnlyUnion(lowerer.unions);
+    if (settledType.kind === "void" && isUnitOnlyTsType(lowerer.typeOf(decl.name))) {
+        settledType = unitOnlyUnion(lowerer.unions);
     }
-    if (type.kind === "void")
+    if (settledType.kind === "void")
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     // A PACKAGE promise stored in a local stays an island HANDLE — the
     // engine's promise has no static promise value to coerce into. Awaits
     // and .catch/.finally chains on the local bridge per use site (each
     // bridge is an independent observer of the same settlement).
-    if (init.type.kind === "jsval" && type.kind === "promise")
-        type = JSVAL;
+    if (init.type.kind === "jsval" && settledType.kind === "promise")
+        settledType = JSVAL;
     // An island value under an `any[]`-declared LOCAL spelling stays an
     // island HANDLE too (the runtime-world rule): the jsval-element-array
     // exit is a CALL-boundary conversion (the loadPlugins param ABI) —
     // converting a local would strand the engine's own prototypes
     // (join/map/... on a native handle-element array), where the handle
     // routes every use engine-side.
-    if (init.type.kind === "jsval" && type.kind === "array" && type.elem.kind === "jsval") {
-        type = JSVAL;
+    if (init.type.kind === "jsval" && settledType.kind === "array" && settledType.elem.kind === "jsval") {
+        settledType = JSVAL;
     }
     // A STATIC array of island HANDLES under an unannotated declared type
     // spelling evolved elements (`const kept = fns.filter(...)` over an
@@ -3387,8 +3743,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // validated-boundary fence.
     if (!decl.type &&
         init.type.kind === "array" && init.type.elem.kind === "jsval" &&
-        type.kind === "array" && type.elem.kind !== "jsval") {
-        type = init.type;
+        settledType.kind === "array" && settledType.elem.kind !== "jsval") {
+        settledType = init.type;
     }
     // `const runner = options.runner || defaultRunner`: the checker types
     // the || as the union/merge of two structurally-compatible function
@@ -3398,13 +3754,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // when the parameters agree and the declared return either contains
     // the init's return as a union arm or is the opaque spawnRes the
     // adapter converts (nothing coerces INTO either declared form).
-    if (type.kind === "func" && init.type.kind === "func" && !typeEquals(type, init.type)) {
+    if (settledType.kind === "func" && init.type.kind === "func" && !typeEquals(settledType, init.type)) {
         const initFn = init.type;
-        const paramsAgree = type.params.length === initFn.params.length &&
-            type.params.every((p, i) => typeEquals(p, initFn.params[i]));
-        const retUnionArm = type.ret.kind === "union" && lowerer.armTag(type.ret.unionId, initFn.ret) >= 0;
-        if (paramsAgree && (retUnionArm || lowerer.spawnResFnAdapterPlan(type, initFn) !== null)) {
-            type = init.type;
+        const paramsAgree = settledType.params.length === initFn.params.length &&
+            settledType.params.every((p, i) => typeEquals(p, initFn.params[i]));
+        const retUnionArm = settledType.ret.kind === "union" && lowerer.armTag(settledType.ret.unionId, initFn.ret) >= 0;
+        if (paramsAgree && (retUnionArm || lowerer.spawnResFnAdapterPlan(settledType, initFn) !== null)) {
+            settledType = init.type;
         }
     }
     // The downstream twin: `const result = runner(cmd, args)` where the
@@ -3413,12 +3769,12 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // can narrow (spawnRes has no discriminant). The VALUE is statically
     // the record arm, so the local adopts it; flows into the union slot
     // re-wrap via the ordinary arm coercion.
-    if (type.kind === "union" && init.type.kind === "record") {
-        const arms = lowerer.unions.get(type.unionId)?.arms ?? [];
+    if (settledType.kind === "union" && init.type.kind === "record") {
+        const arms = lowerer.unions.get(settledType.unionId)?.arms ?? [];
         if (arms.length === 2 &&
             arms.some((a) => a.kind === "spawnRes") &&
             arms.some((a) => typeEquals(a, init.type))) {
-            type = init.type;
+            settledType = init.type;
         }
     }
     // `const r: Repo = new MemRepo()` over an all-generic-method
@@ -3426,8 +3782,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // (the record shape maps empty and the width copy would drop the
     // class the generic-method calls monomorphize against) — see
     // genericIfaceBindingKeepsClass.
-    if (type.kind === "record" && init.type.kind === "object" && genericIfaceBindingKeepsClass(lowerer, decl, type)) {
-        type = init.type;
+    if (settledType.kind === "record" && init.type.kind === "object" && genericIfaceBindingKeepsClass(lowerer, decl, settledType)) {
+        settledType = init.type;
     }
     // A TDZ box minted DURING this very initializer (a callback inside it
     // captured this const — predeclareForwardCapture's current-statement
@@ -3442,8 +3798,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     // Slot coercion: `const r: A | B = bValue;` wraps implicitly; width
     // subtyping (`const p: {a: number} = wider;`) is rejected, not coerced.
-    init = lowerer.coerceInto(decl.initializer, init, type);
-    const local = lowerer.declareLocal(decl.name, decl.name.text, type, isLet);
+    init = lowerer.coerceInto(decl.initializer, init, settledType);
+    const local = lowerer.declareLocal(decl.name, decl.name.text, settledType, isLet);
     if (runtimeStringArithmetic && isStringArithmeticUnion(init.type)) {
         lowerer.runtimeOptionalArithmeticLocals.add(lowerer.runtimeOptionalRootOf(local));
     }
@@ -3545,9 +3901,8 @@ export function lowerSwitch(lowerer, stmt) {
     const labels = lowerer.takeLabels();
     const disc = lowerer.lowerExpr(stmt.expression);
     const dk = disc.type.kind;
-    if (dk === "dyn") {
-        lowerer.unsupported("SC1100", stmt.expression, "switch statements on 'unknown' values");
-    }
+    if (dk === "dyn")
+        return lowerDynSwitch(lowerer, stmt, disc);
     if (dk === "union")
         return lowerUnionSwitch(lowerer, stmt, disc);
     if (dk !== "f64" && dk !== "string" && dk !== "bool") {
@@ -3596,19 +3951,51 @@ export function lowerSwitch(lowerer, stmt) {
    *   is last).
    * Case bodies share ONE lexical scope, exactly like the real switch. */
 function lowerUnionSwitch(lowerer, stmt, disc) {
-    const loc = locOf(stmt);
     if (disc.type.kind !== "union")
         throw new InternalCompilerError("lowerer bug: non-union disc");
     const unionType = disc.type;
     if (!lowerer.eqComparableUnion(unionType.unionId)) {
         lowerer.unsupported("SC1090", stmt.expression, "switch on a union whose arms do not have static equality");
     }
+    return lowerBranchSwitch(lowerer, stmt, disc, (stableDisc, test, expression) => {
+        const unitTest = test.kind === "unitLit"
+            ? lowerer.lowerUnitComparison(stableDisc, test, false, locOf(expression))
+            : null;
+        return unitTest ?? {
+            kind: "unionEq",
+            unionId: unionType.unionId,
+            negated: false,
+            sameValue: false,
+            left: stableDisc,
+            right: lowerer.coerceInto(expression, test, unionType),
+            type: BOOL,
+            loc: locOf(expression),
+        };
+    });
+}
+/** A checked-dynamic switch whose tests have native strict-equality
+ * answers. Scalar tests use dynScalarEq; null/undefined use dyn kind tests.
+ * Other case values retain the existing unknown-switch fence. */
+function lowerDynSwitch(lowerer, stmt, disc) {
+    return lowerBranchSwitch(lowerer, stmt, disc, (stableDisc, test, expression) => {
+        if (test.kind === "unitLit") {
+            return { kind: "dynTest", test: test.unit, value: stableDisc, type: BOOL, loc: locOf(expression) };
+        }
+        if (test.type.kind !== "string" && test.type.kind !== "f64" &&
+            test.type.kind !== "bool" && test.type.kind !== "dyn") {
+            lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
+        }
+        return { kind: "dynScalarEq", left: stableDisc, right: test, type: BOOL, loc: locOf(expression) };
+    });
+}
+function lowerBranchSwitch(lowerer, stmt, disc, compare) {
+    const loc = locOf(stmt);
     const prefix = [];
     let stableDisc = disc;
-    if (!pureReemittable(disc)) {
-        const temp = lowerer.declareHiddenLocal("%switch", unionType);
+    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: unionType, 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
@@ -3667,7 +4054,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
                 // final else, so matching them changes nothing when pure).
                 if (test.kind !== "strLit" && test.kind !== "numLit" &&
                     test.kind !== "boolLit" && test.kind !== "unitLit" &&
-                    !pureReemittable(test)) {
+                    !isSafeToRepeat(test)) {
                     lowerer.unsupported("SC1090", clause.expression, "effectful case tests in a union-typed switch (bind the test value to a const first)");
                 }
                 // A unit-literal test takes the unit-comparison lowering: a tag
@@ -3675,19 +4062,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
                 // lacks it (`case null:` on a `number | undefined` — legal TS,
                 // never matches; coercing the literal into the union would hit
                 // the stranded-arm trap and throw where JS just skips the case).
-                const unitTest = test.kind === "unitLit"
-                    ? lowerer.lowerUnitComparison(stableDisc, test, false, locOf(clause.expression))
-                    : null;
-                pendingTests.push(unitTest ?? {
-                    kind: "unionEq",
-                    unionId: unionType.unionId,
-                    negated: false,
-                    sameValue: false,
-                    left: stableDisc,
-                    right: lowerer.coerceInto(clause.expression, test, unionType),
-                    type: BOOL,
-                    loc: locOf(clause.expression),
-                });
+                pendingTests.push(compare(stableDisc, test, clause.expression));
             }
             const isDefault = ts.isDefaultClause(clause);
             if (clause.statements.length === 0 && !isDefault && i < clauses.length - 1) {
@@ -3730,7 +4105,7 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
         lowerer.scopes.pop();
     }
 }
-/** try/catch/finally. Supported subset:
+/** try/catch/finally:
    * - `catch { }` (bindingless) discards the thrown value on entry.
    * - `catch (e)` binds it as a CAUGHT local — a snapshot of the exception
    *   cell, deliberately narrower than dyn: the supported uses are the
@@ -3741,23 +4116,14 @@ function lowerUnionSwitch(lowerer, stmt, disc) {
    *   assignment are fenced (SC1063 and friends); destructuring patterns
    *   are SC1062. The `: any` / `: unknown` annotations tsc admits both
    *   lower the same way (tsc narrows either through the tests).
-   * - `finally` runs on normal completion, on exception paths, and on the
-   *   way out of a `return` in the try/catch body (the backend's
-   *   pending-return path — inner-to-outer through nested finallys, the
-   *   value snapshotted before the finally runs, Node-exact).
-   *   break/continue crossing a try-with-finally stay rejected, as does
-   *   any jump out of the finally body itself (it would replace a pending
-   *   completion — rejectJumpCrossingFinally). Plain try/catch places no
-   *   restriction on jumps.
+   * - `finally` runs on normal completion, exception paths, and every
+   *   abrupt completion that crosses it. Return values are snapshotted
+   *   before cleanup; an abrupt completion inside the finally replaces the
+   *   pending one, matching JavaScript completion-record semantics.
    * Each block is its own lexical scope (the binding lives in a scope
    * WRAPPING the catch block, like the spec's catch environment). */
 export function lowerTry(lowerer, stmt) {
-    const hasFinally = stmt.finallyBlock !== undefined;
-    // try/catch bodies are jump-fenced only when a finally guards them.
-    const lowerGuarded = (block) => hasFinally
-        ? lowerer.inCtl("tryFinally", () => lowerer.lowerScopedBlock(block))
-        : lowerer.lowerScopedBlock(block);
-    const tryBody = lowerGuarded(stmt.tryBlock);
+    const tryBody = lowerer.lowerScopedBlock(stmt.tryBlock);
     let catchBody = null;
     let catchLocalId = null;
     if (stmt.catchClause) {
@@ -3770,19 +4136,17 @@ export function lowerTry(lowerer, stmt) {
             try {
                 const local = lowerer.declareLocal(vd.name, vd.name.text, CAUGHT, false);
                 catchLocalId = local.id;
-                catchBody = lowerGuarded(stmt.catchClause.block);
+                catchBody = lowerer.lowerScopedBlock(stmt.catchClause.block);
             }
             finally {
                 lowerer.scopes.pop();
             }
         }
         else {
-            catchBody = lowerGuarded(stmt.catchClause.block);
+            catchBody = lowerer.lowerScopedBlock(stmt.catchClause.block);
         }
     }
-    const finallyBody = stmt.finallyBlock
-        ? lowerer.inCtl("finallyBlock", () => lowerer.lowerScopedBlock(stmt.finallyBlock))
-        : null;
+    const finallyBody = stmt.finallyBlock ? lowerer.lowerScopedBlock(stmt.finallyBlock) : null;
     return {
         kind: "tryCatch",
         tryBody,
@@ -3806,6 +4170,7 @@ function lowerDeleteStatement(lowerer, expr) {
     if (!ts.isElementAccessExpression(target) && !ts.isPropertyAccessExpression(target)) {
         lowerer.unsupported("SC1090", expr, "'delete' of non-property expressions");
     }
+    fenceNodeModuleMutation(lowerer, target, "delete");
     const lowerKey = () => {
         if (ts.isPropertyAccessExpression(target)) {
             return { kind: "strLit", value: target.name.text, type: STRING, loc: locOf(target.name) };
@@ -4131,6 +4496,21 @@ export function lowerExprStatement(lowerer, expr) {
     const stmtNode = expr.parent;
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
+    // A discarded conditional has no value to merge: represent its lazy
+    // branch selection directly as statement control flow. In particular,
+    // both arms may be void calls (`flag ? emitA() : emitB()`), for which a
+    // value-shaped void ternary has no IR representation. Preserve the same
+    // narrowing environments as a source if statement, and lower only a
+    // statically selected arm when the condition folded without effects.
+    if (ts.isConditionalExpression(expr)) {
+        const cond = lowerer.lowerCondition(expr.condition);
+        if (cond.kind === "boolLit") {
+            return lowerExprStatement(lowerer, cond.value ? expr.whenTrue : expr.whenFalse);
+        }
+        const then = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, expr.condition, true), () => withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, expr.condition), () => [lowerExprStatement(lowerer, expr.whenTrue)]));
+        const else_ = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, expr.condition, false), () => [lowerExprStatement(lowerer, expr.whenFalse)]);
+        return { kind: "if", cond, then, else_, loc: locOf(expr) };
+    }
     // Assignment statements over the no-storage binding families:
     //   - `f1 = f2` where the RHS roots at an ambient-undefined name:
     //     Node evaluates the RHS first and dies on the root's
@@ -4299,6 +4679,7 @@ export function lowerExprStatement(lowerer, expr) {
             if (ts.isElementAccessExpression(expr.left))
                 return lowerer.lowerElementWrite(expr);
             if (ts.isPropertyAccessExpression(expr.left)) {
+                fenceNodeModuleMutation(lowerer, expr.left, "assignment");
                 // Native arrays have a writable length property. The runtime grows
                 // by creating holes and truncates with RC-aware removal; keep this
                 // as a statement operation so invalid lengths can use the normal
@@ -4451,10 +4832,10 @@ export function lowerExprStatement(lowerer, expr) {
                 // chain): the dyn keyed write — the value converts INTO dyn
                 // (closures box), the runtime sets the member on OBJ receivers
                 // and throws Node's TypeErrors on the rest. The receiver is
-                // PROBED (probeLower) and claimed exactly when it lowers to
+                // PROBED (tryLowerExpression) and claimed exactly when it lowers to
                 // dyn; typed receivers keep their own lowerings and fences.
                 if (!expr.left.questionDotToken) {
-                    const recv = probeLower(lowerer, expr.left.expression);
+                    const recv = tryLowerExpression(lowerer, expr.left.expression);
                     if (recv && recv.type.kind === "dyn") {
                         const loc = locOf(expr);
                         const key = { kind: "strLit", value: expr.left.name.text, type: STRING, loc: locOf(expr.left.name) };
@@ -5810,29 +6191,27 @@ export function lowerForOf(lowerer, stmt) {
     // desugars drop them — a labeled jump naming those loops fences at the
     // jump site (no label point exists in their desugared shape).
     const labels = lowerer.takeLabels();
-    // `for await` is ASYNC ITERATION, not the shipped async/await. ONE
-    // async iterable has a lowering: process.stdin (the piped-input
-    // pattern real CLIs use) — see lowerForAwaitStdin. Everything else is
-    // named specifically (the bare SC1070 text would claim async/await
-    // itself is missing).
+    // `for await` is ASYNC ITERATION, not the shipped async/await. Typed
+    // async generators use the generic request protocol; process.stdin
+    // and readable streams retain their dedicated next-chunk paths.
     if (stmt.awaitModifier) {
-        if (ts.isPropertyAccessExpression(stmt.expression) &&
-            lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin") {
-            return lowerForAwaitStdin(lowerer, stmt);
-        }
-        // Readable streams (the readableAsyncIterator surface): the mapped
-        // receiver class roots at a readable-sided stream class.
         {
-            const recvT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
-            if (recvT?.kind === "object") {
-                const info = lowerer.classes.get(recvT.className);
-                const sides = streamSidesOf(lowerer, info);
-                if (sides === "r" || sides === "rw") {
-                    return lowerForAwaitReadable(lowerer, stmt, recvT);
+            const genT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
+            if (genT?.kind === "generator" && genT.async) {
+                const iterable = lowerer.lowerExpr(stmt.expression);
+                if (iterable.type.kind === "generator" && iterable.type.async) {
+                    return lowerForAwaitGenerator(lowerer, stmt, iterable, labels);
                 }
             }
         }
-        lowerer.unsupported("SC1070", stmt, "'for await' (async iteration over anything but process.stdin and readable streams)");
+        if (ts.isPropertyAccessExpression(stmt.expression) &&
+            lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin") {
+            return lowerForAwaitStdin(lowerer, stmt);
+        }
+        const builtin = lowerForAwaitBuiltin(lowerer, stmt);
+        if (builtin)
+            return builtin;
+        lowerer.unsupported("SC1070", stmt, "'for await' over this value (supported: typed async generators, represented class async iterators, process.stdin, and Node/Web readable streams)");
     }
     lowerer.fenceStaticHeadersIteration(stmt.expression);
     // A stored numeric value iterator declared in this function keeps its
@@ -6051,7 +6430,7 @@ export function lowerForOf(lowerer, stmt) {
                     elemT = { kind: "union", unionId: lowerer.unions.intern(arms) };
                 }
             }
-            if (elemT !== null && pureReemittable(iterable)) {
+            if (elemT !== null && isSafeToRepeat(iterable)) {
                 const loc = locOf(stmt.expression);
                 const shapeId = iterable.type.shapeId;
                 const snapshotElem = elemT;
@@ -6161,9 +6540,7 @@ export function lowerForOf(lowerer, stmt) {
         lowerer.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
     }
     const list = stmt.initializer;
-    if ((list.flags & ts.NodeFlags.Using) !== 0) {
-        lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
-    }
+    const resourceLoop = (list.flags & ts.NodeFlags.Using) !== 0;
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
     const decl = list.declarations[0]; // the grammar allows exactly one
     // `for (const [k, v] of pairs)` — a destructuring loop variable: the
@@ -6216,7 +6593,19 @@ export function lowerForOf(lowerer, stmt) {
             lowerer.runtimeOptionalStorageLocals.add(root);
         }
         const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement), labels);
-        return forValues(local.id, body);
+        if (!resourceLoop)
+            return forValues(local.id, body);
+        const resource = varRef(local.id, local.type, locOf(decl.name));
+        const cleanup = cleanupForValue(lowerer, decl.name, resource, isAwaitUsing(list));
+        return forValues(local.id, [{
+                kind: "tryCatch",
+                tryBody: body,
+                catchBody: null,
+                catchLocalId: null,
+                finallyBody: cleanup,
+                suppressFinallyErrors: true,
+                loc: locOf(decl),
+            }]);
     }
     finally {
         lowerer.scopes.pop();
@@ -7372,112 +7761,6 @@ function lowerForAwaitStdin(lowerer, stmt) {
         lowerer.scopes.pop();
     }
 }
-/** `for await (const chunk of readable)` — the stream async iterator
-   * (the stdin desugar's sibling): every pass awaits the runtime's
-   * next-chunk promise — buffered content, or a REJECTION carrying the
-   * stream's error (the await rethrows it, Node's iterator contract) —
-   * and exits on the EOF sentinel. Chunks are Buffers in typed code
-   * (encoded streams fence at the runtime entry); in the JS lane the
-   * chunk is checked-dynamic and boxes by runtime tag (dyn strings once
-   * an encoding applies, dyn undefined as the sentinel — chunks are
-   * never undefined). Early exit leaves the stream alive (Node's
-   * iterator return() would destroy it — a documented divergence). */
-function lowerForAwaitReadable(lowerer, stmt, recvT) {
-    if (!lowerer.ctx.isAsync) {
-        lowerer.unsupported("SC1090", stmt, "top-level 'for await' (await outside async functions)");
-    }
-    if (!ts.isVariableDeclarationList(stmt.initializer)) {
-        lowerer.unsupported("SC1090", stmt.initializer, "for-await over a pre-declared variable (declare the loop variable in the loop: for await (const chunk of ...))");
-    }
-    const list = stmt.initializer;
-    const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
-    const isLet = (list.flags & ts.NodeFlags.Let) !== 0;
-    // `for await (var chunk of ...)`: the chunk binding is per-await
-    // machinery (a fresh value each pass, fiber-parked in between) —
-    // threading it through a shared hoisted slot has no user yet.
-    if (!isConst && !isLet)
-        lowerer.unsupported("SC1030", list, "'var' loop bindings in 'for await' (use const)");
-    const decl = list.declarations[0];
-    if (!ts.isIdentifier(decl.name))
-        lowerer.unsupported("SC1031", decl.name);
-    const loc = locOf(stmt);
-    // The chunk is CHECKED-DYNAMIC in both lanes (the shim types the
-    // iterator's element as any): the runtime boxes by tag — Buffers
-    // normally, strings once an encoding applies — and the dyn surface
-    // carries the common consumptions (.length, [i], toString, +=,
-    // typeof). A statically-typed chunk would have to pick one side of
-    // the encoding question at compile time.
-    const dynLane = true;
-    const chunkT = DYN;
-    const promiseT = { kind: "promise", inner: chunkT };
-    lowerer.scopes.push(new Map());
-    try {
-        // The receiver evaluates ONCE, before the loop.
-        const recvLocal = lowerer.declareHiddenLocal("%faStream", recvT);
-        const recvDecl = {
-            kind: "varDecl",
-            localId: recvLocal.id,
-            init: lowerer.lowerExpr(stmt.expression),
-            loc,
-        };
-        const p = lowerer.declareHiddenLocal("%streamNext", promiseT);
-        const chunk = lowerer.declareLocal(decl.name, decl.name.text, chunkT, isLet);
-        const body = lowerer.inCtl("loop", () => lowerer.lowerScopedBlock(stmt.statement));
-        const chunkRef = { kind: "varRef", localId: chunk.id, type: chunkT, loc };
-        const eofCond = dynLane
-            ? { kind: "dynTest", test: "undefined", value: chunkRef, type: BOOL, loc }
-            : {
-                kind: "bin",
-                op: "===",
-                left: { kind: "bytesIntrinsic", method: "length", receiver: chunkRef, args: [], type: F64, loc },
-                right: { kind: "numLit", value: 0, type: F64, loc },
-                type: BOOL,
-                loc,
-            };
-        const head = [
-            {
-                kind: "varDecl",
-                localId: p.id,
-                init: {
-                    kind: "libCall",
-                    fn: dynLane ? "readable.nextChunkDyn" : "readable.nextChunk",
-                    args: [{ kind: "varRef", localId: recvLocal.id, type: recvT, loc }],
-                    type: promiseT,
-                    loc,
-                },
-                loc,
-            },
-            {
-                kind: "varDecl",
-                localId: chunk.id,
-                init: {
-                    kind: "awaitExpr",
-                    value: { kind: "varRef", localId: p.id, type: promiseT, loc },
-                    type: chunkT,
-                    loc,
-                },
-                loc,
-            },
-            { kind: "if", cond: eofCond, then: [{ kind: "break", loc }], else_: null, loc },
-        ];
-        return {
-            kind: "block",
-            body: [
-                recvDecl,
-                {
-                    kind: "while",
-                    cond: { kind: "boolLit", value: true, type: BOOL, loc },
-                    body: [...head, ...body],
-                    loc,
-                },
-            ],
-            loc,
-        };
-    }
-    finally {
-        lowerer.scopes.pop();
-    }
-}
 export function lowerForStatement(lowerer, stmt) {
     const labels = lowerer.takeLabels();
     lowerer.scopes.push(new Map());