@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -1,7 +1,11 @@
+import { keepsInitializerLayout, notePreservedLayout } from "./structural-instances.js";
+import { jsGlobalValueByName } from "./global-values.js";
 import { lowerTupleAliasDecl, stripTypeWrappers } from "./typed-arguments.js";
+import { islandHandleBinding, lowerIslandExpr, lowerIslandSubclass } from "./lower-node-island.js";
+import { isIslandSubclassDecl } from "../../node-islands/boundary.js";
 import { allBytesArms, indexedUnionArms, lowerIndexedUnionMember, lowerIndexedUnionNumberRead, lowerIndexedUnionRead, } from "./indexed-unions.js";
-import { declaredMemberOf, isPromisePrototypeRead } from "./expressions/property-access.js";
-import { hostsAll } from "./expressions/hosted-narrowing.js";
+import { declaredMemberOf, isPromisePrototypeRead, lowerUnionKeyedRead, } from "./expressions/property-access.js";
+import { hostedStorageView, hostsAll } from "./expressions/hosted-narrowing.js";
 import { requestGeneralStreamSurface } from "./general-streams.js";
 import { lowerForAwaitDynStream, nodeStreamInterfaceSide } from "./dyn-streams.js";
 import { lowerForAwaitValueStream } from "./builtins/hash-stream.js";
@@ -14,6 +18,7 @@ import { lowerCollectionSpread } from "./containers/collection-methods.js";
 import { lowerEventObjectPropertyWrite } from "./lower-event-target.js";
 import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { importMetaBindingSource } from "./import-meta.js";
+import { anyResidueReplacedBy } from "./any-collection-residue.js";
 import { iteratorCanStep, iteratorValue } from "./iterator-consumption.js";
 import { notIterableSpelling } from "./iterable-spelling.js";
 import { isPrivateSplitConsumer } from "./split-consumers.js";
@@ -22,15 +27,16 @@ import { InternalCompilerError } from "../../errors.js";
  * declarations including destructuring patterns, scoped blocks, control
  * flow (if/while/for/for-of/do, switch, try/catch, abrupt completions),
  * explicit resource management, and blocked-binding poisoning. */
+import { isWebStreamValueInJavaScript, typeInvolvesWebStream } from "./builtins/web-streams-dyn.js";
 import * as ts from "../ts7/adapter.js";
 import { lowerOptionalIndex } from "./undefined-index.js";
-import { builtinNamespaceValue } from "./builtin-namespaces.js";
 import { processDataMemberValue, programReadsExitCode } from "./builtins/process.js";
 import { requireInitFlagStmt } from "./require-initialization.js";
 import { isJsonRequireDecl } from "./json-require.js";
 import { isTimeValueDateDeclaration } from "./date-values.js";
 import { bindingSource } from "../binding-source.js";
 import { lowerConstructorReturn } from "./constructor-returns.js";
+import { statementGroupKey } from "./type-failure.js";
 import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, splitRequireAssignmentOf, splitRequireBindingOf, splitRequireBindingOfIdent, splitRequireEarlyReadOf, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
 import { cjsExportMemberWriteGlobalOf, isCjsExportsIdentifier, isCjsModuleExports, isFreshExportsReset, } from "./cjs-exports-object.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
@@ -79,11 +85,11 @@ import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbse
 import { globalSymbolKey } from "./expressions/global-symbols.js";
 import { identifiersNamed } from "./identifier-uses.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
-import { builtinGlobalValue, jsHoldsDynObject, lowerEnvironmentKey, lowerNativeFunctionAssignment, lowerStrictEquality, } from "./lower-exprs.js";
+import { dereferencedElementWrite, jsHoldsDynObject, lowerEnvironmentKey, lowerNativeFunctionAssignment, lowerStrictEquality, nodeTypeError, } from "./lower-exprs.js";
 import { keptIdentityAssertion } from "./assertion-identity.js";
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
-import { lowerUnionFieldWrite } from "./expressions/union-fields.js";
+import { lowerUnionFieldDelete, lowerUnionFieldWrite } from "./expressions/union-fields.js";
 import { UNSUPPORTED, checkerPanicDiag, isCheckerPanic, unsupportedNativeExecutionDiag, } from "../../diagnostics/diagnostic.js";
 import { isParseArgsDynTypeName, isUnitOnlyTsType, jsOpenObjectType, unitOnlyUnion, } from "../type-mapper.js";
 import { canonicalBuiltinModule } from "../builtin-modules.js";
@@ -214,9 +220,7 @@ function stdlibTypeNamed(lowerer, node, name) {
 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 info = lowerer.classes.get(value.type.className) ?? 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;
@@ -529,59 +533,59 @@ export function lowerStmts(lowerer, stmts) {
                 lowerer.countStatement(stmt, sf?.fileName);
             const diagsBefore = lowerer.diags.length;
             const sinkMark = lowerer.diagSinkMark();
+            const touched = new Set();
+            lowerer.failureTouches.push(touched);
+            const pendingSlots = [];
+            // A declarator that initializes a forward-captured TDZ box takes it
+            // out of tdzPredeclared; a retry after a later declarator degrades
+            // must initialize the same box again.
+            const tdzBefore = new Map(lowerer.ctx.tdzPredeclared);
+            // The first attempt's diagnostics: a statement that still fails
+            // after degrading reports them, since a retry does not repeat what
+            // lowered once (a poisoned generic instance) and its own diagnostics
+            // can miss the failure's cause.
+            let firstAttempt = null;
             try {
-                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,
-                            });
-                        }
+                for (let attempt = 0;; attempt++) {
+                    const hits = new Set();
+                    try {
+                        lowerer.withPartialHits(hits, () => lowerOneStatement(lowerer, stmt, out, usingMarkers, diagsBefore, deferFences));
+                        break;
+                    }
+                    catch (e) {
+                        // Localized failure's statement commit point (design §3.3): a
+                        // degradable type failure at a local, loop variable or module
+                        // global degrades that type and the statement lowers again.
+                        // A declaration this statement flushed inside a probe (where
+                        // no retry runs) can retry here too.
+                        firstAttempt ??= lowerer.diags.slice(diagsBefore);
+                        const giveUp = () => {
+                            if (attempt > 0)
+                                lowerer.restoreFirstAttemptDiags(diagsBefore, firstAttempt);
+                            return e;
+                        };
+                        if (attempt >= MAX_DEGRADE_RETRIES || deferFences)
+                            throw giveUp();
+                        const slot = lowerer.degradeAtCommit(e, STATEMENT_SLOTS);
+                        // Pushed-down types the failed attempt mapped widen to the
+                        // whole slot before anything else is given up.
+                        if (slot === null &&
+                            !lowerer.reopenFlushedAtCommit(diagsBefore) &&
+                            !lowerer.widenPartials(hits))
+                            throw giveUp();
+                        // A failed attempt adds nothing to `out` but the TDZ boxes
+                        // forward captures declared (they stay declared), so the
+                        // retry appends after them.
+                        lowerer.dropAttemptDiags(diagsBefore);
+                        if (slot !== null)
+                            pendingSlots.push(slot);
+                        for (const [symbol, local] of tdzBefore)
+                            if (!lowerer.ctx.tdzPredeclared.has(symbol))
+                                lowerer.ctx.tdzPredeclared.set(symbol, local);
                     }
-                    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
-                // fence — inside this statement's poison window, so a JS fence
-                // becomes the statement's runtimeFence exactly like every other
-                // deferred rejection.
-                if (lowered) {
-                    const body = [];
-                    if (Array.isArray(lowered))
-                        body.push(...lowered);
-                    else
-                        body.push(lowered);
-                    const rewritten = lowerSurplusCalls(lowerer, body);
-                    enforceLibBoundary(lowerer, rewritten);
-                    if (!appended)
-                        out.push(...rewritten);
-                }
-                // A JS statement that lowered CLEAN can still have flushed
-                // DEFERRED collection diagnostics (a symbol lookup on an alias
-                // resolves through flushDeferred — informational here, not a
-                // blocker of THIS statement): those belong to the runtime-fence
-                // ledger, not the build — real uses of the broken declaration
-                // meet their own per-site fences.
-                if (deferFences && lowerer.diagSink === null && lowerer.diags.length > diagsBefore) {
-                    const flushed = lowerer.diags.splice(diagsBefore);
-                    const ice = flushed.filter((d) => d.code === "SC9001");
-                    lowerer.diags.push(...ice);
-                    lowerer.runtimeFences.push(...flushed.filter((d) => d.code !== "SC9001"));
                 }
+                for (const slot of pendingSlots)
+                    lowerer.noteDynamicSlot(slot);
             }
             catch (e) {
                 // A Go panic inside tsgo, surfaced by the sync channel as a
@@ -597,7 +601,17 @@ export function lowerStmts(lowerer, stmts) {
                 }
                 if (!lowerer.suppressStats)
                     lowerer.countStatementFailed(stmt, sf?.fileName);
-                lowerer.noteBlockedBindings(stmt);
+                // Localized failure (report-only): the statement's committed
+                // diagnostics that are not themselves type failures or rejected
+                // declarations are cascades of the rejected declarations it used.
+                const committed = lowerer.diagSink === null && !deferFences ? lowerer.diags.slice(diagsBefore) : [];
+                if (touched.size > 0) {
+                    const cause = [...touched];
+                    for (const d of committed)
+                        if (d.typeFailure === undefined && d.rejects === undefined)
+                            d.cause ??= cause;
+                }
+                lowerer.noteBlockedBindings(stmt, committed);
                 // The runtime-fence conversion (JS sources, direct diagnostics
                 // only — a capture wrapper in force means collection owns the
                 // report). The statement's diagnostics move OFF the build and
@@ -625,6 +639,9 @@ export function lowerStmts(lowerer, stmts) {
                         out.push(fence);
                 }
             }
+            finally {
+                lowerer.failureTouches.pop();
+            }
         }
         // Each acquisition protects the remainder of its lexical statement
         // list. Folding from the last registration outward produces the
@@ -649,6 +666,78 @@ export function lowerStmts(lowerer, stmts) {
     }
     return out;
 }
+/** Localized failure: retries a degradable statement-level type failure
+ * at most this many times (each retry degrades one more type). */
+const MAX_DEGRADE_RETRIES = 16;
+/** The slot kinds lowerStmts' commit point degrades: locals, loop
+ * variables and module globals (stage L1), and the parameters and returns
+ * of the function expressions, arrows and methods a statement holds
+ * (stage L2), and the types of the statement's own expressions: casts,
+ * literals with a contextual type, spread clones, temporaries (stage L4). */
+const STATEMENT_SLOTS = new Set([
+    "local",
+    "global",
+    "loop",
+    "param",
+    "return",
+    "field",
+    "member",
+    "expression",
+]);
+/** One attempt at lowering a statement of lowerStmts into `out`. */
+function lowerOneStatement(lowerer, stmt, out, usingMarkers, diagsBefore, deferFences) {
+    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
+    // fence — inside this statement's poison window, so a JS fence
+    // becomes the statement's runtimeFence exactly like every other
+    // deferred rejection.
+    if (lowered) {
+        const body = [];
+        if (Array.isArray(lowered))
+            body.push(...lowered);
+        else
+            body.push(lowered);
+        const rewritten = lowerSurplusCalls(lowerer, body);
+        enforceLibBoundary(lowerer, rewritten);
+        if (!appended)
+            out.push(...rewritten);
+    }
+    // A JS statement that lowered CLEAN can still have flushed
+    // DEFERRED collection diagnostics (a symbol lookup on an alias
+    // resolves through flushDeferred — informational here, not a
+    // blocker of THIS statement): those belong to the runtime-fence
+    // ledger, not the build — real uses of the broken declaration
+    // meet their own per-site fences.
+    if (deferFences && lowerer.diagSink === null && lowerer.diags.length > diagsBefore) {
+        const flushed = lowerer.diags.splice(diagsBefore);
+        const ice = flushed.filter((d) => d.code === "SC9001");
+        lowerer.diags.push(...ice);
+        lowerer.runtimeFences.push(...flushed.filter((d) => d.code !== "SC9001"));
+    }
+}
 /** Whether a statement list belongs to a function body (at any block
  * depth) rather than to a module's top level. */
 function enclosedByFunction(stmt) {
@@ -1061,6 +1150,7 @@ function jsDeclarationExpandsObject(lowerer, decl, inferred) {
         inferred !== null &&
         jsOpenObjectType(decl, inferred, lowerer.shapes, lowerer.unions).kind === "dyn") ||
         arms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm)) ||
+        arms.some((arm) => arm.kind === "record" && jsObjectLiteralFilledLater(lowerer, decl, arm)) ||
         (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             !hasJsTypeAnnotation(decl) &&
@@ -1271,7 +1361,7 @@ function noteEarlyReadVar(lowerer, symbol, local) {
  * lowerVarDecl's salvage path declares the local when it can, and
  * resolution checks locals/globals before the fallthroughs consult
  * blockedBindings. */
-export function noteBlockedBindings(lowerer, stmt) {
+export function noteBlockedBindings(lowerer, stmt, diags = []) {
     let list = null;
     if (ts.isVariableStatement(stmt))
         list = stmt.declarationList;
@@ -1282,13 +1372,24 @@ export function noteBlockedBindings(lowerer, stmt) {
     }
     if (!list)
         return;
+    // Localized failure (report-only): the bindings form one failure group,
+    // the statement, whose diagnostics are the group's.
+    const group = statementGroupKey(stmt);
+    let bound = false;
     for (const decl of list.declarations.nodes) {
         for (const nameNode of boundIdentifiersOf(decl.name)) {
             const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
-            if (symbol)
-                lowerer.blockedBindings.add(symbol);
+            if (!symbol)
+                continue;
+            lowerer.blockedBindings.add(symbol);
+            if (!lowerer.rejectedGroups.has(symbol))
+                lowerer.rejectedGroups.set(symbol, group);
+            bound = true;
         }
     }
+    if (bound)
+        for (const d of diags)
+            d.rejects ??= group;
 }
 /** True when a reference/assignment fell through resolution because the
  * binding's DECLARATION never compiled: a poisoned declaration statement
@@ -1298,10 +1399,13 @@ export function noteBlockedBindings(lowerer, stmt) {
 export function isBlockedBinding(lowerer, symbol) {
     if (!symbol)
         return false;
-    return (lowerer.blockedBindings.has(symbol) ||
+    const blocked = lowerer.blockedBindings.has(symbol) ||
         lowerer.deferredDiags.has(symbol) ||
         lowerer.flushedSymbols.has(symbol) ||
-        lowerer.alreadyFlushed.has(symbol));
+        lowerer.alreadyFlushed.has(symbol);
+    if (blocked)
+        lowerer.touchRejected(symbol);
+    return blocked;
 }
 /** Lowers a statement in a fresh lexical scope (if/while/for bodies). */
 export function lowerScopedBlock(lowerer, stmt) {
@@ -1411,6 +1515,8 @@ function lowerModuleLevelReturn(lowerer, stmt) {
 export function lowerStmt(lowerer, stmt) {
     if (ownPrototypeResetStatement(lowerer, stmt))
         return { kind: "block", body: [], loc: locOf(stmt) };
+    if (ts.isClassDeclaration(stmt) && isIslandSubclassDecl(stmt))
+        return lowerIslandSubclass(lowerer, stmt);
     if (ts.isClassDeclaration(stmt)) {
         if (!stmt.name)
             lowerer.unsupported("SC1090", stmt, "anonymous local class declarations");
@@ -1419,8 +1525,8 @@ export function lowerStmt(lowerer, stmt) {
         const symbol = lowerer.checker.getSymbolAtLocation(stmt.name);
         const pre = symbol ? lowerer.ctx.tdzPredeclared.get(symbol) : undefined;
         if (pre) {
-            lowerer.ctx.tdzPredeclared.delete(symbol);
             const value = lowerer.coerceToExpected(lowerer.lowerClassExpression(stmt), DYN);
+            lowerer.ctx.tdzPredeclared.delete(symbol);
             return { kind: "assign", localId: pre.id, value, initializes: true, loc: locOf(stmt) };
         }
         const type = { kind: "classval", className: info.def.name };
@@ -1598,7 +1704,16 @@ export function lowerStmt(lowerer, stmt) {
         }
         // Exception-representable values move into the runtime's exception
         // cell. `throw f()` of a void call has no value.
-        let value = lowerer.lowerExpr(stmt.expression);
+        // A thrown object or array literal has no declared type: it is built as
+        // a dynamic object, so the catch binding's checked casts adopt it
+        // (lowerer.untypedLiteralContext).
+        let literal = stmt.expression;
+        while (ts.isParenthesizedExpression(literal))
+            literal = literal.expression;
+        let value = (ts.isObjectLiteralExpression(literal) || ts.isArrayLiteralExpression(literal)) &&
+            lowerer.untypedLiteralContext(literal)
+            ? lowerer.lowerExprExpecting(stmt.expression, DYN)
+            : lowerer.lowerExpr(stmt.expression);
         if (value.type.kind === "void")
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
         // Preserve primitive reasons and readable record identity across the
@@ -2133,7 +2248,7 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
     const jsRuntimeKeyCheck = init.type.kind === "dyn" &&
         ts.isObjectBindingPattern(decl.name) &&
         isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
-        startsWithRuntimeKey(lowerer, decl.name) &&
+        (decl.name.elements.nodes.length === 0 || startsWithRuntimeKey(lowerer, decl.name)) &&
         destrSpellingOf(decl.initializer) !== null;
     if (jsRuntimeKeyCheck ||
         (init.type.kind === "dyn" &&
@@ -2255,7 +2370,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                 if (el.dotDotDotToken)
                     lowerer.unsupported("SC1031", el, "rest elements over a union of array or tuple layouts");
                 const loc = locOf(el);
-                let value = unionArrayValueRead(lowerer, srcRef(), numLit(i, loc), loc, (text) => strCharsCall(lowerer, text, loc));
+                let value = unionArrayValueRead(lowerer, srcRef(), numLit(i, loc), loc, (text) => strCharsCall(text, loc));
                 if (!value)
                     lowerer.unsupported("SC1031", el, "array or tuple union elements without a common native representation");
                 if (el.initializer)
@@ -2368,7 +2483,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         }
         // STRING sources (`const [a, b] = str`): array destructuring walks
         // the STRING ITERATOR — code points, astral characters whole —
-        // which is Array.from(string)'s own machinery (%str.chars), so the
+        // which is Array.from(string)'s own machinery (str.codePoints), so the
         // source splits once into a hidden chars array and the pattern
         // lowers as an array pattern over string[]. Positions, holes,
         // defaults (with the bounds test), rest (the remaining code points
@@ -2387,7 +2502,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             out.push({
                 kind: "varDecl",
                 localId: chars.id,
-                init: strCharsCall(lowerer, srcRef(), loc),
+                init: strCharsCall(srcRef(), loc),
                 loc,
             });
             lowerer.lowerBindingPattern(pattern, () => ({ kind: "varRef", localId: chars.id, type: charsT, loc }), charsT, isLet, out);
@@ -2587,6 +2702,39 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         // every statically non-nullish kind, record or not (the assignment
         // path's rule); possibly-nullish sources would throw in JS and keep
         // a fence.
+        //
+        // A CHECKED-DYNAMIC source still owes that step at runtime: an empty
+        // object pattern over null/undefined throws RequireObjectCoercible,
+        // and an empty array pattern throws GetIterator's "is not iterable".
+        // Nothing else about the pattern is observable, so the fence is the
+        // whole lowering.
+        if (srcType.kind === "dyn") {
+            const unitLoc = locOf(pattern);
+            const isObject = ts.isObjectBindingPattern(pattern);
+            for (const unit of ["null", "undefined"]) {
+                // V8 describes an argument-derived source by its type ("object
+                // null"); a bare non-empty pattern names its source instead, but
+                // those reads throw on their own before this check could fire.
+                const described = unit === "null" ? "object null" : "undefined";
+                const message = isObject
+                    ? `Cannot destructure '${described}' as it is ${unit}.`
+                    : `${described} is not iterable (cannot read property Symbol(Symbol.iterator))`;
+                out.push({
+                    kind: "if",
+                    cond: { kind: "dynTest", test: unit, value: srcRef(), type: BOOL, loc: unitLoc },
+                    then: [
+                        {
+                            kind: "exprStmt",
+                            expr: nodeThrowExpr(1, "", message, VOID, unitLoc),
+                            loc: unitLoc,
+                        },
+                    ],
+                    else_: null,
+                    loc: unitLoc,
+                });
+            }
+            return;
+        }
         if (isUnitType(srcType) ||
             (srcType.kind === "union" &&
                 (lowerer.unions.get(srcType.unionId)?.arms.some(isUnitType) ?? true))) {
@@ -2727,9 +2875,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // chain declares keep named fences (a detached method would lose its
     // receiver without an error; JS binds the prototype function).
     if (srcType.kind === "object") {
-        const info = lowerer.classes.get(srcType.className);
-        if (!info)
-            lowerer.flushDeferredClass(srcType.className);
+        const info = lowerer.classes.get(srcType.className) ?? lowerer.flushDeferredClass(srcType.className);
         if (info) {
             for (const el of pattern.elements.nodes) {
                 if (el.name === undefined)
@@ -2880,6 +3026,20 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         lowerer.unions
             .get(srcType.unionId)
             ?.arms.every((arm) => arm.kind === "record" || arm.kind === "object")) {
+        const arms = lowerer.unions.get(srcType.unionId).arms;
+        if (!unionObjectPatternFits(lowerer, pattern, arms)) {
+            // NARROW FIRST: the checker may have refined the union at this
+            // very site (`if (u.kind === "a") { const { x } = u }`, an `in`
+            // guard) while the IR value keeps the stored, wider union. Bind
+            // the narrowed view once and destructure that.
+            const view = narrowedUnionPatternSource(lowerer, pattern, present, srcType.unionId, locOf(pattern));
+            if (view !== null) {
+                const tmp = lowerer.declareHiddenLocal("%destrN", view.type);
+                out.push({ kind: "varDecl", localId: tmp.id, init: view, loc: locOf(pattern) });
+                lowerer.lowerBindingPattern(pattern, () => ({ kind: "varRef", localId: tmp.id, type: view.type, loc: locOf(pattern) }), view.type, isLet, out, dynSpell, allowDynObject);
+                return;
+            }
+        }
         lowerUnionObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out);
         return;
     }
@@ -3224,18 +3384,220 @@ function lowerUrlObjectPattern(lowerer, pattern, srcRef, isLet, out) {
         lowerer.bindPatternTarget(el.name, value, isLet, out);
     }
 }
+/** The fresh record for `{ a, ...rest }` over a UNION source: per arm,
+ * the unconsumed fields copied out at destructure time into a fresh
+ * record of the checker's arm-wise rest type, selected by the runtime
+ * tag. Null-safe answer: an arm whose remaining fields do not spell an
+ * arm of the checker's rest type keeps the named fence. */
+function unionObjectRestValue(lowerer, el, srcRef, srcType, arms) {
+    const loc = locOf(el);
+    const restT = patternBindingType(lowerer, el.name);
+    const fence = (why) => lowerer.unsupported("SC1031", el, why);
+    if (restT === null) {
+        fence(`rest bindings over union sources (${NARROW_FIRST})`);
+    }
+    // The consumed set is the pattern's literal keys: a computed sibling
+    // would make it a runtime fact.
+    const consumed = new Set();
+    const pattern = el.parent;
+    if (ts.isObjectBindingPattern(pattern)) {
+        for (const sib of pattern.elements.nodes) {
+            if (sib === el || sib.dotDotDotToken)
+                continue;
+            const key = sib.propertyName ?? sib.name;
+            if (key && ts.isComputedPropertyName(key)) {
+                fence("rest bindings beside computed keys (the consumed set is a runtime fact)");
+            }
+            if (key && (ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key))) {
+                consumed.add(key.text);
+            }
+        }
+    }
+    const pieces = [];
+    for (let tag = 0; tag < arms.length; tag++) {
+        const arm = arms[tag];
+        if (arm.kind !== "record") {
+            fence(`rest bindings over union sources (${NARROW_FIRST})`);
+        }
+        const shape = lowerer.shapes.get(arm.shapeId);
+        if (!shape || shape.indexValue) {
+            fence("rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
+        }
+        const rem = shape.fields.filter((f) => !consumed.has(f.name));
+        if (rem.some((f) => f.name.startsWith("%"))) {
+            fence("rest bindings over accessor shapes (the entries are closures, not data)");
+        }
+        const armRef = {
+            kind: "unionNarrow",
+            unionId: srcType.unionId,
+            tag,
+            value: srcRef(),
+            type: arm,
+            loc,
+        };
+        const packed = lowerer.keyOrder.copy({
+            kind: "recordLit",
+            fields: rem.map((f) => ({
+                name: f.name,
+                value: lowerer.presenceKeepingCopy(armRef, arm.shapeId, f.name, {
+                    kind: "recordGet",
+                    obj: armRef,
+                    shapeId: arm.shapeId,
+                    field: f.name,
+                    type: f.type,
+                    loc,
+                }, loc),
+            })),
+            type: {
+                kind: "record",
+                shapeId: lowerer.shapes.intern(rem.map((f) => ({ name: f.name, type: f.type }))),
+            },
+            loc,
+        }, arm.shapeId);
+        const coerced = lowerer.coerceInto(el, packed, restT);
+        if (!typeEquals(coerced.type, restT)) {
+            fence(`rest bindings over union sources (the remaining fields of an arm do not spell an arm of '${lowerer.fmt(restT)}')`);
+        }
+        pieces.push({ tag, value: coerced });
+    }
+    let result = null;
+    for (let i = pieces.length - 1; i >= 0; i--) {
+        const piece = pieces[i];
+        result =
+            result === null
+                ? piece.value
+                : {
+                    kind: "ternary",
+                    cond: {
+                        kind: "unionIsTag",
+                        unionId: srcType.unionId,
+                        tag: piece.tag,
+                        negated: false,
+                        value: srcRef(),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: piece.value,
+                    else_: result,
+                    type: restT,
+                    loc,
+                };
+    }
+    if (result === null) {
+        fence(`rest bindings over union sources (${NARROW_FIRST})`);
+    }
+    return result;
+}
+/** The one type every arm declares for `propName`, or null when an arm
+ * does not declare it (or types it differently, or not at all). */
+function unionPatternCommonType(lowerer, arms, propName) {
+    let common = null;
+    for (const arm of arms) {
+        let ft;
+        if (arm.kind === "record") {
+            ft = lowerer.shapes.get(arm.shapeId)?.fields.find((f) => f.name === propName)?.type;
+        }
+        else if (arm.kind === "object") {
+            ft = lowerer.classes.get(arm.className)?.fields.get(propName);
+        }
+        if (!ft || ft.kind === "void" || isUnitType(ft) || (common && !typeEquals(common, ft))) {
+            return null;
+        }
+        common = ft;
+    }
+    return common;
+}
+/** Whether the unionDisc fast path lowers this pattern over these arms
+ * unchanged: no rest element, and every element's key folds to one name
+ * every arm declares with one type. */
+function unionObjectPatternFits(lowerer, pattern, arms) {
+    for (const el of pattern.elements.nodes) {
+        if (el.name === undefined)
+            continue;
+        if (el.dotDotDotToken)
+            return false;
+        const prop = el.propertyName ?? el.name;
+        const propName = ts.isIdentifier(prop) ||
+            ts.isComputedPropertyName(prop) ||
+            ts.isStringLiteralLike(prop) ||
+            ts.isNumericLiteral(prop)
+            ? patternKeyNameOf(lowerer, prop)
+            : null;
+        if (propName === null)
+            return false;
+        if (unionPatternCommonType(lowerer, arms, propName) === null)
+            return false;
+    }
+    return true;
+}
+/** The CHECKER-NARROWED view of a destructuring source: `if (u.kind ===
+ * "a") { const { x } = u }` or an `in` guard refines the type at the
+ * pattern's own site, while the IR value keeps the stored (wider) union
+ * and the un-narrowed lowering. Bind the value to the narrowed sub-union
+ * — a trusted arm extraction for one arm, a re-tag with the excluded
+ * arms as traps for a sub-union — so the pattern reads the arms the
+ * checker proved. Null when the checker did not narrow, when the
+ * refinement is an intersection of stored records (hostedStorageView
+ * keeps that layout), or when nothing was excluded. */
+function narrowedUnionPatternSource(lowerer, pattern, value, fromId, loc) {
+    const from = lowerer.unions.get(fromId);
+    if (!from)
+        return null;
+    const narrowed = lowerer.irTypeOf(pattern);
+    if (narrowed.kind === "void" || isUnitType(narrowed))
+        return null;
+    const siteArms = narrowed.kind === "union" ? lowerer.unions.get(narrowed.unionId)?.arms : [narrowed];
+    if (!siteArms || siteArms.length === 0)
+        return null;
+    const allowed = new Set();
+    for (const arm of siteArms) {
+        const tag = lowerer.armTag(fromId, arm);
+        // Not a stored arm: a checker intersection that refines the stored
+        // records, which keeps the value's layout.
+        if (tag < 0)
+            return hostedStorageView(lowerer, value, narrowed, loc);
+        allowed.add(tag);
+    }
+    if (allowed.size === 0 || allowed.size === from.arms.length)
+        return null;
+    if (allowed.size === 1) {
+        const tag = [...allowed][0];
+        // The checker proved the tag; the extraction traps on a mismatch
+        // instead of reading another arm.
+        return { kind: "unionNarrow", unionId: fromId, tag, value, type: from.arms[tag], loc };
+    }
+    const arms = from.arms.filter((_, tag) => allowed.has(tag));
+    const subId = lowerer.unions.transform(from, arms);
+    const helper = lowerer.narrowedRetagHelper(pattern, fromId, subId, loc);
+    if (!helper)
+        return null;
+    return {
+        kind: "call",
+        callee: helper,
+        args: [value],
+        type: { kind: "union", unionId: subId },
+        loc,
+    };
+}
 /** An object pattern over a union of records and class instances
  * (`function f({ kind, path }: Add | Remove)`): each element reads a data
- * field every arm declares with one type, through the runtime tag, as
- * `value.field` does. Rest elements and fields the arms type differently
- * stay fenced. */
+ * field through the runtime tag, as `value.field` does — the shared
+ * `unionDisc` when every arm declares it with one type, else the
+ * `unionKeyGet` join (an arm that does not declare the key answers
+ * undefined, as JS reads it). A rest element packs each arm's unconsumed
+ * fields into a fresh record. Class arms still need same-typed fields. */
 function lowerUnionObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out) {
     const arms = lowerer.unions.get(srcType.unionId)?.arms ?? [];
     for (const el of pattern.elements.nodes) {
         if (el.name === undefined)
             continue;
         if (el.dotDotDotToken) {
-            lowerer.unsupported("SC1031", el, `rest bindings over union sources (${NARROW_FIRST})`);
+            // `{ a, ...rest }` over a union: each arm packs its own unconsumed
+            // fields into a FRESH record (JS's CopyDataProperties makes a fresh
+            // object too), and the checker's rest type is the union of those
+            // per-arm packs. The tag decides which pack runs.
+            lowerer.bindPatternTarget(el.name, unionObjectRestValue(lowerer, el, srcRef, srcType, arms), isLet, out);
+            continue;
         }
         const prop = el.propertyName ?? el.name;
         const propName = ts.isIdentifier(prop) ||
@@ -3247,32 +3609,30 @@ function lowerUnionObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out)
         if (propName === null) {
             lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
         }
-        let common = null;
-        for (const arm of arms) {
-            let ft;
-            if (arm.kind === "record") {
-                ft = lowerer.shapes.get(arm.shapeId)?.fields.find((f) => f.name === propName)?.type;
-            }
-            else if (arm.kind === "object") {
-                ft = lowerer.classes.get(arm.className)?.fields.get(propName);
-            }
-            if (!ft || ft.kind === "void" || isUnitType(ft) || (common && !typeEquals(common, ft))) {
-                common = null;
-                break;
-            }
-            common = ft;
+        const common = unionPatternCommonType(lowerer, arms, propName);
+        let value;
+        if (common !== null) {
+            value = {
+                kind: "unionDisc",
+                unionId: srcType.unionId,
+                field: propName,
+                value: srcRef(),
+                type: common,
+                loc: locOf(el),
+            };
         }
-        if (common === null) {
-            lowerer.unsupported("SC1031", el, `destructuring '${propName}' from a union whose arms type it differently (every arm must be a record or class with a same-typed field '${propName}' — ${NARROW_FIRST})`);
+        else {
+            // The unionDisc generalization (`unionKeyGet`): each arm answers
+            // its own declared type and an arm that does not declare the
+            // key answers undefined — exactly JS's desugar, which reads a
+            // missing property as undefined.
+            const loc = locOf(el);
+            const joined = lowerUnionKeyedRead(lowerer, el, srcType.unionId, srcRef(), { kind: "strLit", value: propName, type: STRING, loc }, propName, true);
+            if (joined === null) {
+                lowerer.unsupported("SC1031", el, `destructuring '${propName}' from a union whose arms answer it with types that have no combined representation (every arm's '${propName}' must join into one union — ${NARROW_FIRST})`);
+            }
+            value = joined;
         }
-        let value = {
-            kind: "unionDisc",
-            unionId: srcType.unionId,
-            field: propName,
-            value: srcRef(),
-            type: common,
-            loc: locOf(el),
-        };
         if (el.initializer)
             value = applyBindingDefault(lowerer, el, value);
         lowerer.bindPatternTarget(el.name, value, isLet, out);
@@ -3610,14 +3970,9 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             const canonical = ts.symbolName(member) === "global" ? "globalThis" : ts.symbolName(member);
             token = `[builtin ${canonical}]`;
             alias = canonical;
-            // Builtin constructors read as their interned function values, and
-            // crypto as the WebCrypto object: the same values the bare and
-            // `globalThis.X` spellings read.
-            value =
-                canonical === "crypto"
-                    ? { kind: "libCall", fn: "webcrypto.object", args: [], type: DYN, loc: locOf(el) }
-                    : (builtinNamespaceValue(lowerer, canonical, locOf(el)) ??
-                        builtinGlobalValue(canonical, locOf(el), true));
+            // The values the bare and `globalThis.X` spellings read
+            // (jsGlobalValueByName).
+            value = jsGlobalValueByName(lowerer, canonical, locOf(el));
         }
         else if (globalName === "console" && !CONSOLE_CALL_MEMBERS.has(propName)) {
             token = `[builtin console.${propName}]`;
@@ -3631,6 +3986,12 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             // A data member reads its value once, exactly like the spelled
             // `process.<member>` read the destructuring performs.
         }
+        else if (globalName === "process" &&
+            propName === "cwd" &&
+            (value = lowerer.lowerBuiltinCallableValue({ module: "process", member: propName }, locOf(el))) !== null) {
+            // process.cwd reads the directory when it is called, so the detached
+            // function is the same one every other spelling reads.
+        }
         else {
             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)`);
         }
@@ -4514,6 +4875,11 @@ function inferredEvolvingLetType(lowerer, decl) {
     const scope = decl.parent?.parent?.parent;
     if (symbol === undefined || (!ts.isBlock(scope) && !ts.isSourceFile(scope)))
         return null;
+    // A shorthand property's name (`{ width }`) resolves to the property
+    // symbol, but it reads the binding: the checker's shorthand-value symbol.
+    const refersToBinding = (node) => (ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node
+        ? lowerer.checker.getShorthandAssignmentValueSymbol(node.parent)
+        : lowerer.checker.getSymbolAtLocation(node)) === symbol;
     const isPlainAssignmentTarget = (node) => {
         let target = node;
         while (ts.isParenthesizedExpression(target.parent) && target.parent.expression === target) {
@@ -4527,9 +4893,7 @@ function inferredEvolvingLetType(lowerer, decl) {
     const captures = (fn) => {
         let captured = false;
         ts.walkPreorder(fn, (node) => {
-            if (node !== fn &&
-                ts.isIdentifier(node) &&
-                lowerer.checker.getSymbolAtLocation(node) === symbol) {
+            if (node !== fn && ts.isIdentifier(node) && refersToBinding(node)) {
                 captured = true;
                 return "stop";
             }
@@ -4561,6 +4925,15 @@ function inferredEvolvingLetType(lowerer, decl) {
                     invalid = true;
                     return "stop";
                 }
+                // An index read's checker type omits the undefined a read past the
+                // end (or of an absent key) answers.
+                let right = node.right;
+                while (ts.isParenthesizedExpression(right))
+                    right = right.expression;
+                if (ts.isElementAccessExpression(right)) {
+                    invalid = true;
+                    return "stop";
+                }
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(node.right));
                 if (!mapped || mapped.kind === "dyn" || mapped.kind === "void" || isUnitType(mapped)) {
                     invalid = true;
@@ -4577,7 +4950,7 @@ function inferredEvolvingLetType(lowerer, decl) {
         }
         if (ts.isIdentifier(node) &&
             node !== decl.name &&
-            lowerer.checker.getSymbolAtLocation(node) === symbol &&
+            refersToBinding(node) &&
             !isPlainAssignmentTarget(node)) {
             reads.push(node);
         }
@@ -4754,8 +5127,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
             const pre = symbol ? lowerer.ctx.tdzPredeclared.get(symbol) : undefined;
             if (pre) {
-                lowerer.ctx.tdzPredeclared.delete(symbol);
                 const value = genericBindingStoredValue(lowerer, decl, info);
+                lowerer.ctx.tdzPredeclared.delete(symbol);
                 return { kind: "assign", localId: pre.id, value, initializes: true, loc: locOf(decl) };
             }
             return genericBindingPresenceStore(info, decl);
@@ -4861,6 +5234,18 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 return { kind: "assign", localId: g.id, value: wrapped, loc: locOf(decl) };
             return null;
         }
+        // `const files = pkg.list()`: an undeclared island object stays a
+        // handle (lower-node-island.ts), so the binding holds it as dyn.
+        if (ts.isIdentifier(decl.name) && islandHandleBinding(lowerer, decl.name)) {
+            g.type = DYN;
+            return {
+                kind: "assign",
+                localId: g.id,
+                value: lowerer.coerceToExpected(lowerer.lowerExpr(decl.initializer), DYN),
+                ...(g.tdz ? { initializes: true } : {}),
+                loc: locOf(decl),
+            };
+        }
         const guardedRead = isGuardedRecordRead(lowerer, decl)
             ? lowerAbsenceProbe(lowerer, decl.initializer)
             : null;
@@ -4882,6 +5267,14 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                     (existingValueForm(decl.initializer) || jsHoldsDynObject(lowerer, decl.initializer)))))
             g.type = DYN;
         g.type = inferredOptionalRecordType(lowerer, decl, g.type, raw.type);
+        // A module const keeps its initializer's record or array layout, as a
+        // function's const does (keepsInitializerLayout).
+        if (!isVarDeclared(decl) &&
+            (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0 &&
+            keepsInitializerLayout(lowerer, decl.initializer, raw.type, g.type)) {
+            g.type = raw.type;
+            notePreservedLayout(lowerer, decl);
+        }
         const arithmetic = raw.type.kind === "union" ? lowerer.unions.get(raw.type.unionId)?.arms : undefined;
         if (arithmetic?.length === 2 &&
             arithmetic.every((a) => a.kind === "f64" || a.kind === "string" || a.kind === "bool") &&
@@ -4905,11 +5298,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // 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.
+    // declaration is the one initializing `assign` into the shared box. The
+    // box stays pre-declared until the initializer lowers: a statement the
+    // commit point lowers again (localized failure) initializes the same box.
     const pre = declSymbol ? lowerer.ctx.tdzPredeclared.get(declSymbol) : undefined;
     if (pre && decl.initializer) {
-        lowerer.ctx.tdzPredeclared.delete(declSymbol);
         const init = lowerer.lowerExprExpecting(decl.initializer, pre.type);
+        lowerer.ctx.tdzPredeclared.delete(declSymbol);
         return { kind: "assign", localId: pre.id, value: init, initializes: true, loc: locOf(decl) };
     }
     // `var x = e` — an ASSIGNMENT into the function-scoped hoisted slot
@@ -4958,6 +5353,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             : lowerer.unassignedSlotInit(type, locOf(decl));
         return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
     }
+    if (ts.isIdentifier(decl.name) && islandHandleBinding(lowerer, decl.name)) {
+        const init = lowerer.coerceToExpected(lowerer.lowerExpr(decl.initializer), DYN);
+        const local = lowerer.declareLocal(decl.name, decl.name.text, DYN, isLet);
+        return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
+    }
     // Initializer first: `const f = () => ...` should report the arrow
     // function (with its hint), not the unmappable declared type. If it
     // poisons, still declare the local when its type is representable, so
@@ -5015,6 +5415,35 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // Promise.prototype is an ordinary object the checker types Promise<any>.
     if (!decl.type && !hasJsTypeAnnotation(decl) && isPromisePrototypeRead(lowerer, decl.initializer))
         type = DYN;
+    // A web stream value in JavaScript keeps its checked-dynamic identity.
+    if (init.type.kind === "dyn" &&
+        !decl.type &&
+        !hasJsTypeAnnotation(decl) &&
+        decl.initializer !== undefined &&
+        (isWebStreamValueInJavaScript(lowerer, decl.initializer) ||
+            (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+                typeInvolvesWebStream(lowerer, lowerer.typeOf(decl.name)))))
+        type = DYN;
+    // An unannotated TypeScript binding whose checker type carries `any`
+    // inference residue (`Map<any, any>` from an untyped `new Map()` joined
+    // into the initializer's type) takes the initializer's own layout when
+    // that layout replaces only the residue: `any` admits every use, and the
+    // value has that layout.
+    if (!decl.type &&
+        type !== null &&
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+        !typeEquals(type, init.type) &&
+        anyResidueReplacedBy(lowerer, type, init.type))
+        type = init.type;
+    // A const whose initializer has another record or array layout than the
+    // binding's type keeps the initializer's layout: converting would copy the
+    // value, so the binding would not be the value its initializer names.
+    if (!isLet &&
+        type !== null &&
+        keepsInitializerLayout(lowerer, decl.initializer, init.type, type)) {
+        type = init.type;
+        notePreservedLayout(lowerer, decl);
+    }
     // A typed-arguments function expression (typed-arguments.ts): the
     // checker types the binding variadic, but its value has the fixed
     // signature every use asserts.
@@ -5494,6 +5923,40 @@ function lowerVariableInitializer(lowerer, node, expected) {
         }
     }
 }
+/** A JS object literal that leaves out a required field of the binding's
+ * inferred record: tsc types `var p = {}; p.id = id;` by the members later
+ * assignments add, so the object only gains them after its initializer, and
+ * until then it is not a value of that record. Keep it a checked-dynamic
+ * object, as an object that gains keys outside the record is. */
+function jsObjectLiteralFilledLater(lowerer, decl, type) {
+    if (decl.type || !decl.initializer || !isJsSourceFile(ts.getSourceFileOfNode(decl)))
+        return false;
+    let initializer = decl.initializer;
+    while (ts.isParenthesizedExpression(initializer))
+        initializer = initializer.expression;
+    if (!ts.isObjectLiteralExpression(initializer) || hasJsTypeAnnotation(decl))
+        return false;
+    const shape = lowerer.shapes.get(type.shapeId);
+    if (!shape || shape.tuple)
+        return false;
+    const given = new Set();
+    for (const property of initializer.properties.nodes) {
+        if (ts.isSpreadAssignment(property))
+            return false;
+        const name = property.name;
+        if (name === undefined)
+            return false;
+        if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+            given.add(name.text);
+        else
+            return false;
+    }
+    // A field whose type holds undefined reads as it would before the write.
+    const holdsUndefined = (t) => t.kind === "dyn" ||
+        t.kind === "undefinedT" ||
+        (t.kind === "union" && lowerer.armTag(t.unionId, UNDEFINED_T) >= 0);
+    return shape.fields.some((field) => !given.has(field.name) && !field.name.startsWith("%") && !holdsUndefined(field.type));
+}
 /** 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. */
@@ -5872,8 +6335,13 @@ export function lowerSwitch(lowerer, stmt) {
         if (dk === "union")
             return lowerUnionSwitch(lowerer, stmt, disc, labels);
         // Objects, arrays, functions and other references match their cases
-        // with ===, which compares them by identity.
-        if (dk !== "f64" && dk !== "string" && dk !== "bool")
+        // with ===, which compares them by identity. In JavaScript, a case
+        // test of another type (a namespace enum member read through an
+        // untyped object) compares with === too.
+        const mixedJsCases = isJsSourceFile(ts.getSourceFileOfNode(stmt)) &&
+            stmt.caseBlock.clauses.nodes.some((clause) => ts.isCaseClause(clause) &&
+                tryLowerExpression(lowerer, clause.expression)?.type.kind !== dk);
+        if ((dk !== "f64" && dk !== "string" && dk !== "bool") || mixedJsCases)
             return lowerBranchSwitch(lowerer, stmt, disc, labels, (stableDisc, test, expression) => lowerStrictEquality(lowerer, expression, stmt.expression, expression, stableDisc, test, false, locOf(expression)));
         // The whole case-body sequence is ONE lexical scope in JS: a bare `let`
         // in one case is visible in later cases.
@@ -6117,6 +6585,15 @@ function lowerDeleteStatement(lowerer, expr) {
             loc,
         };
     }
+    // `delete u.f` on a union of records that every arm declares `f` optional
+    // on: dispatch over the arms and write each slot's ABSENT state (the
+    // monomorphic optional-field delete). Required fields, class arms and
+    // other receivers keep their own fences below.
+    if (ts.isPropertyAccessExpression(target)) {
+        const unionDelete = lowerUnionFieldDelete(lowerer, target);
+        if (unionDelete)
+            return unionDelete;
+    }
     let obj = lowerer.lowerExpr(target.expression);
     // `delete this.stack` in an Error subclass that declares a `stack`
     // accessor (quickjs-wasi's JSException): V8 gives each error an own
@@ -6648,10 +7125,39 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
  * assignment, and `({ a, b } = e);` (destructuring ASSIGNMENT, which JS
  * requires parenthesized in statement position) lands in the
  * object-literal-target branch below. */
+/** dereferencedElementWrite in statement position. */
+function lowerDereferencedElementWrite(lowerer, expr) {
+    const write = dereferencedElementWrite(lowerer, expr);
+    if (write === null)
+        return null;
+    const loc = locOf(expr);
+    return {
+        kind: "block",
+        body: [
+            ...write.stmts,
+            {
+                kind: "if",
+                cond: write.present,
+                then: [
+                    lowerer.withExpressionOverrides(write.overrides, () => lowerExprStatement(lowerer, expr)),
+                ],
+                else_: [{ kind: "exprStmt", expr: nodeTypeError(write.message, VOID, loc), loc }],
+                loc,
+            },
+        ],
+        loc,
+    };
+}
 export function lowerExprStatement(lowerer, expr) {
     const stmtNode = expr.parent;
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
+    // Node islands (scope-B NI-4): writes and calls on island values.
+    if (lowerer.nodeIslands !== null) {
+        const island = lowerIslandExpr(lowerer, expr);
+        if (island !== null)
+            return { kind: "exprStmt", expr: island, loc: locOf(expr) };
+    }
     // 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
@@ -6890,6 +7396,11 @@ export function lowerExprStatement(lowerer, expr) {
                 if (ex)
                     return ex;
             }
+            {
+                const dereferenced = lowerDereferencedElementWrite(lowerer, expr);
+                if (dereferenced)
+                    return dereferenced;
+            }
             if (ts.isElementAccessExpression(expr.left))
                 return lowerer.lowerElementWrite(expr);
             if (ts.isPropertyAccessExpression(expr.left)) {
@@ -7493,12 +8004,17 @@ export function lowerExprStatement(lowerer, expr) {
     if (droppedPureStdlibStatement(lowerer, expr)) {
         return { kind: "block", body: [], loc: locOf(expr) };
     }
-    if (stmtNode !== undefined &&
-        ts.isExpressionStatement(stmtNode) &&
-        ts.isBinaryExpression(expr) &&
+    if (ts.isBinaryExpression(expr) &&
         (expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
             expr.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
-        return lowerDiscardedLogical(lowerer, expr);
+        // A right operand without a value (`skip || (flag ? warnA() : warnB())`,
+        // where both arms are void calls) leaves the logical nothing to join:
+        // it is the branch `if (!skip) ...` wherever its result is discarded,
+        // a for loop's initializer and update included.
+        if (needsNoValue(lowerer, expr.right))
+            return lowerLogicalBranch(lowerer, expr);
+        if (stmtNode !== undefined && ts.isExpressionStatement(stmtNode))
+            return lowerDiscardedLogical(lowerer, expr);
     }
     const value = lowerer.lowerExpr(expr);
     // A bare unit-literal statement (`undefined;`): a pure no-op in JS,
@@ -7541,6 +8057,27 @@ function lowerDiscardedLogical(lowerer, expr) {
             throw e;
         lowerer.diags.length = diagsBefore;
     }
+    return lowerLogicalBranch(lowerer, expr);
+}
+/** True when the discarded `expr` needs no value: its type maps to void,
+ * or it is a logical or comma expression whose last operand needs none. A
+ * discarded logical whose right operand needs no value lowers as a branch
+ * that runs the operand as a statement. */
+function needsNoValue(lowerer, expr) {
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (ts.isBinaryExpression(expr) &&
+        (expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+            expr.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+            expr.operatorToken.kind === ts.SyntaxKind.CommaToken))
+        return needsNoValue(lowerer, expr.right);
+    const type = lowerer.typeOf(expr);
+    return ((type.flags & (ts.TypeFlags.Void | ts.TypeFlags.TypeParameter)) !== 0 &&
+        lowerer.mapTypeOf(type)?.kind === "void");
+}
+/** `a && b` as `if (a) b;` and `a || b` as `if (!a) b;`, with `b` lowered
+ * as a statement under the narrowing `a` gives it. */
+function lowerLogicalBranch(lowerer, expr) {
     const and = expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken;
     const cond = lowerer.lowerCondition(expr.left);
     if (cond.kind === "boolLit") {
@@ -8369,7 +8906,7 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
     let srcType = tmpRef().type;
     // A STRING source (`[a, b] = s`): the declaration path's rule in
     // assignment position — the string iterator's code-point split
-    // (%str.chars, astral characters whole) into a hidden chars array,
+    // (str.codePoints, astral characters whole) into a hidden chars array,
     // then the pattern proceeds as an array pattern over string[]
     // (defaults with the bounds test, rest packing the remaining code
     // points, elisions; positions past the last code point inherit the
@@ -8382,7 +8919,7 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
         out.push({
             kind: "varDecl",
             localId: chars.id,
-            init: strCharsCall(lowerer, tmpRef(), loc),
+            init: strCharsCall(tmpRef(), loc),
             loc,
         });
         tmpRef = () => ({ kind: "varRef", localId: chars.id, type: charsT, loc });
@@ -8599,6 +9136,84 @@ function isUntypedIterable(lowerer, node) {
         return true;
     return lowerer.mapTypeOf(type)?.kind === "dyn";
 }
+/** `for (const x of map.get(k) ?? [])`: the receiver's checker type is one
+ * non-array iterable beside `never[]` — the array literal's type, whose only
+ * value is the empty array (`never` is uninhabited), so that arm yields
+ * nothing at all. The loop walks the iterable arm under its tag test and the
+ * empty-array arm runs zero iterations. An ARRAY iterable never needs this:
+ * `T[] | never[]` reduces in the checker to `T[]`, never being assignable to
+ * T. A union of two inhabited iterables has no single element type and keeps
+ * its existing fence. */
+function lowerForOfEmptyArrayArm(lowerer, stmt, iterable, iterSrc, labels) {
+    if (iterable.type.kind !== "union" || stmt.awaitModifier !== undefined)
+        return null;
+    const { checker } = lowerer;
+    const widened = lowerer.typeOf(iterSrc);
+    if (!widened.isUnionType())
+        return null;
+    const parts = ts.constituentTypes(widened);
+    if (parts.length !== 2)
+        return null;
+    const neverArrays = parts.filter((part) => {
+        if (!checker.isArrayType(part))
+            return false;
+        const elem = checker.getTypeArguments(part)[0];
+        return elem !== undefined && (elem.flags & ts.TypeFlags.Never) !== 0;
+    });
+    if (neverArrays.length !== 1)
+        return null;
+    const other = parts.find((part) => part !== neverArrays[0]);
+    if (other === undefined)
+        return null;
+    const armT = lowerer.mapTypeOf(other);
+    if (armT === null)
+        return null;
+    if (armT.kind !== "set" && armT.kind !== "map" && armT.kind !== "string")
+        return null;
+    const tag = lowerer.armTag(iterable.type.unionId, armT);
+    if (tag < 0)
+        return null;
+    const loc = locOf(stmt);
+    // The tag test and the walk read the source once: a call or getter in the
+    // head runs one time, and the loop walks the value the test saw.
+    const source = lowerer.declareHiddenLocal("%forOfEmptyArm", iterable.type);
+    const sourceRef = { kind: "varRef", localId: source.id, type: iterable.type, loc };
+    const narrowed = {
+        kind: "unionNarrow",
+        unionId: iterable.type.unionId,
+        tag,
+        value: sourceRef,
+        type: armT,
+        loc,
+    };
+    const loop = armT.kind === "set"
+        ? lowerForOfSet(lowerer, stmt, narrowed, armT)
+        : armT.kind === "map"
+            ? lowerForOfMap(lowerer, stmt, narrowed, armT)
+            : lowerForOfString(lowerer, stmt, narrowed, labels);
+    return {
+        kind: "block",
+        body: [
+            { kind: "varDecl", localId: source.id, init: iterable, loc },
+            {
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: iterable.type.unionId,
+                    tag,
+                    negated: false,
+                    value: sourceRef,
+                    type: BOOL,
+                    loc,
+                },
+                then: [loop],
+                else_: null,
+                loc,
+            },
+        ],
+        loc,
+    };
+}
 export function lowerForOf(lowerer, stmt) {
     // Labels consume HERE (nested statements must never see them). The
     // plain array/string paths carry them; the container/matchAll/stdin
@@ -8844,6 +9459,11 @@ export function lowerForOf(lowerer, stmt) {
         if (iterableUnion)
             return lowerForOfIterable(lowerer, stmt, iterable, iterableUnion, labels);
     }
+    {
+        const emptyArrayArm = lowerForOfEmptyArrayArm(lowerer, stmt, iterable, iterSrc, labels);
+        if (emptyArrayArm)
+            return emptyArrayArm;
+    }
     let tupleSource = null;
     // 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
@@ -9740,16 +10360,18 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
 /** `for (const ch of s)` over a STRING: JS's string iterator, which walks
  * code POINTS — each pass binds the whole character (a two-unit string
  * for astral chars, where charAt/slice would return one surrogate half).
- * Desugars over the UTF-16 cursor machinery: a hidden unit
- * index reads the character with the cpAt intrinsic and advances by ITS
- * length before the body runs (so `continue` never skips the advance):
+ * Desugars over a byte cursor into the WTF-8 data: a hidden byte offset
+ * reads the character that starts there with the cpAtByte intrinsic and
+ * advances by ITS byte count before the body runs (so `continue` never
+ * skips the advance):
  *
  *   { const %s = <expr>; let %i = 0;
- *     while (%i < %s.length) { const ch = cpAt(%s, %i); %i += ch.length; <body> } }
+ *     while (%i < byteLength(%s)) { const ch = cpAtByte(%s, %i); %i += byteLength(ch); <body> } }
  *
- * Strings are immutable, so the length is stable and there is no
+ * Strings are immutable, so the byte count is stable and there is no
  * iterator state to unwind on throw; a lone surrogate is a one-unit
- * character, so every step lands on a character start. */
+ * character with its own three-byte encoding, so every step lands on a
+ * character start. */
 /** for-of over a CLASS ITERABLE (classIteratorOf's shape) — the
  * iterator protocol as ordinary method calls:
  *
@@ -9952,6 +10574,7 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false, syncO
     const iterator = lowerer.declareHiddenLocal("%dofIterator", DYN);
     const next = lowerer.declareHiddenLocal("%dofNext", DYN);
     const fast = lowerer.declareHiddenLocal("%dofNative", BOOL);
+    const generator = lowerer.declareHiddenLocal("%dofGenerator", F64);
     const done = lowerer.declareHiddenLocal("%dofDone", BOOL);
     done.mutable = true;
     const value = lowerer.declareHiddenLocal("%dofValue", DYN);
@@ -9961,6 +10584,15 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false, syncO
     needsClose.mutable = true;
     const error = lowerer.declareHiddenLocal("%dofError", CAUGHT);
     const syncIterator = asyncLoop ? lowerer.declareHiddenLocal("%dofSync", BOOL) : null;
+    lowerer.untypedLoops.set(generator, {
+        kind: generator.id,
+        value: value.id,
+        iterator: iterator.id,
+        next: next.id,
+        done: done.id,
+        async: asyncLoop,
+        sync: syncIterator?.id ?? null,
+    });
     const awaitDyn = (value) => ({
         kind: "libCall",
         fn: "async.awaitDyn",
@@ -10205,6 +10837,14 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false, syncO
                         : iteratorCanStep(varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), loc),
                     loc,
                 },
+                // Which of the program's generator types the iterator is, once
+                // generator-dynamic-dispatch.ts knows them; 0 keeps the protocol.
+                {
+                    kind: "varDecl",
+                    localId: generator.id,
+                    init: { kind: "numLit", value: 0, type: F64, loc },
+                    loc,
+                },
                 {
                     kind: "varDecl",
                     localId: done.id,
@@ -10374,7 +11014,7 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
     try {
         const s = lowerer.declareHiddenLocal("%strof", STRING);
         const i = lowerer.declareHiddenLocal("%iterof", F64);
-        i.mutable = true; // the unit index reassigns (hidden locals default const)
+        i.mutable = true; // the byte cursor reassigns (hidden locals default const)
         const sRef = () => ({ kind: "varRef", localId: s.id, type: STRING, loc });
         const iRef = () => ({ kind: "varRef", localId: i.id, type: F64, loc });
         // `for (var c of str)`: the character mechanics stay on a hidden
@@ -10398,7 +11038,7 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
                 localId: ch.id,
                 init: {
                     kind: "strIntrinsic",
-                    method: "cpAt",
+                    method: "cpAtByte",
                     receiver: sRef(),
                     args: [iRef()],
                     type: STRING,
@@ -10425,7 +11065,7 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
                     left: iRef(),
                     right: {
                         kind: "strIntrinsic",
-                        method: "length",
+                        method: "byteLength",
                         receiver: chRef,
                         args: [],
                         type: F64,
@@ -10457,7 +11097,7 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
                         left: iRef(),
                         right: {
                             kind: "strIntrinsic",
-                            method: "length",
+                            method: "byteLength",
                             receiver: sRef(),
                             args: [],
                             type: F64,
@@ -10503,11 +11143,8 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
  *   own-keys snapshot, verified against Node) while each visit re-checks
  *   presence (i < live length), so pops during the body skip exactly
  *   like Node. Sparse arrays cannot exist here (hole creation traps).
- * - globalThis: the harness's leaked-globals sweep — a compiled binary's
- *   global bindings are compile-time names, never enumerable runtime
- *   properties, so the enumeration is honestly EMPTY (zero iterations;
- *   the body typechecked but never evaluates — SEMANTICS.md documents
- *   the divergence).
+ * - globalThis: Node 24's enumerable globals in Node's order, then the
+ *   program's own global properties, as keys of a fresh object.
  * - JavaScript program classes use their live property-creation table.
  *   TypeScript and runtime-owned layouts keep the class-instance fence.
  * Bindings mirror for-of's: const/let declare the per-iteration string
@@ -10517,10 +11154,11 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
 function lowerForIn(lowerer, stmt) {
     const labels = lowerer.takeLabels();
     const loc = locOf(stmt);
-    if (stdlibGlobalNameOf(lowerer, stmt.expression) === "globalThis") {
-        return { kind: "block", body: [], loc };
-    }
-    let receiver = lowerer.lowerExpr(stmt.expression);
+    // The global object visits Node's enumerable globals, then the
+    // program's own global properties (scr_global_for_in_object).
+    let receiver = stdlibGlobalNameOf(lowerer, stmt.expression) === "globalThis"
+        ? { kind: "libCall", fn: "global.forInObject", args: [], type: DYN, loc }
+        : lowerer.lowerExpr(stmt.expression);
     if (receiver.type.kind === "object") {
         const info = lowerer.classes.get(receiver.type.className);
         let root = info;