@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -1,8 +1,19 @@
-import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js";
+import { lowerTupleAliasDecl, stripTypeWrappers } from "./typed-arguments.js";
+import { declaredMemberOf, isPromisePrototypeRead } from "./expressions/property-access.js";
+import { hostsAll } from "./expressions/hosted-narrowing.js";
+import { requestGeneralStreamSurface } from "./general-streams.js";
+import { lowerForAwaitDynStream } from "./dyn-streams.js";
+import { lowerChildPropertyWrite } from "./handle-properties.js";
+import { matchAllRowsReadByElements, storedMatchAllRowsReadByElements, } from "./containers/match-row-uses.js";
+import { dynUndefinedExpr, nodeThrowExpr, numLit, varRef } from "../../ir/build.js";
+import { runtimeKeyPatternRead } from "./expressions/keyed-field-targets.js";
+import { declaresHoistedBinding, staticCondition } from "./static-typeof.js";
+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 { iteratorCanStep, iteratorValue } from "./iterator-consumption.js";
+import { notIterableSpelling } from "./iterable-spelling.js";
 import { isPrivateSplitConsumer } from "./split-consumers.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Statement lowering: the statement dispatch (lowerStmt), variable
@@ -10,23 +21,32 @@ import { InternalCompilerError } from "../../errors.js";
  * 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 { processDataMemberValue, programReadsExitCode } from "./builtins/process.js";
+import { requireInitFlagStmt } from "./require-initialization.js";
+import { isJsonRequireDecl } from "./json-require.js";
 import { bindingSource } from "../binding-source.js";
+import { lowerConstructorReturn } from "./constructor-returns.js";
+import { cjsExportValueByName, cjsNamespaceDestructureOf, cjsTableMethodEntry, inlineProgramRequireOf, requireNestedPatternsOf, } from "./cjs-inline-require.js";
+import { cjsExportMemberWriteGlobalOf, isCjsExportsIdentifier, isCjsModuleExports, isFreshExportsReset, } from "./cjs-exports-object.js";
+import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { arrayValueRead, arrayValueStore, arrayValueType, unionArrayValueRead, lowerSafeIndexRead, } from "./array-values.js";
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement, } from "./lower-generators.js";
-import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
+import { classAsyncGeneratorIterator, lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, isDynTypedRefType, isUnitType, shapeHasAccessorSlots, typeEquals, } from "../../ir/ir.js";
 import { PoisonError, boundIdentifiersOf, dynFallbackType, neverTaintedJsType, staticImportNamespaceType, } from "./lowerer.js";
 import { enforceLibBoundary, lowerSurplusCalls } from "./lib-boundary.js";
-import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, isNodeEsmFile, locOf, requireSpecOf, } from "../program.js";
-import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf, } from "./surfaces.js";
+import { cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isEsModuleStamp, isJsSourceFile, locOf, requireEarlyReference, requireSpecOf, } from "../program.js";
+import { isStrictCode } from "./strict-mode.js";
+import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, bufferNamespaceMember, stdlibGlobalNameOf, } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
 import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf, } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, } from "./containers/for-of.js";
+import { lowerForOfHelperChain } from "./containers/iterator-helpers.js";
 import { objectIterOverIndexShape } from "./containers/indexed-objects.js";
 import { strCharsCall } from "./containers/array-construction.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, } from "./generic-functions.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, genericLocalClassBinding, } from "./generic-functions.js";
 import { bindingNeverReassigned, deadUnmappableBinding, nullishExprUnitOf, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
 import { hasExplicitJsDocReturn } from "./function-returns.js";
 import { recordKeysArrayCall } from "./lower-calls.js";
@@ -47,11 +67,14 @@ import { isTimersPromisesIntervalCall } from "./builtins/timers.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, } from "./builtins/module-bindings.js";
 import { lowerNodeModuleCall } from "./builtins/module-resolution.js";
 import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
+import { builtinClassAliasOwnsNoSlot, registerBuiltinClassAlias } from "./builtins/class-values.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompoundStatement, lowerIncDec, lowerIncDecTarget, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerCompoundValueToTarget, lowerElementCompoundStatement, lowerIncDec, lowerIncDecTarget, lowerOptionalNumber, lowerGroupsProjection, matchResultNamedGroupsOf, runtimeOptionalGuardIds, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed, } from "./lower-exprs.js";
 import { globalSymbolKey } from "./expressions/global-symbols.js";
+import { identifiersNamed } from "./identifier-uses.js";
 import { lowerShortCircuitAssignment } from "./expressions/nullish-assignment.js";
-import { lowerEnvironmentKey, lowerNativeFunctionAssignment } from "./lower-exprs.js";
+import { builtinGlobalValue, jsHoldsDynObject, lowerEnvironmentKey, lowerNativeFunctionAssignment, lowerStrictEquality, } 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";
@@ -64,6 +87,7 @@ import { constituentTypes } from "../ts7/checker.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { fenceNodeModuleMutation } from "./lower-node-module.js";
 import { fencePerfEntryKeyWalk } from "./builtins/performance.js";
+import { classGeneratorIterable } from "./class-iterables.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
@@ -72,9 +96,9 @@ 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 ||
+        decl.initializer.elements.nodes.length !== 0 ||
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
+        npmStaticPackageOfPath(ts.getSourceFileOfNode(decl).fileName) === null ||
         lowerer.ctx.returnType.kind !== "array") {
         return null;
     }
@@ -112,8 +136,8 @@ function npmStaticReturnedEmptyArrayType(lowerer, decl) {
  * the assignment, narrows it. */
 function npmStaticOptionalSelfWriteType(lowerer, decl, initial) {
     if (!ts.isIdentifier(decl.name) ||
-        !isJsSourceFile(decl.getSourceFile()) ||
-        npmStaticPackageOfPath(decl.getSourceFile().fileName) === null ||
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
+        npmStaticPackageOfPath(ts.getSourceFileOfNode(decl).fileName) === null ||
         initial.kind === "union") {
         return null;
     }
@@ -173,8 +197,9 @@ function stdlibTypeNamed(lowerer, node, name) {
         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 (sym !== undefined &&
+            ts.symbolName(sym) === name &&
+            sym.declarations.some((d) => lowerer.isStdlibFile(ts.getSourceFileOfNode(d))));
     };
     return visit(lowerer.typeOf(node));
 }
@@ -356,7 +381,7 @@ function lowerUsingStatement(lowerer, stmt) {
         lowerer.unsupported("SC1090", stmt, "'await using' outside an async function or top-level-await module");
     }
     const registrations = [];
-    for (const decl of stmt.declarationList.declarations) {
+    for (const decl of stmt.declarationList.declarations.nodes) {
         if (!ts.isIdentifier(decl.name))
             lowerer.unsupported("SC1031", decl.name);
         if (decl.initializer === undefined)
@@ -386,14 +411,14 @@ function pureAnnotatedDeadConst(stmt, sf) {
         return false;
     if ((stmt.declarationList.flags & ts.NodeFlags.Const) === 0)
         return false;
-    const decls = stmt.declarationList.declarations;
+    const decls = stmt.declarationList.declarations.nodes;
     if (decls.length === 0)
         return false;
     return decls.every((d) => {
         let init = d.initializer;
         if (init === undefined)
             return false;
-        const trivia = sf.text.slice(init.pos, init.getStart(sf));
+        const trivia = sf.text.slice(init.pos, ts.tokenStartOfNode(init));
         if (!trivia.includes("@__PURE__") && !trivia.includes("#__PURE__"))
             return false;
         // `as` casts are type-world wrappers (`(() => {...})() as unknown as
@@ -421,7 +446,7 @@ function pureAnnotatedDeadConst(stmt, sf) {
  * probes that would otherwise claim (and diagnose) the call-initializer
  * shape. */
 export function provenanceElidedConstDecl(lowerer, decl) {
-    const sf = decl.getSourceFile();
+    const sf = ts.getSourceFileOfNode(decl);
     if (!isProvenanceSourceFile(sf.fileName))
         return false;
     const stmt = decl.parent?.parent;
@@ -468,7 +493,7 @@ export function lowerStmts(lowerer, stmts) {
     // runtimeFence — a catchable, SC-coded throw at the statement's
     // position — instead of failing the whole build). TypeScript keeps
     // compile fences. ICEs (SC9001) always stay compile errors.
-    const sf = stmts[0]?.getSourceFile();
+    const sf = stmts.length === 0 ? undefined : ts.getSourceFileOfNode(stmts[0]);
     const deferFences = sf !== undefined && isJsSourceFile(sf);
     // Register this list as open for the forward-capture machinery: a
     // nested function lowering mid-list may pre-declare a LATER const of
@@ -482,16 +507,20 @@ export function lowerStmts(lowerer, stmts) {
         out,
     };
     lowerer.activeStmtLists.push(entry);
+    const inFunction = stmts.length > 0 && enclosedByFunction(stmts[0]);
+    let unreachable = false;
     try {
         for (let i = 0; i < stmts.length; i++) {
             const stmt = stmts[i];
             entry.index = i;
-            if (!lowerer.suppressStats) {
-                lowerer.stats.statementsTotal++;
-                if (sf !== undefined)
-                    lowerer.bumpFileStat(sf.fileName, "total");
-            }
+            if (unreachable && skipsWhenUnreachable(stmt))
+                continue;
+            if (inFunction && isAbruptStatement(stmt))
+                unreachable = true;
+            if (!lowerer.suppressStats)
+                lowerer.countStatement(stmt, sf?.fileName);
             const diagsBefore = lowerer.diags.length;
+            const sinkMark = lowerer.diagSinkMark();
             try {
                 let lowered;
                 let appended = false;
@@ -558,11 +587,8 @@ export function lowerStmts(lowerer, stmts) {
                 else if (!(e instanceof PoisonError)) {
                     throw e;
                 }
-                if (!lowerer.suppressStats) {
-                    lowerer.stats.statementsFailed++;
-                    if (sf !== undefined)
-                        lowerer.bumpFileStat(sf.fileName, "failed");
-                }
+                if (!lowerer.suppressStats)
+                    lowerer.countStatementFailed(stmt, sf?.fileName);
                 lowerer.noteBlockedBindings(stmt);
                 // The runtime-fence conversion (JS sources, direct diagnostics
                 // only — a capture wrapper in force means collection owns the
@@ -583,6 +609,13 @@ export function lowerStmts(lowerer, stmts) {
                     if (fence)
                         out.push(fence);
                 }
+                else if (deferFences) {
+                    // Inside a capture buffer the owner keeps the diagnostics, but
+                    // the statement still must not vanish from a result it keeps.
+                    const fence = lowerer.capturedRuntimeFence(sinkMark, stmt);
+                    if (fence)
+                        out.push(fence);
+                }
             }
         }
         // Each acquisition protects the remainder of its lexical statement
@@ -608,6 +641,48 @@ export function lowerStmts(lowerer, stmts) {
     }
     return out;
 }
+/** Whether a statement list belongs to a function body (at any block
+ * depth) rather than to a module's top level. */
+function enclosedByFunction(stmt) {
+    let owner = stmt.parent;
+    while (owner !== undefined && !ts.isFunctionLike(owner) && !ts.isSourceFile(owner))
+        owner = owner.parent;
+    return owner !== undefined && ts.isFunctionLike(owner);
+}
+/** `return`, `throw`, `break` and `continue`: the rest of the enclosing
+ * statement list never runs. */
+function isAbruptStatement(stmt) {
+    return (ts.isReturnStatement(stmt) ||
+        ts.isThrowStatement(stmt) ||
+        ts.isBreakStatement(stmt) ||
+        ts.isContinueStatement(stmt));
+}
+/** Statements after an abrupt statement in a function body that lowering
+ * skips: they never execute, so neither their unsupported constructs nor the
+ * functions they reference become part of the program (production builds of
+ * libraries keep development-only code behind `throw` stubs this way).
+ * Hoisting keeps its meaning: a reference above the abrupt statement to a
+ * later function declaration lowers that declaration eagerly
+ * (predeclareForwardFnDecl), and references to a later `var`, `let` or
+ * `const` binding resolve through the forward-hoisting machinery to its
+ * undefined or TDZ state, which skipping its initializer preserves. Class,
+ * enum, module and import/export declarations and generic function
+ * declarations still lower. */
+function skipsWhenUnreachable(stmt) {
+    if (ts.isFunctionDeclaration(stmt))
+        return stmt.typeParameters === undefined;
+    if (ts.isVariableStatement(stmt))
+        return !(stmt.modifiers?.nodes ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+    return !(ts.isClassDeclaration(stmt) ||
+        ts.isEnumDeclaration(stmt) ||
+        ts.isModuleDeclaration(stmt) ||
+        ts.isImportDeclaration(stmt) ||
+        ts.isImportEqualsDeclaration(stmt) ||
+        ts.isExportDeclaration(stmt) ||
+        ts.isExportAssignment(stmt) ||
+        ts.isInterfaceDeclaration(stmt) ||
+        ts.isTypeAliasDeclaration(stmt));
+}
 const TDZ_KINDS = new Set([
     "func",
     "string",
@@ -661,7 +736,7 @@ const TDZ_KINDS = new Set([
  * is empty. Mutable bindings also guard writes; only the declaration's
  * initializing assignment may leave the temporal dead zone. */
 export function predeclareForwardCapture(lowerer, symbol) {
-    const decl = lowerer.checker.valueDeclarationOf(symbol);
+    const decl = symbol.valueDeclaration;
     if (!decl ||
         !ts.isVariableDeclaration(decl) ||
         decl.name === undefined ||
@@ -672,6 +747,10 @@ export function predeclareForwardCapture(lowerer, symbol) {
     const flags = ts.getCombinedNodeFlags(decl);
     if ((flags & ts.NodeFlags.BlockScoped) === 0 || (flags & ts.NodeFlags.Using) !== 0)
         return false;
+    // `const E = EventEmitter` has no storage to box: uses resolve at
+    // compile time (builtinClassAliasOf).
+    if (builtinClassAliasOwnsNoSlot(lowerer, symbol))
+        return false;
     // MODULE-scope bindings are pre-registered globals (collectGlobals):
     // references resolve through globalOf after the local search fails, so
     // a TDZ box here would SHADOW the global and never fill (the top-level
@@ -697,7 +776,7 @@ export function predeclareForwardCapture(lowerer, symbol) {
         if (idx < entry.index || entry.ctx === lowerer.ctx || entry.ctx.tdzPredeclared.has(symbol))
             return false;
         let type = lowerer.irTypeOf(decl.name);
-        if (isJsSourceFile(decl.getSourceFile()) &&
+        if (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             !hasJsTypeAnnotation(decl) &&
             (ts.isObjectLiteralExpression(decl.initializer) ||
@@ -739,8 +818,8 @@ export function predeclareForwardCapture(lowerer, symbol) {
  * lower the declaration under the owning statement list's context, then
  * resume the caller and thread its captures normally. */
 export function predeclareForwardFnDecl(lowerer, symbol) {
-    const decl = lowerer.checker.valueDeclarationOf(symbol);
-    if (!decl || !ts.isFunctionDeclaration(decl) || !decl.body || decl.typeParameters)
+    const decl = symbol.valueDeclaration;
+    if (!decl || !ts.isFunctionDeclaration(decl) || !decl.body || decl.typeParameters?.nodes)
         return false;
     for (let i = lowerer.activeStmtLists.length - 1; i >= 0; i--) {
         const entry = lowerer.activeStmtLists[i];
@@ -765,14 +844,26 @@ export function predeclareForwardFnDecl(lowerer, symbol) {
         entry.ctx.hoistedFnDecls.add(decl);
         const fnTail = lowerer.fnStack.splice(depth + 1);
         const scopeTail = entry.ctx.scopes.splice(frameIdx + 1);
+        // The hoisted function is kept even when the reference lowers inside
+        // a speculative attempt (a probe's temporary diagnostic sink): lower
+        // it without that sink, so its failing JS statements keep their
+        // runtime fences instead of vanishing from a body that is kept. A
+        // declaration that fails as a whole is not kept: its diagnostics go
+        // back to the probe.
+        const previousSink = lowerer.diagSink;
+        const diagsBefore = lowerer.diags.length;
+        lowerer.diagSink = null;
         try {
             entry.out.push(lowerer.lowerNestedFunctionDecl(decl));
         }
         catch (e) {
             entry.ctx.hoistedFnDecls.delete(decl);
+            if (previousSink !== null)
+                previousSink.push(...lowerer.diags.splice(diagsBefore));
             throw e;
         }
         finally {
+            lowerer.diagSink = previousSink;
             entry.ctx.scopes.push(...scopeTail);
             lowerer.fnStack.push(...fnTail);
         }
@@ -804,16 +895,108 @@ function hostVariableDeclarationOf(name) {
  * iteration), and it persists after the loop. Returns the write target
  * (a module global for top-level loops, the hoisted function slot
  * otherwise); null when the binding isn't a `var` identifier. */
-export function forOfVarTarget(lowerer, decl) {
+export function forOfVarTarget(lowerer, decl, valueType) {
     if (!ts.isIdentifier(decl.name) || !isVarDeclared(decl))
         return null;
     const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
     if (!symbol)
         return null;
     const g = lowerer.globalsBySymbol.get(symbol);
-    if (g)
+    if (g) {
+        if (valueType?.kind === "dyn" && jsBindingKeepsCheckedObject(lowerer, decl.name, g.type))
+            g.type = DYN;
         return g;
-    return hoistVarBinding(lowerer, symbol, decl.name);
+    }
+    return hoistVarBinding(lowerer, symbol, decl.name, valueType);
+}
+/** JavaScript: whether an unannotated variable binding whose static type
+ * is `type` keeps a checked-dynamic value unconverted. The checker types
+ * such a binding by the object it receives (an element of an evolving
+ * `[]`, a `find` result, a member of a checked-dynamic object), but the
+ * value is an existing checked-dynamic object or array: a record- or
+ * array-typed slot would hold a converted copy, so writes through the
+ * binding would miss the object other references see, and `===` against
+ * them would fail. Block-scoped bindings with an identifier name keep such
+ * values by the same rule in lowerVarDecl (preservesObjectIdentity). */
+function jsBindingKeepsCheckedObject(lowerer, nameNode, type) {
+    if (!isJsSourceFile(ts.getSourceFileOfNode(nameNode)))
+        return false;
+    const host = hostVariableDeclarationOf(nameNode);
+    if (!host || host.type || hasJsTypeAnnotation(host))
+        return false;
+    const arms = type.kind === "union" ? (lowerer.unions.get(type.unionId)?.arms ?? []) : [type];
+    return (arms.some((arm) => arm.kind === "record" || arm.kind === "array") &&
+        arms.every((arm) => arm.kind === "record" || arm.kind === "array" || isUnitType(arm)));
+}
+/** Whether `node` mentions the binding `symbol` anywhere, nested functions
+ * included. */
+function mentionsSymbol(lowerer, node, symbol) {
+    if (ts.isIdentifier(node))
+        return lowerer.checker.getSymbolAtLocation(node) === symbol;
+    return (ts.forEachChild(node, (child) => mentionsSymbol(lowerer, child, symbol) ? true : undefined) === true);
+}
+/** Whether `node` evaluates to an existing value rather than constructing
+ * one whose layout a destination directs: not a literal, `new`, function
+ * or class expression, nor a conditional with such an arm (an arm that
+ * is `null` or `undefined` constructs nothing). */
+function existingValueForm(node, armOfConditional = false) {
+    while (ts.isParenthesizedExpression(node))
+        node = node.expression;
+    if (ts.isConditionalExpression(node))
+        return existingValueForm(node.whenTrue, true) && existingValueForm(node.whenFalse, true);
+    if (armOfConditional &&
+        (node.kind === ts.SyntaxKind.NullKeyword ||
+            (ts.isIdentifier(node) && node.text === "undefined")))
+        return true;
+    return !(ts.isObjectLiteralExpression(node) ||
+        ts.isArrayLiteralExpression(node) ||
+        ts.isNewExpression(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isClassExpression(node) ||
+        ts.isLiteralExpression(node) ||
+        node.kind === ts.SyntaxKind.NullKeyword);
+}
+/** JavaScript `var x = e` whose binding could hold an existing
+ * checked-dynamic object (jsBindingKeepsCheckedObject): lowers `e` BEFORE
+ * minting the hoisted slot, as a block-scoped declaration does, so a
+ * checked-dynamic value gets a checked-dynamic slot instead of a converted
+ * copy. Other values coerce into the planned slot exactly as
+ * lowerExprExpecting would. Null when the declaration does not qualify:
+ * the slot already exists, the initializer is fresh construction whose
+ * layout the slot type directs (existingValueForm; a literal holding an
+ * existing checked-dynamic object qualifies), or it refers to the binding
+ * itself (hoist-before-init resolves that reference). */
+function lowerJsVarFromExisting(lowerer, decl, symbol) {
+    if (!ts.isIdentifier(decl.name) || !decl.initializer)
+        return null;
+    if (!isJsSourceFile(ts.getSourceFileOfNode(decl)) || lowerer.ctx.hoistedVars.has(symbol))
+        return null;
+    if (lowerer.bindingIn(lowerer.ctx, symbol))
+        return null;
+    let node = decl.initializer;
+    while (ts.isParenthesizedExpression(node) || ts.isSatisfiesExpression(node))
+        node = node.expression;
+    // A literal holding an existing checked-dynamic object builds as a
+    // checked-dynamic literal without a destination (lowerArrayLiteral,
+    // lowerObjectLiteral): a record- or array-typed slot would copy it.
+    const holdsChecked = (ts.isArrayLiteralExpression(node) || ts.isObjectLiteralExpression(node)) &&
+        jsHoldsDynObject(lowerer, node);
+    if (!holdsChecked && !existingValueForm(node))
+        return null;
+    const planned = varBindingType(lowerer, decl.name);
+    if (!planned || !jsBindingKeepsCheckedObject(lowerer, decl.name, planned))
+        return null;
+    if (mentionsSymbol(lowerer, node, symbol))
+        return null;
+    const value = lowerer.lowerExpr(node);
+    const local = hoistVarBinding(lowerer, symbol, decl.name, value.type.kind === "dyn" ? DYN : undefined);
+    return {
+        kind: "assign",
+        localId: local.id,
+        value: lowerer.coerceExistingInto(node, value, local.type),
+        loc: locOf(decl),
+    };
 }
 /** The `var` symbol's function-scoped binding TYPE — the declared type at
  * the binding name, with the JS-source fallbacks every mutable binding
@@ -825,12 +1008,16 @@ function varBindingType(lowerer, nameNode) {
     if (ts.isVariableDeclaration(nameNode.parent) &&
         isNativeProxyInitializer(lowerer, nameNode.parent.initializer))
         return DYN;
-    if (isJsSourceFile(nameNode.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(nameNode)) &&
         ts.isVariableDeclaration(nameNode.parent) &&
         isNativeBuiltinValueInitializer(lowerer, nameNode.parent.initializer))
         return DYN;
+    if (ts.isVariableDeclaration(nameNode.parent) &&
+        !nameNode.parent.type &&
+        isPromisePrototypeRead(lowerer, nameNode.parent.initializer))
+        return DYN;
     let type = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
-    if (type?.kind === "record" && isJsSourceFile(nameNode.getSourceFile())) {
+    if (type?.kind === "record" && isJsSourceFile(ts.getSourceFileOfNode(nameNode))) {
         const shape = lowerer.shapes.get(type.shapeId);
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
@@ -866,7 +1053,7 @@ function varBindingType(lowerer, nameNode) {
  * a loop re-ASSIGNS the one binding per pass and never resets it — the
  * classic capture semantics fall out: closures made in a loop share the
  * single boxed binding, where `let` gets a fresh box per iteration. */
-function hoistVarBinding(lowerer, symbol, nameNode) {
+function hoistVarBinding(lowerer, symbol, nameNode, valueType) {
     const existing = lowerer.ctx.hoistedVars.get(symbol);
     if (existing)
         return existing;
@@ -876,7 +1063,15 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
         lowerer.ctx.hoistedVars.set(symbol, bound);
         return bound;
     }
-    const type = varBindingType(lowerer, nameNode);
+    let type = varBindingType(lowerer, nameNode);
+    // The first value stored is an existing checked-dynamic object: keep it
+    // (jsBindingKeepsCheckedObject). A checked-dynamic slot holds undefined
+    // natively, so no runtime-optional widening applies.
+    const keepsChecked = valueType?.kind === "dyn" &&
+        type !== null &&
+        jsBindingKeepsCheckedObject(lowerer, nameNode, type);
+    if (keepsChecked)
+        type = DYN;
     if (!type)
         lowerer.badType(nameNode, lowerer.typeOf(nameNode));
     const root = lowerer.activeStmtLists.find((e) => e.ctx === lowerer.ctx);
@@ -894,7 +1089,8 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
     };
     lowerer.ctx.locals.push(local);
     lowerer.ctx.scopes[0].set(symbol, local);
-    noteEarlyReadVar(lowerer, symbol, local);
+    if (!keepsChecked)
+        noteEarlyReadVar(lowerer, symbol, local);
     // A checked-dynamic slot holds the dyn undefined (a NULL dyn is a
     // trap); everything else rides unassignedSlotInit (interned union arm,
     const wrapped = type.kind === "dyn"
@@ -921,7 +1117,7 @@ export function predeclareForwardVar(lowerer, symbol) {
     // Module-scope vars already have their global storage.
     if (lowerer.globalsBySymbol.has(symbol))
         return false;
-    const decl = lowerer.checker.valueDeclarationOf(symbol);
+    const decl = symbol.valueDeclaration;
     if (!decl || !ts.isVariableDeclaration(decl) || !isVarDeclared(decl))
         return false;
     const nameNode = ts.isIdentifier(decl.name) ? decl.name : null;
@@ -1001,7 +1197,7 @@ export function noteBlockedBindings(lowerer, stmt) {
     }
     if (!list)
         return;
-    for (const decl of list.declarations) {
+    for (const decl of list.declarations.nodes) {
         for (const nameNode of boundIdentifiersOf(decl.name)) {
             const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
             if (symbol)
@@ -1026,7 +1222,7 @@ export function isBlockedBinding(lowerer, symbol) {
 export function lowerScopedBlock(lowerer, stmt) {
     lowerer.scopes.push(new Map());
     try {
-        return withRuntimeOptionalScope(lowerer, () => ts.isBlock(stmt) ? lowerer.lowerStmts(stmt.statements) : lowerer.lowerStmts([stmt]));
+        return withRuntimeOptionalScope(lowerer, () => ts.isBlock(stmt) ? lowerer.lowerStmts(stmt.statements.nodes) : lowerer.lowerStmts([stmt]));
     }
     finally {
         lowerer.scopes.pop();
@@ -1084,7 +1280,20 @@ function lowerLabeled(lowerer, stmt) {
     const body = lowerer.inCtl("block", () => lowerer.lowerScopedBlock(inner), labels);
     return { kind: "block", body, labels, loc: locOf(stmt) };
 }
+// Value kinds a `throw` converts to a checked-dynamic value, so the catch
+// binding sees the thrown object rather than a type-erased reference.
+const THROWN_AS_DYN = new Set([
+    "array",
+    "union",
+    "map",
+    "set",
+    "bytes",
+    "func",
+    "regex",
+]);
 export function lowerStmt(lowerer, stmt) {
+    if (ownPrototypeResetStatement(lowerer, stmt))
+        return { kind: "block", body: [], loc: locOf(stmt) };
     if (ts.isClassDeclaration(stmt)) {
         if (!stmt.name)
             lowerer.unsupported("SC1090", stmt, "anonymous local class declarations");
@@ -1097,7 +1306,7 @@ export function lowerStmt(lowerer, stmt) {
     if (ts.isVariableStatement(stmt)) {
         // `declare const` — ambient: no storage, no init (collectGlobals
         // skipped it; reads throw Node's ReferenceError at the access).
-        const first = stmt.declarationList.declarations[0];
+        const first = stmt.declarationList.declarations.nodes[0];
         if (first && ts.getCombinedModifierFlags(first) & ts.ModifierFlags.Ambient)
             return null;
         return lowerer.lowerVarStatement(stmt);
@@ -1111,6 +1320,20 @@ export function lowerStmt(lowerer, stmt) {
     }
     if (ts.isIfStatement(stmt)) {
         const cond = lowerer.lowerCondition(stmt.expression);
+        // A global-detection condition (static-typeof.ts) folds; its untaken
+        // arm is code Node never runs and does not lower, unless it declares a
+        // hoisted binding.
+        const decided = staticCondition(lowerer, stmt.expression);
+        if (decided !== null) {
+            const taken = decided ? stmt.thenStatement : stmt.elseStatement;
+            const untaken = decided ? stmt.elseStatement : stmt.thenStatement;
+            if (untaken === undefined || !declaresHoistedBinding(untaken)) {
+                const arm = taken === undefined ? [] : lowerer.lowerScopedBlock(taken);
+                return decided
+                    ? { kind: "if", cond, then: arm, else_: null, loc: locOf(stmt) }
+                    : { kind: "if", cond, then: [], else_: arm, loc: locOf(stmt) };
+            }
+        }
         // Aliased-typeof narrows (ms's `var type = typeof val` guard): the
         // then-branch lowers under what a TRUE condition proves, the
         // else-branch under a FALSE one — the var/let alias narrowing the
@@ -1176,6 +1399,12 @@ export function lowerStmt(lowerer, stmt) {
         // incompatible boundary keeps the ordinary per-statement refusal.
         let value = null;
         if (stmt.expression) {
+            // A constructor's returned object replaces the constructed `this`.
+            if (lowerer.currentClass?.ctor) {
+                const constructorReturn = lowerConstructorReturn(lowerer, stmt);
+                if (constructorReturn !== null)
+                    return constructorReturn;
+            }
             return lowerer.lowerReturnStmt(stmt.expression, locOf(stmt));
         }
         else if (lowerer.ctx.returnType.kind === "union") {
@@ -1240,6 +1469,13 @@ export function lowerStmt(lowerer, stmt) {
         else if (value.type.kind === "record" && lowerer.dynConvertible(value.type)) {
             value = { kind: "dynFrom", value, liveRef: true, type: DYN, loc: locOf(stmt.expression) };
         }
+        else if (THROWN_AS_DYN.has(value.type.kind) && lowerer.dynConvertible(value.type)) {
+            // Arrays, Maps, Sets, typed arrays, Buffers, functions, regexes and
+            // unions over them keep their identity and contents the same way:
+            // the catch binding, `typeof`, `instanceof`, `Array.isArray`,
+            // inspection and typed views read the thrown object.
+            value = lowerer.coerceInto(stmt.expression, value, DYN);
+        }
         if (value.type.kind === "date") {
             lowerer.unsupported("SC1090", stmt.expression, "throwing Date values (catch bindings cannot preserve Date's object kind; throw an Error or primitive instead)");
         }
@@ -1313,77 +1549,131 @@ export function lowerVarStatement(lowerer, stmt) {
     }
     const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
-    return list.declarations.flatMap((decl) => {
-        // The canonical ESM bridge to a compiled program module. Like a
-        // top-level CommonJS require declaration, the binding is alias
-        // plumbing while the dependency evaluates at this statement's
-        // exact position through its run-once initializer.
-        if (isConst && createRequireProgramModuleDecl(lowerer, decl.name, decl.initializer)) {
-            if (!ts.isSourceFile(stmt.parent)) {
-                lowerer.unsupported("SC1090", decl, "createRequire program-module bindings outside the module's top level (move the binding to the top of the file; side-effect-only requires may remain nested)");
-            }
-            const target = createRequireProgramModuleOf(lowerer, decl.initializer);
-            const init = lowerer.requireInitStmt(target.spec, decl);
+    return list.declarations.nodes.flatMap((decl) => {
+        const lowered = lowerVarDeclarator(lowerer, stmt, decl, isConst, isLet);
+        // A require binding earlier code can read is initialized from here on
+        // (require-initialization.ts).
+        const initialized = requireInitFlagStmt(lowerer, decl);
+        return initialized ? [...lowered, initialized] : lowered;
+    });
+}
+function lowerVarDeclarator(lowerer, stmt, decl, isConst, isLet) {
+    // The canonical ESM bridge to a compiled program module. Like a
+    // top-level CommonJS require declaration, the binding is alias
+    // plumbing while the dependency evaluates at this statement's
+    // exact position through its run-once initializer.
+    if (isConst && createRequireProgramModuleDecl(lowerer, decl.name, decl.initializer)) {
+        if (!ts.isSourceFile(stmt.parent)) {
+            lowerer.unsupported("SC1090", decl, "createRequire program-module bindings outside the module's top level (move the binding to the top of the file; side-effect-only requires may remain nested)");
+        }
+        const target = createRequireProgramModuleOf(lowerer, decl.initializer);
+        const init = lowerer.requireInitStmt(target.spec, decl);
+        return init ? [init] : [];
+    }
+    // tsc's interop bindings (`const x_1 = __importDefault(require("./m"))`)
+    // are require bindings (cjs-tsc-interop.ts): the module's %init here.
+    if (ts.isSourceFile(stmt.parent)) {
+        const interop = tscInteropBindingOfDecl(lowerer, decl);
+        if (interop !== null) {
+            const init = lowerer.requireInitStmt(interop.spec, decl);
             return init ? [init] : [];
         }
-        // CommonJS require declarations (JS files): at the module's top
-        // level the BINDINGS are alias plumbing (no storage;
-        // resolveValueSymbol routes the reads), but the require itself is
-        // Node's inline module evaluation — a relative require lowers to the
-        // required module's guarded %init call at exactly this position
-        // (first require runs the body, later ones are cache hits; builtins
-        // load nothing). Binding requires anywhere else would need lazily-
-        // initialized alias storage this model doesn't represent; named
-        // fence.
-        if (decl.initializer !== undefined &&
-            requireSpecOf(decl.initializer) !== null &&
-            !isNativeFfiRequire(lowerer, decl.initializer) &&
-            isJsSourceFile(decl.getSourceFile())) {
-            const spec = requireSpecOf(decl.initializer);
-            if (lowerer.externalTypes.has(spec))
-                lowerer.externalHostFence(spec, decl, false);
-            if (ts.isSourceFile(stmt.parent)) {
-                const init = lowerer.requireInitStmt(spec, decl);
-                return init ? [init] : [];
-            }
-            // A nested BUILTIN require (`get inFreeBSDJail() { const { execSync }
-            // = require('child_process'); ... }` — test/common's lazy-getter
-            // idiom): builtins load nothing, so the statement is PURE alias
-            // plumbing wherever it sits — the bindings resolve through the
-            // same routing top-level requires use, and no statement remains.
-            // Relative requires keep the fence: their module-init-at-position
-            // semantics needs storage this model doesn't represent.
-            if (canonicalBuiltinModule(spec) !== null) {
-                return [];
-            }
-            lowerer.unsupported("SC1090", decl, "require() with bindings outside the module's top level (move it to the top of the file)");
-        }
-        // `const { NGHTTP2_CANCEL } = http2.constants` — a destructure over
-        // the baked constants table: alias plumbing, no storage (uses read
-        // their literals via builtinConstantBindingOf; collectGlobals skipped
-        // the globals by the same test).
-        if (lowerer.builtinConstantsDestructureDecl(decl.name, decl.initializer))
+        if (isDeadTscHelperDecl(lowerer, stmt))
             return [];
-        if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
-            // `const { createSign } = crypto` over a builtin NAMESPACE binding:
-            // alias plumbing (builtinImportOf routes the reads) — no statement.
-            if (builtinNamespaceDestructureModuleOf(lowerer, decl) !== null)
-                return [];
-            return lowerer.lowerDestructuringDecl(decl, isLet);
-        }
-        // STORED protocol values with statically closed representations:
-        // numeric value iterators retain source/cursor/done hidden locals; a
-        // matchAll drain retains its companion index array so a later
-        // for-of can serve `m.index`. Both are const-only interceptions.
-        const numericIterator = lowerNumericIteratorDecl(lowerer, decl, isConst);
-        if (numericIterator)
-            return numericIterator;
-        const drained = lowerMatchAllDrainDecl(lowerer, decl, isConst);
-        if (drained)
-            return drained;
-        const lowered = lowerer.lowerVarDecl(decl, isLet);
-        return lowered ? [lowered] : [];
-    });
+    }
+    // CommonJS require declarations (JS files): at the module's top
+    // level the BINDINGS are alias plumbing (no storage;
+    // resolveValueSymbol routes the reads), but the require itself is
+    // Node's inline module evaluation — a relative require lowers to the
+    // required module's guarded %init call at exactly this position
+    // (first require runs the body, later ones are cache hits; builtins
+    // load nothing). Binding requires anywhere else would need lazily-
+    // initialized alias storage this model doesn't represent; named
+    // fence.
+    if (decl.initializer !== undefined &&
+        requireSpecOf(decl.initializer) !== null &&
+        !isNativeFfiRequire(lowerer, decl.initializer) &&
+        !isJsonRequireDecl(lowerer, decl) &&
+        isJsSourceFile(ts.getSourceFileOfNode(decl))) {
+        const spec = requireSpecOf(decl.initializer);
+        if (lowerer.externalTypes.has(spec))
+            lowerer.externalHostFence(spec, decl, false);
+        if (ts.isSourceFile(stmt.parent)) {
+            const init = lowerer.requireInitStmt(spec, decl);
+            const out = init ? [init] : [];
+            // Nested patterns destructure the named export's value right after
+            // the module evaluated (`const { codes: { ERR_X } } = require(...)`).
+            for (const element of requireNestedPatternsOf(decl)) {
+                const key = element.propertyName;
+                const value = lowerer.lowerExpr(key);
+                lowerer.lowerBindingPattern(element.name, () => lowerer.lowerExpr(key), value.type, isLet, out);
+            }
+            return out;
+        }
+        // A nested BUILTIN require (`get inFreeBSDJail() { const { execSync }
+        // = require('child_process'); ... }` — test/common's lazy-getter
+        // idiom): builtins load nothing, so the statement is PURE alias
+        // plumbing wherever it sits — the bindings resolve through the
+        // same routing top-level requires use, and no statement remains.
+        // Relative requires keep the fence: their module-init-at-position
+        // semantics needs storage this model doesn't represent.
+        if (canonicalBuiltinModule(spec) !== null) {
+            return canonicalBuiltinModule(spec) === "punycode"
+                ? [lowerer.punycodeRequireWarning(decl)]
+                : [];
+        }
+        lowerer.unsupported("SC1090", decl, "require() with bindings outside the module's top level (move it to the top of the file)");
+    }
+    // `const { NGHTTP2_CANCEL } = http2.constants` — a destructure over
+    // the baked constants table: alias plumbing, no storage (uses read
+    // their literals via builtinConstantBindingOf; collectGlobals skipped
+    // the globals by the same test).
+    if (lowerer.builtinConstantsDestructureDecl(decl.name, decl.initializer))
+        return [];
+    if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
+        // `const { createSign } = crypto` over a builtin NAMESPACE binding:
+        // alias plumbing (builtinImportOf routes the reads) — no statement.
+        if (builtinNamespaceDestructureModuleOf(lowerer, decl) !== null)
+            return [];
+        // `const { A, B } = ns` over a CommonJS module binding: each name
+        // snapshots the named export's value here (cjs-inline-require.ts).
+        {
+            const nsDestructure = cjsNamespaceDestructureOf(lowerer, decl);
+            if (nsDestructure !== null) {
+                const out = [];
+                for (const element of nsDestructure.elements) {
+                    const target = lowerer.globalOf(element.name);
+                    const value = cjsExportValueByName(lowerer, nsDestructure.dep, element.key, element.name);
+                    if (target === null || value === null) {
+                        lowerer.unsupported("SC1090", element.name, `destructuring the export '${element.key}' of a CommonJS module binding (it has no static value)`);
+                    }
+                    out.push({
+                        kind: "assign",
+                        localId: target.id,
+                        value: typeEquals(value.type, target.type)
+                            ? value
+                            : lowerer.coerceInto(element.name, value, target.type),
+                        loc: locOf(element.name),
+                        ...("tdz" in target && target.tdz ? { initializes: true } : {}),
+                    });
+                }
+                return out;
+            }
+        }
+        return lowerer.lowerDestructuringDecl(decl, isLet);
+    }
+    // STORED protocol values with statically closed representations:
+    // numeric value iterators retain source/cursor/done hidden locals; a
+    // matchAll drain retains its companion index array so a later
+    // for-of can serve `m.index`. Both are const-only interceptions.
+    const numericIterator = lowerNumericIteratorDecl(lowerer, decl, isConst);
+    if (numericIterator)
+        return numericIterator;
+    const drained = lowerMatchAllDrainDecl(lowerer, decl, isConst);
+    if (drained)
+        return drained;
+    const lowered = lowerer.lowerVarDecl(decl, isLet);
+    return lowered ? [lowered] : [];
 }
 /** The numeric indexed source of a built-in value-iterator expression:
  * `numbers.values()` or the equivalent
@@ -1398,7 +1688,7 @@ export function numericIteratorSourceOf(lowerer, expr) {
     let init = expr;
     while (ts.isParenthesizedExpression(init))
         init = init.expression;
-    if (!ts.isCallExpression(init) || init.questionDotToken || init.arguments.length !== 0)
+    if (!ts.isCallExpression(init) || init.questionDotToken || init.arguments.nodes.length !== 0)
         return null;
     let receiver = null;
     if (ts.isPropertyAccessExpression(init.expression) &&
@@ -1494,7 +1784,7 @@ function lowerMatchAllDrainDecl(lowerer, decl, isConst) {
     const loc = locOf(decl);
     const access = call.expression;
     const receiver = lowerer.lowerExpr(access.expression);
-    const re = lowerer.lowerExpr(call.arguments[0]);
+    const re = lowerer.lowerExpr(call.arguments.nodes[0]);
     const idxsT = arrayOf(F64);
     const idxs = lowerer.declareHiddenLocal("%midxs", idxsT);
     const local = lowerer.declareLocal(decl.name, decl.name.text, rowsT, false);
@@ -1511,7 +1801,9 @@ function lowerMatchAllDrainDecl(lowerer, decl, isConst) {
             localId: local.id,
             init: {
                 kind: "regexIntrinsic",
-                method: "matchAllInto",
+                method: storedMatchAllRowsReadByElements(lowerer, decl)
+                    ? "matchAllCapturesInto"
+                    : "matchAllInto",
                 receiver,
                 args: [re, { kind: "varRef", localId: idxs.id, type: idxsT, loc }],
                 type: rowsT,
@@ -1527,7 +1819,7 @@ function lowerMatchAllDrainDecl(lowerer, decl, isConst) {
 export function isParseArgsDynCheckerType(lowerer, type) {
     const widened = lowerer.checker.getBaseTypeOfLiteralType(type);
     const declarationBelongs = (d) => {
-        if (!lowerer.isStdlibFile(d.getSourceFile()))
+        if (!lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))
             return false;
         let inParseArgsType = false;
         for (let node = d.parent; node; node = node.parent) {
@@ -1543,8 +1835,8 @@ export function isParseArgsDynCheckerType(lowerer, type) {
     };
     const sym = widened.getAliasSymbol() ?? widened.getSymbol();
     if (sym &&
-        isParseArgsDynTypeName(sym.name) &&
-        lowerer.checker.declarationsOf(sym).some(declarationBelongs)) {
+        isParseArgsDynTypeName(ts.symbolName(sym)) &&
+        sym.declarations.some(declarationBelongs)) {
         return true;
     }
     // A discriminant check erases the token alias and leaves one anonymous
@@ -1552,7 +1844,7 @@ export function isParseArgsDynCheckerType(lowerer, type) {
     // is the same stable signal the dotted-member bridge uses.
     return lowerer.checker
         .getPropertiesOfType(widened)
-        .some((p) => lowerer.checker.declarationsOf(p).some(declarationBelongs));
+        .some((p) => p.declarations.some(declarationBelongs));
 }
 /** Destructuring declarations, desugared as sugar over indexed/field
  * reads: the initializer evaluates ONCE into a hidden temp, then each
@@ -1587,12 +1879,17 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
         lowerer.lowerExpr(decl.initializer);
     const parseArgsDynObject = init.type.kind === "dyn" &&
         isParseArgsDynCheckerType(lowerer, lowerer.typeOf(decl.initializer));
-    // An `any`-origin source needs a represented record or array shape for
-    // destructuring. JS files retain their per-site runtime fences.
+    // An `any`-origin source destructures through a represented record or
+    // array shape, or through the checked-dynamic value it lowered to: the
+    // pattern reads members (or iterates) the dyn value exactly as a
+    // JavaScript file's pattern does, with the same per-site runtime fences
+    // (null/undefined sources throw Node's TypeError). Primitive and unit
+    // sources keep their own fences below; other carriers keep this one.
     if (lowerer.anyOrigin(decl.initializer) &&
-        !isJsSourceFile(decl.getSourceFile()) &&
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         init.type.kind !== "record" &&
-        init.type.kind !== "array") {
+        init.type.kind !== "array" &&
+        init.type.kind !== "dyn") {
         lowerer.anyOpFence("destructuring", decl);
     }
     // An IR-string source the CHECKER does not type as a string is a
@@ -1603,7 +1900,7 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
     // points), numbers and characters Node never sees. The fence names
     // the checker's own type instead of the carrier.
     if (init.type.kind === "string" &&
-        isJsSourceFile(decl.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !checkerStringSource(lowerer, decl.initializer)) {
         lowerer.unsupported("SC1031", decl.name, ts.isArrayBindingPattern(decl.name)
             ? `array destructuring of non-array values (the source is '${lowerer.checker.typeToString(lowerer.typeOf(decl.initializer))}'-typed)`
@@ -1615,7 +1912,7 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
         init.type.kind === "bool" ||
         init.type.kind === "string" ||
         isUnitType(init.type)) &&
-        !isJsSourceFile(decl.getSourceFile()) &&
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !(init.type.kind === "string" &&
             staticStringPattern(lowerer, decl.name))) {
         {
@@ -1631,7 +1928,7 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
     // (the message is the fence's — a unit value here is the failure
     // path either way). TypeScript keeps the fence: narrowing first is
     // the annotated fix.
-    if (isJsSourceFile(decl.getSourceFile()) && init.type.kind === "union") {
+    if (isJsSourceFile(ts.getSourceFileOfNode(decl)) && init.type.kind === "union") {
         const def = lowerer.unions.get(init.type.unionId);
         const dataArms = (def?.arms ?? []).filter((a) => !isUnitType(a));
         const arm = dataArms[0];
@@ -1669,41 +1966,55 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
             init = { kind: "unionNarrow", unionId: init.type.unionId, tag, value: uref, type: arm, loc };
         }
     }
-    // `const { groups } = re.exec(s)!` / `const { groups: { year } } = m`
-    // — every pattern element binds `groups` off a MATCH SLICE whose
-    // regex is statically known: the slice has no record shape of its
-    // own, so the groups projection (lowerGroupsProjection — the same
-    // record `m.groups` reads produce) wraps one level in a synthesized
-    // `{ groups: ... }` record and the ordinary record destructure below
-    // serves the pattern — aliases and nested patterns included. Only
-    // named-group regexes take the wrap: a group-less regex destructures
-    // `groups: undefined` in Node (a nested pattern then throws), which
-    // the fence reports honestly instead.
-    if (ts.isObjectBindingPattern(decl.name) &&
-        decl.name.elements.length > 0 &&
-        isMatchSliceType(lowerer, init.type) &&
-        decl.name.elements.every((el) => {
-            if (el.dotDotDotToken !== undefined || el.name === undefined)
-                return false;
-            const prop = el.propertyName;
-            if (prop === undefined)
-                return ts.isIdentifier(el.name) && el.name.text === "groups";
-            return (ts.isIdentifier(prop) || ts.isStringLiteral(prop)) && prop.text === "groups";
-        })) {
-        const groups = matchResultNamedGroupsOf(lowerer, decl.initializer);
-        if (groups !== null && groups.length > 0) {
-            const proj = lowerGroupsProjection(lowerer, init, groups, loc);
-            const outerShape = lowerer.shapes.intern([{ name: "groups", type: proj.type }], false, undefined, ["groups"]);
-            init = {
-                kind: "recordLit",
-                fields: [{ name: "groups", value: proj }],
-                type: { kind: "record", shapeId: outerShape },
-                loc,
-            };
-        }
-    }
+    const groupsSource = matchGroupsPatternSource(lowerer, decl.name, init, () => matchResultNamedGroupsOf(lowerer, decl.initializer), loc);
+    if (groupsSource !== null)
+        init = groupsSource;
     const tmp = lowerer.declareHiddenLocal("%destr", init.type);
     out.push({ kind: "varDecl", localId: tmp.id, init, loc });
+    // A TypeScript `any` source destructured through its checked-dynamic
+    // value: RequireObjectCoercible with V8's own TypeError ("Cannot
+    // destructure property 'a' of 'f(...)' as it is null.") for the source
+    // spellings the assignment form reproduces; other sources are refused,
+    // as in the assignment form. JavaScript files keep their existing
+    // per-read errors, except that a runtime computed first key checks the
+    // source first: Node throws before it evaluates any key, and V8's bare
+    // message names the source.
+    const jsRuntimeKeyCheck = init.type.kind === "dyn" &&
+        ts.isObjectBindingPattern(decl.name) &&
+        isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+        startsWithRuntimeKey(lowerer, decl.name) &&
+        destrSpellingOf(decl.initializer) !== null;
+    if (jsRuntimeKeyCheck ||
+        (init.type.kind === "dyn" &&
+            ts.isObjectBindingPattern(decl.name) &&
+            !isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+            lowerer.anyOrigin(decl.initializer))) {
+        const spelling = destrSpellingOf(decl.initializer);
+        if (spelling === null) {
+            lowerer.unsupported("SC1031", decl.initializer, "destructuring declaration from an `any` source whose expression spelling is unsupported (use a variable, ordinary property chain, or ordinary call)");
+        }
+        const first = decl.name.elements.nodes[0];
+        const firstKey = first === undefined || first.dotDotDotToken !== undefined
+            ? undefined
+            : (first.propertyName ?? first.name);
+        // V8 names the first property when its key is an identifier, a string
+        // or a number; a computed first key takes the bare (source-only) form.
+        const firstProp = firstKey === undefined || ts.isComputedPropertyName(firstKey)
+            ? undefined
+            : (patternKeyNameOf(lowerer, firstKey) ?? undefined);
+        out.push({
+            kind: "exprStmt",
+            expr: {
+                kind: "dynDestrCheck",
+                value: { kind: "varRef", localId: tmp.id, type: init.type, loc },
+                spelling,
+                ...(firstProp !== undefined ? { firstProp } : {}),
+                type: init.type,
+                loc,
+            },
+            loc,
+        });
+    }
     // V8's destructuring TypeError spells STATIC sources: an identifier
     // source reads "<name> is not iterable", an identifier-callee call
     // "<name> is not a function or its return value is not iterable";
@@ -1719,6 +2030,44 @@ export function lowerDestructuringDecl(lowerer, decl, isLet) {
     lowerer.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: init.type, loc }), init.type, isLet, out, dynSpell, parseArgsDynObject);
     return out;
 }
+/** `const { groups } = re.exec(s)!` / `const { groups: { year } } = m`
+ * — every pattern element binds `groups` off a match row whose regex is
+ * statically known. The slice (or a JavaScript callback's dynamic row)
+ * has no record shape of its own, so the groups projection
+ * (lowerGroupsProjection — the same record `m.groups` reads produce)
+ * wraps one level in a synthesized `{ groups: ... }` record and the
+ * ordinary record destructure serves the pattern — aliases and nested
+ * patterns included. Only named-group regexes take the wrap: a
+ * group-less regex destructures `groups: undefined` in Node (a nested
+ * pattern then throws), which the fence reports honestly instead. Null
+ * when the pattern or the row does not qualify. */
+export function matchGroupsPatternSource(lowerer, pattern, row, groupsOf, loc) {
+    if (!ts.isObjectBindingPattern(pattern) ||
+        pattern.elements.nodes.length === 0 ||
+        !(row.type.kind === "dyn"
+            ? isJsSourceFile(ts.getSourceFileOfNode(pattern))
+            : isMatchSliceType(lowerer, row.type)) ||
+        !pattern.elements.nodes.every((el) => {
+            if (el.dotDotDotToken !== undefined || el.name === undefined)
+                return false;
+            const prop = el.propertyName;
+            if (prop === undefined)
+                return ts.isIdentifier(el.name) && el.name.text === "groups";
+            return (ts.isIdentifier(prop) || ts.isStringLiteral(prop)) && prop.text === "groups";
+        }))
+        return null;
+    const groups = groupsOf();
+    if (groups === null || groups.length === 0)
+        return null;
+    const proj = lowerGroupsProjection(lowerer, row, groups, loc);
+    const outerShape = lowerer.shapes.intern([{ name: "groups", type: proj.type }], false, undefined, ["groups"]);
+    return {
+        kind: "recordLit",
+        fields: [{ name: "groups", value: proj }],
+        type: { kind: "record", shapeId: outerShape },
+        loc,
+    };
+}
 /** One pattern level: emits a declaration (or global assignment) per
  * bound name, recursing through hidden temps for nested patterns. */
 export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
@@ -1726,7 +2075,9 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         const patternType = lowerer.typeOf(pattern);
         const patternSymbol = patternType.getSymbol();
         allowDynObject ||=
-            patternSymbol?.name === "SegmentData" && lowerer.isStdlibSymbol(patternSymbol);
+            patternSymbol !== undefined &&
+                ts.symbolName(patternSymbol) === "SegmentData" &&
+                lowerer.isStdlibSymbol(patternSymbol);
         allowDynObject ||=
             (patternType.flags & ts.TypeFlags.Object) !== 0 &&
                 lowerer.mapTypeOf(patternType)?.kind === "dyn";
@@ -1740,17 +2091,22 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     if (ts.isArrayBindingPattern(pattern)) {
         lowerer.fenceStaticHeadersIteration(pattern);
         if (srcType.kind === "union" &&
-            lowerer.unions.get(srcType.unionId)?.arms.every((arm) => arm.kind === "array")) {
-            for (let i = 0; i < pattern.elements.length; i++) {
-                const el = pattern.elements[i];
+            lowerer.unions
+                .get(srcType.unionId)
+                ?.arms.every((arm) => arm.kind === "array" ||
+                arm.kind === "string" ||
+                (arm.kind === "record" && lowerer.shapes.get(arm.shapeId)?.tuple === true)) &&
+            lowerer.unions.get(srcType.unionId).arms.some((arm) => arm.kind !== "string")) {
+            for (let i = 0; i < pattern.elements.nodes.length; i++) {
+                const el = pattern.elements.nodes[i];
                 if (ts.isOmittedExpression(el) || el.name === undefined)
                     continue;
                 if (el.dotDotDotToken)
-                    lowerer.unsupported("SC1031", el, "rest elements over a union of array layouts");
+                    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);
+                let value = unionArrayValueRead(lowerer, srcRef(), numLit(i, loc), loc, (text) => strCharsCall(lowerer, text, loc));
                 if (!value)
-                    lowerer.unsupported("SC1031", el, "array union elements without a common native representation");
+                    lowerer.unsupported("SC1031", el, "array or tuple union elements without a common native representation");
                 if (el.initializer)
                     value = applyBindingDefault(lowerer, el, value);
                 lowerer.bindPatternTarget(el.name, value, isLet, out);
@@ -1761,7 +2117,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         // shape — the positional twin of object destructuring below.
         const tupleShape = srcType.kind === "record" ? lowerer.shapes.get(srcType.shapeId) : undefined;
         if (srcType.kind === "record" && tupleShape?.tuple) {
-            pattern.elements.forEach((el, i) => {
+            pattern.elements.nodes.forEach((el, i) => {
                 // Holes: OmittedExpression in 5.9.3, a nameless BindingElement in
                 // 7 (parity finding 2) — either way the position is skipped.
                 if (ts.isOmittedExpression(el) || el.name === undefined)
@@ -1828,7 +2184,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     loc,
                 });
                 const itRef = () => ({ kind: "varRef", localId: it.id, type: citPat.iterT, loc });
-                for (const el of pattern.elements) {
+                for (const el of pattern.elements.nodes) {
                     const stepLoc = locOf(el);
                     const step = lowerer.classIteratorNextCall(citPat, itRef(), stepLoc);
                     if (ts.isOmittedExpression(el) || el.name === undefined) {
@@ -1902,10 +2258,10 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             out.push({
                 kind: "varDecl",
                 localId: pack.id,
-                init: pattern.elements.some((element) => ts.isBindingElement(element) && element.dotDotDotToken)
+                init: pattern.elements.nodes.some((element) => ts.isBindingElement(element) && element.dotDotDotToken)
                     ? {
                         kind: "libCall",
-                        fn: "dyn.iterPack",
+                        fn: "dyn.destructureRest",
                         args: [srcRef(), { kind: "strLit", value: dynSpell ?? "", type: STRING, loc }],
                         type: DYN,
                         loc,
@@ -1913,14 +2269,14 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     : {
                         kind: "dynIterN",
                         value: srcRef(),
-                        count: pattern.elements.length,
+                        count: pattern.elements.nodes.length,
                         ...(dynSpell ? { notIterableMessage: dynSpell } : {}),
                         type: DYN,
                         loc,
                     },
                 loc,
             });
-            pattern.elements.forEach((el, i) => {
+            pattern.elements.nodes.forEach((el, i) => {
                 if (ts.isOmittedExpression(el) || el.name === undefined)
                     return; // hole: the position skips
                 const elLoc = locOf(el);
@@ -1976,7 +2332,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         // fresh number[] (never another typed array), exactly the iterator
         // protocol's Array accumulation.
         if (srcType.kind === "bytes") {
-            pattern.elements.forEach((el, i) => {
+            pattern.elements.nodes.forEach((el, i) => {
                 if (ts.isOmittedExpression(el) || el.name === undefined)
                     return;
                 const loc = locOf(el);
@@ -2018,10 +2374,30 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             });
             return;
         }
+        // Map and Set sources (`const [[k, v], ...rest] = map`): the iterator
+        // yields the collection's entries (Map pairs) or values in order, so
+        // the source snapshots ONCE into that array — the spread's own
+        // machinery — and the pattern lowers as an array pattern over it,
+        // like the string case above. Element defaults keep a fence: they
+        // run between iterator steps and could mutate the live collection.
+        if (srcType.kind === "map" || srcType.kind === "set") {
+            const defaulted = pattern.elements.nodes.find((el) => ts.isBindingElement(el) && el.initializer !== undefined && !el.dotDotDotToken);
+            if (defaulted)
+                lowerer.unsupported("SC1031", defaulted, "binding defaults over Map/Set sources");
+            const snapshot = lowerCollectionSpread(lowerer, srcRef(), pattern);
+            if (snapshot && snapshot.type.kind === "array") {
+                const loc = locOf(pattern);
+                const snapshotT = snapshot.type;
+                const entries = lowerer.declareHiddenLocal("%dentries", snapshotT);
+                out.push({ kind: "varDecl", localId: entries.id, init: snapshot, loc });
+                lowerer.lowerBindingPattern(pattern, () => ({ kind: "varRef", localId: entries.id, type: snapshotT, loc }), snapshotT, isLet, out);
+                return;
+            }
+        }
         if (srcType.kind !== "array") {
             lowerer.unsupported("SC1031", pattern, `array destructuring of non-array values (the source is ${srcType.kind}-typed)`);
         }
-        pattern.elements.forEach((el, i) => {
+        pattern.elements.nodes.forEach((el, i) => {
             if (ts.isOmittedExpression(el) || el.name === undefined)
                 return; // hole: position skipped, like JS over an array
             const loc = locOf(el);
@@ -2054,7 +2430,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         });
         return;
     }
-    if (pattern.elements.length === 0) {
+    if (pattern.elements.nodes.length === 0) {
         // `var {} = e`, `for (const {} of ns)`: RequireObjectCoercible and
         // nothing else — a pure no-op past the source's own evaluation for
         // every statically non-nullish kind, record or not (the assignment
@@ -2079,19 +2455,40 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // deliberately carried by the checked-dynamic tree, so their ordinary
     // object patterns use the same exact keyed-read desugar.
     if (srcType.kind === "union" &&
-        isJsSourceFile(pattern.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(pattern)) &&
         lowerer.dynConvertible(srcType)) {
         lowerer.lowerBindingPattern(pattern, () => lowerer.coerceToExpected(srcRef(), DYN), DYN, isLet, out, dynSpell, allowDynObject);
         return;
     }
     if (srcType.kind === "dyn") {
-        for (const el of pattern.elements) {
+        // A runtime computed first key evaluates after RequireObjectCoercible:
+        // a nullish source throws before the key's side effects run. Later
+        // keys follow a read that already threw.
+        if (ts.isObjectBindingPattern(pattern) && startsWithRuntimeKey(lowerer, pattern)) {
+            const loc = locOf(pattern);
+            for (const unit of ["null", "undefined"]) {
+                out.push({
+                    kind: "if",
+                    cond: { kind: "dynTest", test: unit, value: srcRef(), type: BOOL, loc },
+                    then: [
+                        {
+                            kind: "exprStmt",
+                            expr: nodeThrowExpr(1, "", `Cannot read properties of ${unit}`, VOID, loc),
+                            loc,
+                        },
+                    ],
+                    else_: null,
+                    loc,
+                });
+            }
+        }
+        for (const el of pattern.elements.nodes) {
             if (el.name === undefined)
                 continue;
             const loc = locOf(el);
             if (el.dotDotDotToken) {
                 const keys = [];
-                for (const sibling of pattern.elements) {
+                for (const sibling of pattern.elements.nodes) {
                     if (sibling === el || sibling.dotDotDotToken)
                         continue;
                     const key = sibling.propertyName ?? sibling.name;
@@ -2126,10 +2523,14 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                 ts.isNumericLiteral(prop)
                 ? patternKeyNameOf(lowerer, prop)
                 : null;
-            if (propName === null) {
+            // A runtime computed key (`{ [name]: v }`) reads the live property.
+            const runtimeRead = propName === null && ts.isComputedPropertyName(prop)
+                ? runtimeKeyPatternRead(lowerer, prop.expression, srcRef(), out, loc)
+                : null;
+            if (propName === null && runtimeRead === null) {
                 lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
             }
-            let value = {
+            let value = runtimeRead ?? {
                 kind: "dynKeyGet",
                 key: { kind: "strLit", value: propName, type: STRING, loc },
                 value: srcRef(),
@@ -2169,7 +2570,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         if (!info)
             lowerer.flushDeferredClass(srcType.className);
         if (info) {
-            for (const el of pattern.elements) {
+            for (const el of pattern.elements.nodes) {
                 if (el.name === undefined)
                     continue;
                 const loc = locOf(el);
@@ -2179,7 +2580,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
                     // CopyDataProperties copies own enumerable properties, which
                     // for a class instance are exactly the fields).
                     const consumed = new Set();
-                    for (const sib of pattern.elements) {
+                    for (const sib of pattern.elements.nodes) {
                         if (sib === el || sib.name === undefined || sib.dotDotDotToken)
                             continue;
                         const keyNode = sib.propertyName ?? (ts.isIdentifier(sib.name) ? sib.name : null);
@@ -2258,7 +2659,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // naming that. Callers vetted the source as a checker-typed string —
     // builtin identity tokens fence before reaching here.
     if (srcType.kind === "string") {
-        for (const el of pattern.elements) {
+        for (const el of pattern.elements.nodes) {
             if (el.name === undefined)
                 continue;
             const loc = locOf(el);
@@ -2294,6 +2695,21 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
         }
         return;
     }
+    if (srcType.kind === "array" &&
+        isMatchSliceType(lowerer, srcType) &&
+        isRegexMatchResultPattern(lowerer, pattern)) {
+        lowerMatchResultObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out);
+        return;
+    }
+    if (srcType.kind === "array" && isArrayPositionPattern(lowerer, pattern)) {
+        lowerArrayPositionObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out);
+        return;
+    }
+    const nsSource = lowerer.sourceFileOfModuleNamespace(srcType);
+    if (nsSource !== null) {
+        lowerModuleNamespacePattern(lowerer, pattern, nsSource, isLet, out);
+        return;
+    }
     if (srcType.kind !== "record") {
         lowerer.unsupported("SC1031", pattern, srcType.kind === "object"
             ? "object destructuring of class instances (read the fields directly — accessors make the desugar observable)"
@@ -2302,7 +2718,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     const shape = lowerer.shapes.get(srcType.shapeId);
     if (!shape)
         throw new InternalCompilerError(`lowerer bug: destructuring unknown shape ${srcType.shapeId}`);
-    for (const el of pattern.elements) {
+    for (const el of pattern.elements.nodes) {
         if (el.name === undefined)
             continue; // 7 spells elisions as nameless elements
         // `{ a, ...rest }`: the rest binds a FRESH record of the unconsumed
@@ -2325,7 +2741,18 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             ? patternKeyNameOf(lowerer, prop)
             : null;
         if (propName === null) {
-            lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
+            // A runtime computed key (`{ [name]: v }`): the keyed read of an
+            // index-signature entry, of the declared field a literal-union key
+            // names, or of a JavaScript record's live property.
+            const runtimeRead = ts.isComputedPropertyName(prop)
+                ? runtimeKeyPatternRead(lowerer, prop.expression, srcRef(), out, locOf(el))
+                : null;
+            if (runtimeRead === null) {
+                lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
+            }
+            const value = el.initializer ? applyBindingDefault(lowerer, el, runtimeRead) : runtimeRead;
+            lowerer.bindPatternTarget(el.name, value, isLet, out);
+            continue;
         }
         // An ACCESSOR property (%get:/%set: closure slots): the element's
         // read IS a getter call — once, at the element's pattern position
@@ -2376,18 +2803,19 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             // An UNDECLARED key of an INDEX-SIGNATURE shape (`const { m, n, p }
             // = ....groups` over `{ [key: string]: string }` — the groups
             // record, `Record<string, T>` tables generally): the overflow-map
-            // read, exactly the dot access's recordKeyGet — a missing key
-            // traps when the value type carries no undefined arm (the checker
-            // claimed V), or binds the undefined arm (where a default applies
-            // like any field's).
+            // read, exactly the dot access's recordKeyGet — a missing key binds
+            // the undefined arm (where a default applies like any field's).
             const loc = locOf(el);
+            const readType = shape.indexValue.kind === "dyn"
+                ? shape.indexValue
+                : (lowerer.withUndefinedArmOf(shape.indexValue) ?? shape.indexValue);
             let value = {
                 kind: "recordKeyGet",
                 obj: srcRef(),
                 shapeId: srcType.shapeId,
                 key: { kind: "strLit", value: propName, type: STRING, loc },
                 overflowOnly: true,
-                type: shape.indexValue,
+                type: readType,
                 loc,
             };
             if (el.initializer)
@@ -2395,7 +2823,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
             lowerer.bindPatternTarget(el.name, value, isLet, out);
             continue;
         }
-        if (!fieldType && isJsSourceFile(el.getSourceFile())) {
+        if (!fieldType && isJsSourceFile(ts.getSourceFileOfNode(el))) {
             // Inferred JavaScript shapes can omit optional own properties and
             // inherit values from their prototype. Read the live checked view.
             const loc = locOf(el);
@@ -2512,7 +2940,58 @@ function patternSourceValue(lowerer, value, arrayPattern, out, loc, spelling) {
 function patternBindingType(lowerer, name) {
     const type = lowerer.typeOf(name);
     return (lowerer.mapTypeOf(type) ??
-        (isJsSourceFile(name.getSourceFile()) ? dynFallbackType(lowerer, name, type) : null));
+        (isJsSourceFile(ts.getSourceFileOfNode(name)) ? dynFallbackType(lowerer, name, type) : null));
+}
+/** `const { a, b: c } = ns` / `const { f } = await import("./m")` over
+ * a program module's namespace: each element reads the export exactly
+ * like `ns.a` does — the member resolves to the exporter's own binding
+ * (nsMemberIdentOf's rule), read once at the pattern's position, so the
+ * bound name holds the export's value at that moment (destructuring
+ * copies; it does not alias the live binding). The namespace value
+ * itself was already evaluated into the pattern's temp, so its side
+ * effects (the dynamic import) keep their order. Rest elements would
+ * materialize the namespace object and keep their fence. The exports
+ * come from the source's module, not from the pattern's type: an
+ * annotation can name another module with a compatible shape. */
+function lowerModuleNamespacePattern(lowerer, pattern, source, isLet, out) {
+    const moduleSym = lowerer.checker.getSymbolAtLocation(source);
+    if (moduleSym === undefined) {
+        lowerer.unsupported("SC1031", pattern, "destructuring a module namespace without a module symbol");
+    }
+    const nsType = lowerer.checker.getTypeOfSymbol(moduleSym);
+    for (const el of pattern.elements.nodes) {
+        if (el.name === undefined)
+            continue;
+        if (el.dotDotDotToken) {
+            lowerer.unsupported("SC1031", el, "rest bindings over module namespaces (the namespace object is not materialized — bind the exports you need by name)");
+        }
+        const prop = el.propertyName ?? el.name;
+        const propName = ts.isIdentifier(prop) ||
+            ts.isComputedPropertyName(prop) ||
+            ts.isStringLiteralLike(prop) ||
+            ts.isNumericLiteral(prop)
+            ? patternKeyNameOf(lowerer, prop)
+            : null;
+        let exported = propName === null ? undefined : lowerer.checker.getPropertyOfType(nsType, propName);
+        if (exported !== undefined && exported.flags & ts.SymbolFlags.Alias) {
+            exported = lowerer.checker.getAliasedSymbol(exported);
+        }
+        const declared = exported?.valueDeclaration?.name;
+        if (declared === undefined || !ts.isIdentifier(declared)) {
+            lowerer.unsupported("SC1031", el, "destructuring module namespace members that are not named value exports");
+        }
+        let value = lowerer.lowerExpr(declared);
+        if (el.initializer)
+            value = applyBindingDefault(lowerer, el, value);
+        lowerer.bindPatternTarget(el.name, value, isLet, out);
+    }
+}
+/** Whether a pattern's first element has a computed key that does not
+ * fold to one property name, so the key evaluates at run time. */
+function startsWithRuntimeKey(lowerer, pattern) {
+    const first = pattern.elements.nodes[0];
+    const key = first?.dotDotDotToken === undefined ? first?.propertyName : undefined;
+    return (key !== undefined && ts.isComputedPropertyName(key) && patternKeyNameOf(lowerer, key) === null);
 }
 function patternKeyNameOf(lowerer, prop) {
     if (ts.isIdentifier(prop) || ts.isPrivateIdentifier(prop))
@@ -2529,6 +3008,140 @@ function patternKeyNameOf(lowerer, prop) {
     }
     return null;
 }
+/** True when an object pattern destructures a regex match result: the
+ * checker types its source as the standard library's RegExpExecArray or
+ * RegExpMatchArray. */
+function isRegexMatchResultPattern(lowerer, pattern) {
+    const parent = pattern.parent;
+    const source = ts.isVariableDeclaration(parent) && parent.initializer !== undefined
+        ? lowerer.typeOf(parent.initializer)
+        : lowerer.typeOf(pattern);
+    const type = lowerer.checker.getNonNullableType(source);
+    const symbol = type.getAliasSymbol() ?? type.getSymbol();
+    return (symbol !== undefined &&
+        (ts.symbolName(symbol) === "RegExpExecArray" || ts.symbolName(symbol) === "RegExpMatchArray") &&
+        lowerer.isStdlibSymbol(symbol));
+}
+/** `const { 0: whole, 1: first, index, input, groups } = re.exec(s)!`: an
+ * object pattern over a regex match result. The result is an honest
+ * string[] slice whose `index` and `input` are the special-form reads that
+ * `m.index` and `m.input` lower to; numeric keys are the positional reads
+ * of the equivalent array pattern, and `groups` is the projection `m.groups`
+ * builds when the regex is statically known. Rest elements, defaults on
+ * the special properties, and every other key keep a named fence. */
+function lowerMatchResultObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out) {
+    let groups;
+    for (const el of pattern.elements.nodes) {
+        if (el.name === undefined)
+            continue;
+        const loc = locOf(el);
+        if (el.dotDotDotToken) {
+            lowerer.unsupported("SC1031", el, "rest bindings over regex match results (the rest copies the positions and the index, input and groups properties — destructure them by name)");
+        }
+        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) {
+            lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
+        }
+        let value;
+        if (ARRAY_POSITION_KEY.test(propName)) {
+            value = arrayPositionBinding(lowerer, el, srcRef, srcType, Number(propName), out);
+        }
+        else if (propName === "index" || propName === "input") {
+            if (el.initializer) {
+                lowerer.unsupported("SC1031", el, `binding defaults on the '${propName}' of a regex match result`);
+            }
+            value = lowerer.maybeNarrow({
+                kind: "dynKeyGet",
+                value: lowerer.coerceToExpected(srcRef(), DYN),
+                key: { kind: "strLit", value: propName, type: STRING, loc },
+                type: DYN,
+                loc,
+            }, el.name);
+        }
+        else if (propName === "groups") {
+            if (groups === undefined) {
+                const parent = pattern.parent;
+                groups =
+                    ts.isVariableDeclaration(parent) && parent.initializer !== undefined
+                        ? matchResultNamedGroupsOf(lowerer, parent.initializer)
+                        : null;
+            }
+            if (groups === null || groups.length === 0 || el.initializer) {
+                lowerer.unsupported("SC1031", el, "destructuring 'groups' from this regex match result (it lowers when the regex is statically known and has named groups, without a default)");
+            }
+            value = lowerGroupsProjection(lowerer, srcRef(), groups, loc);
+        }
+        else {
+            lowerer.unsupported("SC1031", el, `destructuring the property '${propName}' of a regex match result (numeric positions, index, input and groups compile)`);
+        }
+        lowerer.bindPatternTarget(el.name, value, isLet, out);
+    }
+}
+/** A canonical array index key (the numeric positions an object pattern
+ * reads off an array). */
+const ARRAY_POSITION_KEY = /^(?:0|[1-9]\d{0,8})$/;
+/** The positional read `{ <index>: x }` takes off an array: the element,
+ * undefined past the end, with the binding default applied. */
+function arrayPositionBinding(lowerer, el, srcRef, srcType, index, out) {
+    const loc = locOf(el);
+    const position = { kind: "numLit", value: index, type: F64, loc };
+    const value = lowerSafeIndexRead(lowerer, srcRef(), position, loc) ?? {
+        kind: "arrayGet",
+        arr: srcRef(),
+        index: position,
+        type: srcType.elem,
+        loc,
+    };
+    return el.initializer
+        ? arrayPositionDefault(lowerer, el, value, srcRef, index, srcType.elem, out)
+        : value;
+}
+/** Whether every element of an object pattern over an array names a
+ * numeric position or `length` (`const { 0: a, 1: b, length } =
+ * s.split(".")`), with no rest element. */
+function isArrayPositionPattern(lowerer, pattern) {
+    return pattern.elements.nodes.every((el) => {
+        if (el.name === undefined)
+            return true;
+        if (el.dotDotDotToken)
+            return false;
+        const prop = el.propertyName ?? el.name;
+        if (!ts.isIdentifier(prop) &&
+            !ts.isComputedPropertyName(prop) &&
+            !ts.isStringLiteralLike(prop) &&
+            !ts.isNumericLiteral(prop))
+            return false;
+        const name = patternKeyNameOf(lowerer, prop);
+        return name !== null && (name === "length" || ARRAY_POSITION_KEY.test(name));
+    });
+}
+/** An object pattern of positions and `length` over an array: each
+ * position is the read the equivalent array pattern makes, and `length`
+ * the array's length (always present, so its default never runs). */
+function lowerArrayPositionObjectPattern(lowerer, pattern, srcRef, srcType, isLet, out) {
+    for (const el of pattern.elements.nodes) {
+        if (el.name === undefined)
+            continue;
+        const name = patternKeyNameOf(lowerer, (el.propertyName ?? el.name));
+        const value = name === "length"
+            ? {
+                kind: "arrIntrinsic",
+                method: "length",
+                receiver: srcRef(),
+                args: [],
+                type: F64,
+                loc: locOf(el),
+            }
+            : arrayPositionBinding(lowerer, el, srcRef, srcType, Number(name), out);
+        lowerer.bindPatternTarget(el.name, value, isLet, out);
+    }
+}
 /** Decode one non-rest object-assignment property into its static source
  * field, destination expression, and optional default initializer. */
 function destructuringPropertyOf(lowerer, prop) {
@@ -2572,7 +3185,7 @@ function checkerStringSource(lowerer, e) {
 }
 function staticStringPattern(lowerer, pattern) {
     if (ts.isArrayBindingPattern(pattern)) {
-        return pattern.elements.every((el) => {
+        return pattern.elements.nodes.every((el) => {
             if (ts.isOmittedExpression(el) || el.name === undefined)
                 return true;
             if (el.dotDotDotToken) {
@@ -2586,7 +3199,7 @@ function staticStringPattern(lowerer, pattern) {
             return staticStringPattern(lowerer, el.name);
         });
     }
-    return pattern.elements.every((el) => {
+    return pattern.elements.nodes.every((el) => {
         if (el.name === undefined)
             return true;
         if (el.dotDotDotToken || !ts.isIdentifier(el.name))
@@ -2652,7 +3265,7 @@ const CONSOLE_CALL_MEMBERS = new Set([
  * when the source is not a stdlib global at all, or in TypeScript
  * files (the identifier chokepoint fences the global there first). */
 function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
-    if (decl.initializer === undefined || !isJsSourceFile(decl.getSourceFile()))
+    if (decl.initializer === undefined || !isJsSourceFile(ts.getSourceFileOfNode(decl)))
         return null;
     const globalName = stdlibGlobalNameOf(lowerer, decl.initializer);
     if (globalName === null)
@@ -2665,7 +3278,7 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
     }
     const srcT = lowerer.typeOf(decl.initializer);
     const binds = [];
-    for (const el of decl.name.elements) {
+    for (const el of decl.name.elements.nodes) {
         if (el.name === undefined)
             continue;
         if (el.dotDotDotToken) {
@@ -2687,8 +3300,9 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
         if (propName === null) {
             lowerer.unsupported("SC1031", el, "destructuring with computed keys that do not fold to one property name");
         }
-        let token;
+        let token = "";
         let alias = null;
+        let value = null;
         if (globalName === "globalThis") {
             // The member must BE a stdlib global (user script vars are
             // properties of `typeof globalThis` too — their values are real
@@ -2697,9 +3311,12 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             if (member === undefined || !lowerer.isStdlibSymbol(member)) {
                 lowerer.unsupported("SC1031", el, `destructuring the non-builtin member '${propName}' of 'globalThis'`);
             }
-            const canonical = member.name === "global" ? "globalThis" : member.name;
+            const canonical = ts.symbolName(member) === "global" ? "globalThis" : ts.symbolName(member);
             token = `[builtin ${canonical}]`;
             alias = canonical;
+            // Builtin constructors read as their interned function values, the
+            // same values the bare and `globalThis.X` spellings read.
+            value = builtinGlobalValue(canonical, locOf(el), true);
         }
         else if (globalName === "console" && !CONSOLE_CALL_MEMBERS.has(propName)) {
             token = `[builtin console.${propName}]`;
@@ -2707,6 +3324,12 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
         else if (TOKEN_OPAQUE_GLOBALS.has(globalName)) {
             token = `[builtin ${globalName}.${propName}]`;
         }
+        else if (globalName === "process" &&
+            ts.isIdentifier(el.name) &&
+            (value = processDataMemberValue(lowerer, propName, el.name, locOf(el))) !== null) {
+            // A data member reads its value once, exactly like the spelled
+            // `process.<member>` read the destructuring performs.
+        }
         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)`);
         }
@@ -2715,6 +3338,10 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
             lowerer.unsupported("SC1031", el, `bindings with predeclared slots over the builtin global '${globalName}'`);
         }
         const g = lowerer.globalsBySymbol.get(symbol);
+        if (value !== null) {
+            binds.push({ name: el.name, token, alias, g, value });
+            continue;
+        }
         if (g !== undefined && g.type.kind !== "string" && g.type.kind !== "dyn") {
             lowerer.unsupported("SC1031", el, `bindings with '${lowerer.fmt(g.type)}' storage over the builtin global '${globalName}'`);
         }
@@ -2723,6 +3350,27 @@ function stdlibGlobalTokenDestructure(lowerer, decl, isLet) {
     const out = [];
     for (const b of binds) {
         const loc = locOf(b.name);
+        if (b.value !== undefined && b.alias !== null) {
+            const symbol = lowerer.checker.getSymbolAtLocation(b.name);
+            if (symbol)
+                lowerer.stdlibGlobalAliases.set(symbol, b.alias);
+        }
+        if (b.value !== undefined) {
+            if (b.g !== undefined) {
+                out.push({
+                    kind: "assign",
+                    localId: b.g.id,
+                    value: lowerer.coerceInto(b.name, b.value, b.g.type),
+                    ...(b.g.tdz ? { initializes: true } : {}),
+                    loc,
+                });
+            }
+            else {
+                const local = lowerer.declareLocal(b.name, b.name.text, b.value.type, isLet);
+                out.push({ kind: "varDecl", localId: local.id, init: b.value, loc });
+            }
+            continue;
+        }
         const token = { kind: "strLit", value: b.token, type: STRING, loc };
         if (b.alias !== null) {
             const symbol = lowerer.checker.getSymbolAtLocation(b.name);
@@ -3004,7 +3652,7 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
         const consumed = new Set();
         let computedSibling = false;
         if (ts.isObjectBindingPattern(pattern)) {
-            for (const sib of pattern.elements) {
+            for (const sib of pattern.elements.nodes) {
                 if (sib === el || sib.dotDotDotToken)
                     continue;
                 const key = sib.propertyName ?? sib.name;
@@ -3071,7 +3719,7 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
             value: lowerer.presenceKeepingCopy(srcRef(), srcType.shapeId, srcField.name, lowerer.coerceInto(el, read, f.type), loc),
         };
     });
-    return { kind: "recordLit", fields, type: restT, loc };
+    return lowerer.keyOrder.copy({ kind: "recordLit", fields, type: restT, loc }, srcType.shapeId);
 }
 /** The fresh record for `{ a, ...rest }` over a CLASS-INSTANCE source:
  * JS's CopyDataProperties copies the OWN ENUMERABLE properties — the
@@ -3125,7 +3773,7 @@ function classInstanceRestValue(lowerer, blame, srcRef, srcType, info, consumed,
     const orderMatches = (order) => order.length === remaining.length && order.every((n, i) => n === remaining[i].name);
     const deferOrderCheck = lowerer.instantiationContext !== null &&
         lowerer.onEdge !== null &&
-        !isJsSourceFile(blame.getSourceFile());
+        !isJsSourceFile(ts.getSourceFileOfNode(blame));
     if (!deferOrderCheck) {
         if (!orderMatches(emitOrder)) {
             lowerer.unsupported("SC1031", blame, "rest bindings over class instances whose packed key order cannot match Node's (Object.keys/JSON.stringify would enumerate the copied fields in a different order)");
@@ -3140,7 +3788,7 @@ function classInstanceRestValue(lowerer, blame, srcRef, srcType, info, consumed,
         // matters.
         const context = lowerer.instantiationContext;
         const countFailure = !lowerer.suppressStats;
-        const sf = blame.getSourceFile();
+        const sf = ts.getSourceFileOfNode(blame);
         lowerer.shapeOrderMetadataFinalizers.push(() => {
             const current = lowerer.shapes.get(restT.shapeId) ?? restShape;
             const currentOrder = current.declaredOrder ?? current.fields.map((f) => f.name);
@@ -3188,6 +3836,8 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
         const symbol = lowerer.checker.getSymbolAtLocation(name);
         const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
         if (g) {
+            if (value.type.kind === "dyn" && jsBindingKeepsCheckedObject(lowerer, name, g.type))
+                g.type = DYN;
             out.push({
                 kind: "assign",
                 localId: g.id,
@@ -3204,7 +3854,7 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
         // here by declareParams) carry no block-scope flag either, but their
         // bindings are the parameters' own.
         if (symbol && hostVariableDeclarationOf(name) !== null && isVarDeclared(name)) {
-            const hoisted = hoistVarBinding(lowerer, symbol, name);
+            const hoisted = hoistVarBinding(lowerer, symbol, name, value.type);
             out.push({
                 kind: "assign",
                 localId: hoisted.id,
@@ -3218,7 +3868,7 @@ export function bindPatternTarget(lowerer, name, value, isLet, out, allowDynObje
         const dynStays = value.type.kind === "dyn" &&
             (() => {
                 const mapped = lowerer.mapTypeOf(lowerer.typeOf(name));
-                return mapped === null;
+                return mapped === null || jsBindingKeepsCheckedObject(lowerer, name, mapped);
             })();
         let type = dynStays
             ? DYN
@@ -3269,7 +3919,7 @@ export function lowerVarDeclList(lowerer, list) {
     const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0;
     if (!isConst && !isLet) {
-        const out = list.declarations.flatMap((decl) => {
+        const out = list.declarations.nodes.flatMap((decl) => {
             // `for (var {} = {}, [a] = xs; ...)`: pattern declarators ride the
             // declaration desugar (var names assign their hoisted slots).
             if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
@@ -3285,7 +3935,7 @@ export function lowerVarDeclList(lowerer, list) {
         return { kind: "block", body: out, loc: locOf(list) };
     }
     const out = [];
-    for (const decl of list.declarations) {
+    for (const decl of list.declarations.nodes) {
         if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
             // Destructuring produces nested initialization blocks; copying
             // their captured bindings still needs a distinct head-scope plan.
@@ -3298,6 +3948,69 @@ export function lowerVarDeclList(lowerer, list) {
     }
     return out.length === 1 ? out[0] : { kind: "block", body: out, loc: locOf(list) };
 }
+/** The type of an unannotated TypeScript binding initialized with `[]`
+ * whose element type evolves: the checker types the declaration as
+ * `never[]` or `any[]` and each later read by the elements written before
+ * it, and reads inside closures as the unsettled array. When every read
+ * with a settled element type maps to the same array type, the binding has
+ * that type. When reads disagree or the binding is reassigned, it is
+ * checked-dynamic, as the same binding is at module scope. Null for other
+ * bindings. */
+function evolvingArrayType(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name) || decl.initializer === undefined)
+        return null;
+    let initializer = decl.initializer;
+    while (ts.isParenthesizedExpression(initializer))
+        initializer = initializer.expression;
+    if (!ts.isArrayLiteralExpression(initializer) || initializer.elements.nodes.length !== 0)
+        return null;
+    const unsettled = (t) => {
+        if (!lowerer.checker.isArrayType(t))
+            return false;
+        const elem = lowerer.checker.getTypeArguments(t)[0];
+        return elem !== undefined && (elem.flags & (ts.TypeFlags.Never | ts.TypeFlags.Any)) !== 0;
+    };
+    if (!unsettled(lowerer.typeOf(decl.name)))
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    if (symbol === undefined)
+        return null;
+    const owner = (node) => {
+        let n = node.parent;
+        while (n !== undefined && !ts.isFunctionLike(n) && !ts.isSourceFile(n))
+            n = n.parent;
+        return n ?? ts.getSourceFileOfNode(node);
+    };
+    const scope = owner(decl);
+    let result = null;
+    // The file's identifiers are indexed by name once (identifiersNamed), so
+    // each binding resolves only the uses spelled like it.
+    for (const node of identifiersNamed(lowerer, ts.getSourceFileOfNode(decl), decl.name.text)) {
+        if (node === decl.name ||
+            node.pos < scope.pos ||
+            node.end > scope.end ||
+            lowerer.checker.getSymbolAtLocation(node) !== symbol)
+            continue;
+        let target = node;
+        while (ts.isParenthesizedExpression(target.parent))
+            target = target.parent;
+        const parent = target.parent;
+        const reassigned = ts.isBinaryExpression(parent) &&
+            parent.left === target &&
+            parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
+        if (reassigned)
+            return DYN;
+        const t = lowerer.typeOf(node);
+        if (unsettled(t))
+            continue;
+        const mapped = lowerer.mapTypeOf(t);
+        if (!mapped || mapped.kind !== "array" || (result !== null && !typeEquals(result, mapped)))
+            return DYN;
+        result = mapped;
+    }
+    return result ?? DYN;
+}
 /** 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
@@ -3355,7 +4068,7 @@ function inferredEvolvingLetType(lowerer, decl) {
                 }
                 if (ts.isCallExpression(node.right) &&
                     (implicitMethodCallInfersReturn(lowerer, node.right) ||
-                        isJsSourceFile(node.right.getSourceFile()))) {
+                        isJsSourceFile(ts.getSourceFileOfNode(node.right)))) {
                     invalid = true;
                     return "stop";
                 }
@@ -3426,6 +4139,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     }
     if (!ts.isIdentifier(decl.name))
         lowerer.unsupported("SC1031", decl.name);
+    {
+        const alias = lowerTupleAliasDecl(lowerer, decl);
+        if (alias)
+            return alias;
+    }
     // A NULLISH generic binding (`const i: I<A & B> = null as any` — the
     // declared type has no mapping, the value is provably null/undefined
     // forever): no storage exists; reads know the value (member reads and
@@ -3456,10 +4174,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         (decl.name.text === "module" || decl.name.text === "exports") &&
         ts.isVariableStatement(decl.parent?.parent) &&
         ts.isSourceFile(decl.parent?.parent?.parent) &&
-        !isJsSourceFile(decl.getSourceFile()) &&
-        !decl
-            .getSourceFile()
-            .statements.some((s) => ts.isImportDeclaration(s) ||
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+        !ts
+            .getSourceFileOfNode(decl)
+            .statements.nodes.some((s) => ts.isImportDeclaration(s) ||
             ts.isExportDeclaration(s) ||
             ts.isExportAssignment(s) ||
             (ts.canHaveModifiers(s) &&
@@ -3508,6 +4226,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // `const process = globalThis.process` — a stdlib-global snapshot:
     // alias plumbing (see stdlibGlobalAliasDecl), no storage, no code.
     const stableStdlibAlias = !isLet ||
+        stdlibBufferVarAlias(lowerer, decl) ||
         (ts.isVariableDeclarationList(decl.parent) &&
             (decl.parent.flags & ts.NodeFlags.Let) !== 0 &&
             ts.isIdentifier(decl.name) &&
@@ -3547,6 +4266,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         return null;
     if (!isLet && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer))
         return null;
+    if (registerBuiltinClassAlias(lowerer, decl.name, decl.initializer))
+        return null;
     // `const knownBy = (cmd) => ...` — an IMPLICIT-ANY function-value
     // binding in npm-static JS (function-scope bindings register here, in
     // source order before any use can lower; file-scope ones registered at
@@ -3631,17 +4352,25 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                 return { kind: "assign", localId: g.id, value: wrapped, loc: locOf(decl) };
             return null;
         }
-        const raw = lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" &&
-            (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
-                ts.isArrayLiteralExpression(decl.initializer) ||
-                ts.isObjectLiteralExpression(decl.initializer))
-            ? DYN
-            : undefined);
-        if (isJsSourceFile(decl.getSourceFile()) &&
+        const guardedRead = isGuardedRecordRead(lowerer, decl)
+            ? lowerAbsenceProbe(lowerer, decl.initializer)
+            : null;
+        const raw = guardedRead ??
+            lowerVariableInitializer(lowerer, decl.initializer, g.type.kind === "dyn" &&
+                (isNativeBuiltinValueInitializer(lowerer, decl.initializer) ||
+                    ts.isArrayLiteralExpression(decl.initializer) ||
+                    ts.isObjectLiteralExpression(decl.initializer))
+                ? DYN
+                : undefined);
+        if (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             !hasJsTypeAnnotation(decl) &&
             raw.type.kind === "dyn" &&
-            (g.type.kind === "record" || g.type.kind === "object"))
+            (g.type.kind === "record" ||
+                g.type.kind === "object" ||
+                (ts.isIdentifier(decl.name) &&
+                    jsBindingKeepsCheckedObject(lowerer, decl.name, g.type) &&
+                    (existingValueForm(decl.initializer) || jsHoldsDynObject(lowerer, decl.initializer)))))
             g.type = DYN;
         g.type = inferredOptionalRecordType(lowerer, decl, g.type, raw.type);
         const arithmetic = raw.type.kind === "union" ? lowerer.unions.get(raw.type.unionId)?.arms : undefined;
@@ -3682,6 +4411,9 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // types already hold the interned undefined arm), and a declaration
     // re-run in a loop must not reset the persisting value.
     if (isVarDeclared(decl) && declSymbol) {
+        const fromExisting = lowerJsVarFromExisting(lowerer, decl, declSymbol);
+        if (fromExisting)
+            return fromExisting;
         const local = hoistVarBinding(lowerer, declSymbol, decl.name);
         if (!decl.initializer)
             return null;
@@ -3697,7 +4429,7 @@ 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())) {
+        if (type.kind === "dyn" && isLet && isJsSourceFile(ts.getSourceFileOfNode(decl))) {
             type = inferredEvolvingLetType(lowerer, decl) ?? type;
         }
         // `var v: void;` / `let x: undefined;` — a unit-only binding rides
@@ -3721,7 +4453,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // function (with its hint), not the unmappable declared type. If it
     // poisons, still declare the local when its type is representable, so
     // later references to this name don't produce cascading errors.
-    const inferredObjectType = isJsSourceFile(decl.getSourceFile())
+    const inferredObjectType = isJsSourceFile(ts.getSourceFileOfNode(decl))
         ? lowerer.mapTypeOf(lowerer.typeOf(decl.name))
         : null;
     const inferredObjectArms = inferredObjectType?.kind === "union"
@@ -3734,11 +4466,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         inferredObjectType !== null &&
         jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind === "dyn") ||
         inferredObjectArms.some((arm) => arm.kind === "record" && jsObjectBindingExpands(lowerer, decl, arm)) ||
-        (isJsSourceFile(decl.getSourceFile()) &&
+        (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             !hasJsTypeAnnotation(decl) &&
             ts.isObjectLiteralExpression(decl.initializer) &&
-            decl.initializer.properties.some((property) => ts.isMethodDeclaration(property) ||
+            decl.initializer.properties.nodes.some((property) => ts.isMethodDeclaration(property) ||
                 ts.isAccessor(property) ||
                 (ts.isPropertyAssignment(property) &&
                     (ts.isFunctionExpression(property.initializer) ||
@@ -3747,7 +4479,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     try {
         init =
             expandsObject ||
-                (isJsSourceFile(decl.getSourceFile()) &&
+                (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                     !decl.type &&
                     isNativeBuiltinValueInitializer(lowerer, decl.initializer))
                 ? lowerer.lowerExprExpecting(decl.initializer, DYN)
@@ -3779,11 +4511,22 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         staticImportNamespaceType(lowerer, decl.initializer) ??
         (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
-    if (isJsSourceFile(decl.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !decl.type &&
         !hasJsTypeAnnotation(decl) &&
         init.type.kind === "func")
         type = init.type;
+    // Promise.prototype is an ordinary object the checker types Promise<any>.
+    if (!decl.type && !hasJsTypeAnnotation(decl) && isPromisePrototypeRead(lowerer, decl.initializer))
+        type = DYN;
+    // A typed-arguments function expression (typed-arguments.ts): the
+    // checker types the binding variadic, but its value has the fixed
+    // signature every use asserts.
+    if (!decl.type &&
+        init.type.kind === "func" &&
+        (lowerer.typedArgumentsLambdas.has(stripTypeWrappers(decl.initializer)) ||
+            lowerer.nullishFuncResults.has(stripTypeWrappers(decl.initializer))))
+        type = init.type;
     // A TypeScript lambda whose closure returns the runtime result (a missing
     // read, a `??` default of another type) instead of the checker's bare
     // return type: the binding keeps the checker's parameters and takes the
@@ -3796,24 +4539,24 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         type = { ...type, ret: init.type.ret };
     if (lowerer.implicitParamTypes !== null &&
         init.type.kind === "dyn" &&
-        isJsSourceFile(decl.getSourceFile()) &&
-        npmStaticPackageOfPath(decl.getSourceFile().fileName) !== null) {
+        isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+        npmStaticPackageOfPath(ts.getSourceFileOfNode(decl).fileName) !== null) {
         type = DYN;
     }
     const preservesObjectIdentity = init.type.kind === "dyn" &&
         (inferredObjectType?.kind === "record" ||
             inferredObjectType?.kind === "array" ||
-            (isJsSourceFile(decl.getSourceFile()) &&
+            (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 inferredObjectArms.some((arm) => arm.kind === "record") &&
                 inferredObjectArms.every((arm) => isUnitType(arm) || arm.kind === "record")) ||
-            (isJsSourceFile(decl.getSourceFile()) &&
+            (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 inferredObjectType !== null &&
                 (inferredObjectType.kind === "date" ||
                     inferredObjectType.kind === "func" ||
                     inferredObjectType.kind === "object" ||
                     jsOpenObjectType(decl, inferredObjectType, lowerer.shapes, lowerer.unions).kind ===
                         "dyn")) ||
-            (isJsSourceFile(decl.getSourceFile()) &&
+            (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
                 inferredObjectType !== null &&
                 (inferredObjectType.kind === "void" ||
                     isUnitType(inferredObjectType) ||
@@ -3821,14 +4564,20 @@ export function lowerVarDecl(lowerer, decl, isLet) {
                         lowerer.unions.get(inferredObjectType.unionId)?.arms.every(isUnitType))))) &&
         !decl.type &&
         !hasJsTypeAnnotation(decl);
+    // The binding of an assertion of the global object holds that object,
+    // whatever its asserted type (assertion-identity.ts).
+    const keepsAssertedObject = init.type.kind === "dyn" &&
+        !decl.type &&
+        keptIdentityAssertion(lowerer, decl.initializer) !== undefined;
     if (expandsObject ||
         preservesObjectIdentity ||
-        (isJsSourceFile(decl.getSourceFile()) &&
+        keepsAssertedObject ||
+        (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             !decl.type &&
             isNativeBuiltinValueInitializer(lowerer, decl.initializer))) {
         type = DYN;
     }
-    if (isJsSourceFile(decl.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !decl.type &&
         init.type.kind === "array" &&
         init.type.elem.kind === "dyn" &&
@@ -3843,14 +4592,14 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // cannot hold the binding's future. The binding is checked-dynamic
     // instead (irTypeOf's JS story): writes dynFrom, typed exits dynCheck.
     // Const keeps the static empty record — no reassignment exists.
-    if (isLet && type?.kind === "record" && isJsSourceFile(decl.getSourceFile())) {
+    if (isLet && type?.kind === "record" && isJsSourceFile(ts.getSourceFileOfNode(decl))) {
         const shape = lowerer.shapes.get(type.shapeId);
         if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
             type = DYN;
     }
     if (isLet &&
         type !== null &&
-        isJsSourceFile(decl.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !decl.type &&
         !hasJsTypeAnnotation(decl) &&
         (type.kind === "object" || type.kind === "symbol" || jsBindingHasOpenWrites(lowerer, decl))) {
@@ -3872,11 +4621,11 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // exits dynCheck.
     if (returnedEmptyArrayType === null &&
         (type === null || type.kind === "array") &&
-        isJsSourceFile(decl.getSourceFile())) {
+        isJsSourceFile(ts.getSourceFileOfNode(decl))) {
         let initExpr = decl.initializer;
         while (ts.isParenthesizedExpression(initExpr))
             initExpr = initExpr.expression;
-        if (ts.isArrayLiteralExpression(initExpr) && initExpr.elements.length === 0) {
+        if (ts.isArrayLiteralExpression(initExpr) && initExpr.elements.nodes.length === 0) {
             const t = lowerer.typeOf(decl.name);
             if (lowerer.checker.isArrayType(t)) {
                 const elem = lowerer.checker.getTypeArguments(t)[0];
@@ -3885,6 +4634,17 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             }
         }
     }
+    // A TypeScript `const nodes = [];` filled by later writes: the checker
+    // types each read by the elements written before it (evolvingArrayType).
+    if (returnedEmptyArrayType === null &&
+        !decl.type &&
+        !isJsSourceFile(ts.getSourceFileOfNode(decl))) {
+        const evolved = evolvingArrayType(lowerer, decl);
+        if (evolved !== null) {
+            type = evolved;
+            init = lowerer.lowerExprExpecting(decl.initializer, evolved);
+        }
+    }
     // An unannotated binding holding an OOB-SAFE indexed read (`elem |
     // undefined`) where the checker spells the bare element: the binding
     // adopts the runtime-honest union. This covers both inferred package JS
@@ -3928,14 +4688,14 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // boxed thunk's JS arity instead.
     if (type?.kind === "func" &&
         init.type.kind === "dyn" &&
-        (isJsSourceFile(decl.getSourceFile()) ||
+        (isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
             (!decl.type &&
                 !hasJsTypeAnnotation(decl) &&
                 type.rest === true &&
                 type.restAbi === undefined))) {
         type = DYN;
     }
-    if (isJsSourceFile(decl.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !decl.type &&
         !hasJsTypeAnnotation(decl) &&
         init.type.kind === "dyn" &&
@@ -3952,7 +4712,28 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // `let` may be reassigned a different shape later; genuine `any`
     // only — every other unmappable keeps its own diagnostic.
     const checkerAny = (lowerer.typeOf(decl.name).flags & ts.TypeFlags.Any) !== 0;
-    if ((type === null || (type.kind === "dyn" && checkerAny)) &&
+    // An annotation the checker could not resolve (a package type alias that
+    // reads as `any`) over an empty object literal: the binding is a
+    // dictionary the code fills by key (`files[name] = entry`), which the
+    // empty struct the literal would adopt cannot hold. It holds the
+    // checked-dynamic object instead.
+    let emptyAnyDictionary = false;
+    if (checkerAny && decl.type && !isLet && init.type.kind === "record") {
+        let lit = decl.initializer;
+        while (ts.isParenthesizedExpression(lit))
+            lit = lit.expression;
+        const shape = lowerer.shapes.get(init.type.shapeId);
+        if (ts.isObjectLiteralExpression(lit) &&
+            lit.properties.nodes.length === 0 &&
+            shape &&
+            shape.fields.length === 0 &&
+            !shape.indexValue) {
+            type = DYN;
+            emptyAnyDictionary = true;
+        }
+    }
+    if (!emptyAnyDictionary &&
+        (type === null || (type.kind === "dyn" && checkerAny)) &&
         !isLet &&
         (checkerAny ||
             (lowerer.checkerAnyArray(decl.name) && lowerer.isArrayValueType(init.type)) ||
@@ -3960,12 +4741,16 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             // 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.
-            (type === null && isJsSourceFile(decl.getSourceFile()))) &&
+            (type === null && isJsSourceFile(ts.getSourceFileOfNode(decl)))) &&
         init.type.kind !== "void" &&
         init.type.kind !== "caught" &&
         !isUnitType(init.type)) {
         type = init.type;
     }
+    // `const B = factory(1)` inside a generic instance: the factory's local
+    // class for the instance the call names.
+    if (!type && !isLet)
+        type = genericLocalClassBinding(lowerer, decl.name);
     if (!type) {
         // The JS declaration fallback (irTypeOf's story): the binding holds
         // the checked-dynamic kind when even the initializer's type has no
@@ -3978,7 +4763,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         lowerer.badType(decl.name, lowerer.typeOf(decl.name));
     let settledType = type;
     if (!isLet &&
-        isJsSourceFile(decl.getSourceFile()) &&
+        isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
         !hasJsTypeAnnotation(decl) &&
         decl.initializer &&
         ts.isNewExpression(decl.initializer)) {
@@ -4013,7 +4798,7 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         ? npmStaticOptionalSelfWriteType(lowerer, decl, settledType)
         : null;
     settledType =
-        expandsObject || preservesObjectIdentity
+        expandsObject || preservesObjectIdentity || keepsAssertedObject
             ? DYN
             : lowerer.runtimeOptionalBindingType(decl.name, settledType);
     if (optionalSelfWriteType !== null)
@@ -4076,6 +4861,21 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             settledType = init.type;
         }
     }
+    // `const view = route as Route & { order: number }`: the asserted type
+    // refines the record arms the value is stored in (the assertion keeps
+    // that value, see hosted-narrowing.ts). The binding keeps the stored
+    // type, so writes through it reach the asserted object. An annotation
+    // the stored type hosts (`const view: Route & { order: number } = ...`)
+    // keeps it too: coercing into the annotated layout would copy the
+    // value and read members the writes have not created yet.
+    if (!isLet &&
+        decl.initializer &&
+        isAssertionInitializer(decl.initializer) &&
+        (settledType.kind === "union" || settledType.kind === "record") &&
+        (init.type.kind === "union" || init.type.kind === "record") &&
+        hostsAll(lowerer, init.type, settledType)) {
+        settledType = init.type;
+    }
     // An exact class behind a generic interface keeps its native
     // representation so generic calls can specialize against its body.
     if ((settledType.kind === "record" || settledType.kind === "dyn") &&
@@ -4176,7 +4976,7 @@ function lowerVariableInitializer(lowerer, node, expected) {
     if (expected?.kind === "dyn")
         return lowerDynObjectLiteral(lowerer, value);
     const previous = new Map();
-    for (const property of value.properties) {
+    for (const property of value.properties.nodes) {
         if (!ts.isPropertyAssignment(property) || !ts.isComputedPropertyName(property.name))
             continue;
         const keyNode = property.name.expression;
@@ -4205,7 +5005,7 @@ function jsObjectBindingExpands(lowerer, decl, type) {
     if (decl.type ||
         !decl.initializer ||
         !ts.isIdentifier(decl.name) ||
-        !isJsSourceFile(decl.getSourceFile()))
+        !isJsSourceFile(ts.getSourceFileOfNode(decl)))
         return false;
     let initializer = decl.initializer;
     while (ts.isParenthesizedExpression(initializer))
@@ -4282,6 +5082,18 @@ function jsObjectBindingExpands(lowerer, decl, type) {
             const name = property(node.left);
             if (name === null || (name !== undefined && !names.has(name)))
                 expands = true;
+            // `state = { _tag: "Done", right }` stores an object with properties
+            // the initializer's shape lacks; later reads of them must see them.
+            const target = unwrap(node.left);
+            const value = unwrap(node.right);
+            const targetSymbol = ts.isIdentifier(target) ? lowerer.resolveValueSymbol(target) : undefined;
+            if (targetSymbol &&
+                aliases.has(targetSymbol) &&
+                ts.isObjectLiteralExpression(value) &&
+                value.properties.nodes.some((field) => !(ts.isPropertyAssignment(field) || ts.isShorthandPropertyAssignment(field)) ||
+                    !(ts.isIdentifier(field.name) || ts.isStringLiteral(field.name)) ||
+                    !names.has(field.name.text)))
+                expands = true;
         }
         if (ts.isDeleteExpression(node) && property(node.expression) !== undefined)
             expands = true;
@@ -4289,7 +5101,7 @@ function jsObjectBindingExpands(lowerer, decl, type) {
             ts.isPropertyAccessExpression(node.expression) &&
             node.expression.name.text === "setPrototypeOf" &&
             lowerer.isStdlibGlobal(node.expression.expression, "Object")) {
-            const target = node.arguments[0];
+            const target = node.arguments.nodes[0];
             const sym = target && ts.isIdentifier(target) ? lowerer.resolveValueSymbol(target) : undefined;
             if (sym && aliases.has(sym))
                 expands = true;
@@ -4301,12 +5113,13 @@ function jsObjectBindingExpands(lowerer, decl, type) {
 }
 export function hasJsTypeAnnotation(decl) {
     const statement = decl.parent?.parent;
-    return (!!statement && /@type\b/.test(decl.getSourceFile().text.slice(statement.pos, decl.getStart())));
+    return (!!statement &&
+        /@type\b/.test(ts.getSourceFileOfNode(decl).text.slice(statement.pos, ts.tokenStartOfNode(decl))));
 }
 /** Inferred JS scalar initializers do not constrain later writes through
  * an any-valued callback. Keep those bindings open, including captured writes. */
 export function jsBindingHasOpenWrites(lowerer, decl) {
-    if (!isJsSourceFile(decl.getSourceFile()) ||
+    if (!isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
         decl.type ||
         hasJsTypeAnnotation(decl) ||
         !ts.isIdentifier(decl.name))
@@ -4335,41 +5148,147 @@ export function jsBindingHasOpenWrites(lowerer, decl) {
         writes = indexed;
         lowerer.jsBindingWritesByOwner.set(owner, writes);
     }
-    return (writes.get(decl.name.text) ?? []).some((node) => lowerer.resolveValueSymbol(node.left) === symbol &&
-        (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+    const candidates = (writes.get(decl.name.text) ?? []).filter((node) => lowerer.resolveValueSymbol(node.left) === symbol);
+    if (candidates.some((node) => (lowerer.typeOf(node.right).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0))
+        return true;
+    // A plain JavaScript write of a value the declared type cannot hold (the
+    // checker does not report it): buffer-crc32 replaces its number[] table
+    // with `new Int32Array(table)`. Only a different representation counts;
+    // writes that coerce into the declared type keep it.
+    // A write whose checker type is the declaration's own maps to the same
+    // representation; the declared type is mapped only for the others.
+    const declaredType = lowerer.typeOf(decl.name);
+    const differing = candidates.filter((node) => node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        lowerer.typeOf(node.right) !== declaredType);
+    if (differing.length === 0)
+        return false;
+    const declared = lowerer.mapTypeOf(declaredType);
+    if (declared === null || declared.kind === "dyn" || declared.kind === "union")
+        return false;
+    return differing.some((node) => {
+        const written = lowerer.mapTypeOf(lowerer.typeOf(node.right));
+        return (written !== null &&
+            written.kind !== "dyn" &&
+            written.kind !== "union" &&
+            !isUnitType(written) &&
+            lowerer.dynConvertible(written) &&
+            lowerer.dynConvertible(declared) &&
+            !typeEquals(written, declared) &&
+            (written.kind !== declared.kind || written.kind === "bytes"));
+    });
 }
 function immediatelyGuardedAbsenceProbe(lowerer, decl) {
-    if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
+    const guard = immediateAbsenceGuard(lowerer, decl);
+    // `if (!x)`: the falsy test sees a missing value.
+    if (guard === "falsy")
+        return true;
+    // `if (x === undefined)` and its spellings compare the binding with the
+    // missing value itself, so the read must be able to produce it. Only
+    // index-signature record reads take this form: array reads already
+    // carry their undefined arm, and their ordinary lowering keeps its
+    // bounds proofs.
+    return guard === "compare" && isIndexSignatureRecordRead(lowerer, decl);
+}
+/** A file-scope or block-scope `let e = map[k]` over an index-signature
+ * record whose next statement guards `e` for absence (`if (e ===
+ * undefined)`, `if (!e)`, ...): the get-or-create idiom. Its read keeps the
+ * missing key as undefined even without noUncheckedIndexedAccess. */
+export function isGuardedRecordRead(lowerer, decl) {
+    return immediateAbsenceGuard(lowerer, decl) !== null && isIndexSignatureRecordRead(lowerer, decl);
+}
+function isIndexSignatureRecordRead(lowerer, decl) {
+    if (!decl.initializer)
         return false;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isElementAccessExpression(init))
+        return false;
+    // Under noUncheckedIndexedAccess the checker already spells the missing
+    // arm, and the ordinary read carries it.
+    const read = lowerer.typeOf(init);
+    if ((read.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0 ||
+        (read.isUnionType() &&
+            ts.constituentTypes(read).some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)))
+        return false;
+    const receiver = lowerer.mapTypeOf(lowerer.typeOf(init.expression));
+    const shape = receiver?.kind === "record" ? lowerer.shapes.get(receiver.shapeId) : undefined;
+    return !!shape && !shape.tuple && !!shape.indexValue && shape.indexValue.kind !== "dyn";
+}
+/** How the statement right after an unannotated declaration tests the
+ * declared binding for absence: `if (!x)` ("falsy"), or a comparison with
+ * the missing value — `x === undefined`, `x == null`, `x !== void 0`,
+ * `typeof x === "undefined"` and their mirrored and negated spellings
+ * ("compare"). Null for anything else. */
+function immediateAbsenceGuard(lowerer, decl) {
+    if (decl.type || !ts.isIdentifier(decl.name) || !decl.initializer)
+        return null;
     const statement = decl.parent?.parent;
     if (!statement || !ts.isVariableStatement(statement))
-        return false;
+        return null;
     const container = statement.parent;
-    const statements = ts.isBlock(container) || ts.isSourceFile(container) ? container.statements : null;
+    const statements = ts.isBlock(container) || ts.isSourceFile(container) ? container.statements.nodes : null;
     if (!statements)
-        return false;
+        return null;
     const index = statements.indexOf(statement);
     const next = index >= 0 ? statements[index + 1] : undefined;
     if (!next || !ts.isIfStatement(next))
-        return false;
-    let condition = next.expression;
-    while (ts.isParenthesizedExpression(condition))
-        condition = condition.expression;
-    if (!ts.isPrefixUnaryExpression(condition) ||
-        condition.operator !== ts.SyntaxKind.ExclamationToken)
-        return false;
-    let operand = condition.operand;
-    while (ts.isParenthesizedExpression(operand))
-        operand = operand.expression;
-    return (ts.isIdentifier(operand) &&
-        lowerer.resolveValueSymbol(operand) === lowerer.resolveValueSymbol(decl.name));
+        return null;
+    const binding = lowerer.resolveValueSymbol(decl.name);
+    const peel = (node) => {
+        while (ts.isParenthesizedExpression(node))
+            node = node.expression;
+        return node;
+    };
+    const isBinding = (node) => {
+        const operand = peel(node);
+        return ts.isIdentifier(operand) && lowerer.resolveValueSymbol(operand) === binding;
+    };
+    const condition = peel(next.expression);
+    if (ts.isPrefixUnaryExpression(condition))
+        return condition.operator === ts.SyntaxKind.ExclamationToken && isBinding(condition.operand)
+            ? "falsy"
+            : null;
+    if (!ts.isBinaryExpression(condition))
+        return null;
+    const op = condition.operatorToken.kind;
+    const strict = op === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+        op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
+    const loose = op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken;
+    if (!strict && !loose)
+        return null;
+    const isUndefined = (node) => {
+        const operand = peel(node);
+        if (ts.isVoidExpression(operand))
+            return true;
+        return (ts.isIdentifier(operand) &&
+            operand.text === "undefined" &&
+            (lowerer.typeOf(operand).flags & ts.TypeFlags.Undefined) !== 0);
+    };
+    const isNull = (node) => peel(node).kind === ts.SyntaxKind.NullKeyword;
+    const missing = (node) => isUndefined(node) || (loose && isNull(node));
+    const isTypeofBinding = (node) => {
+        const operand = peel(node);
+        return ts.isTypeOfExpression(operand) && isBinding(operand.expression);
+    };
+    const isUndefinedTag = (node) => {
+        const operand = peel(node);
+        return ts.isStringLiteralLike(operand) && operand.text === "undefined";
+    };
+    const { left, right } = condition;
+    return (isBinding(left) && missing(right)) ||
+        (missing(left) && isBinding(right)) ||
+        (isTypeofBinding(left) && isUndefinedTag(right)) ||
+        (isUndefinedTag(left) && isTypeofBinding(right))
+        ? "compare"
+        : null;
 }
 function falsyExitRuntimeOptionalLocals(lowerer, stmt) {
     if (stmt.elseStatement)
         return [];
     let tail = stmt.thenStatement;
     while (ts.isBlock(tail)) {
-        const last = tail.statements[tail.statements.length - 1];
+        const last = tail.statements.nodes[tail.statements.nodes.length - 1];
         if (!last)
             return [];
         tail = last;
@@ -4395,15 +5314,16 @@ export function lowerSwitch(lowerer, stmt) {
             return lowerDynSwitch(lowerer, stmt, disc, labels);
         if (dk === "union")
             return lowerUnionSwitch(lowerer, stmt, disc, labels);
-        if (dk !== "f64" && dk !== "string" && dk !== "bool") {
-            lowerer.unsupported("SC1090", stmt.expression, "switch on non-primitive values");
-        }
+        // Objects, arrays, functions and other references match their cases
+        // with ===, which compares them by identity.
+        if (dk !== "f64" && dk !== "string" && dk !== "bool")
+            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.
         lowerer.scopes.push(new Map());
         try {
             const cases = [];
-            for (const clause of stmt.caseBlock.clauses) {
+            for (const clause of stmt.caseBlock.clauses.nodes) {
                 let test = null;
                 if (ts.isCaseClause(clause)) {
                     test = lowerer.lowerExpr(clause.expression);
@@ -4413,7 +5333,7 @@ export function lowerSwitch(lowerer, stmt) {
                 }
                 cases.push({
                     test,
-                    body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements)), labels),
+                    body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements.nodes)), labels),
                 });
             }
             return { kind: "switch", disc, cases, ...(labels && { labels }), loc: locOf(stmt) };
@@ -4463,7 +5383,7 @@ function lowerDynSwitch(lowerer, stmt, disc, labels) {
                 loc: locOf(expression),
             };
         }
-        if (!lowerer.dynConvertible(test.type)) {
+        if (test.type.kind === "date" || !lowerer.dynConvertible(test.type)) {
             lowerer.unsupported("SC1100", expression, "switch case values that cannot compare strictly with 'unknown'");
         }
         return {
@@ -4484,7 +5404,7 @@ function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
     // Calls/assignments in a case test may mutate a captured discriminant
     // binding. The checker still narrows that binding as if it were the
     // snapshot. Keep the original tagged value in those case bodies.
-    const effectful = stmt.caseBlock.clauses.some((clause) => ts.isCaseClause(clause) &&
+    const effectful = stmt.caseBlock.clauses.nodes.some((clause) => ts.isCaseClause(clause) &&
         !ts.isStringLiteral(clause.expression) &&
         !ts.isNumericLiteral(clause.expression) &&
         !ts.isIdentifier(clause.expression) &&
@@ -4500,11 +5420,11 @@ function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
         lowerer.unstableSwitchBindings.add(symbol);
     lowerer.scopes.push(new Map());
     try {
-        const cases = stmt.caseBlock.clauses.map((clause) => ({
+        const cases = stmt.caseBlock.clauses.nodes.map((clause) => ({
             test: ts.isCaseClause(clause)
                 ? compare(stableDisc, lowerer.lowerExpr(clause.expression), clause.expression)
                 : null,
-            body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements)), labels),
+            body: lowerer.inCtl("switch", () => withRuntimeOptionalScope(lowerer, () => lowerer.lowerStmts(clause.statements.nodes)), labels),
         }));
         return {
             kind: "block",
@@ -4533,7 +5453,7 @@ function lowerBranchSwitch(lowerer, stmt, disc, labels, compare) {
  *   cell, deliberately narrower than dyn: the supported uses are the
  *   narrowing tests (`e instanceof C` over hierarchy classes, `typeof e
  *   === "string"/"number"/"boolean"`), reads under a proven narrow
- *   (caughtRead bridges them with caughtNarrow, trust-the-checker like
+ *   (caughtRead bridges them with caughtNarrow, verified at run time like
  *   unionNarrow), and rethrow (`throw e`). Unsupported raw uses and
  *   assignments are fenced (SC1063 and friends); destructuring patterns
  *   are SC1062. Captures retain the snapshot beyond the catch scope.
@@ -4579,31 +5499,6 @@ export function lowerTry(lowerer, stmt) {
         loc: locOf(stmt),
     };
 }
-function hasUseStrictDirective(statements) {
-    for (const statement of statements) {
-        if (!ts.isExpressionStatement(statement) || !ts.isStringLiteral(statement.expression))
-            return false;
-        if (statement.expression.text === "use strict")
-            return true;
-    }
-    return false;
-}
-function isStrictDelete(node) {
-    for (let parent = node.parent; parent; parent = parent.parent) {
-        if (ts.isClassDeclaration(parent) || ts.isClassExpression(parent))
-            return true;
-        if (ts.isFunctionLike(parent) &&
-            parent.body &&
-            ts.isBlock(parent.body) &&
-            hasUseStrictDirective(parent.body.statements))
-            return true;
-        if (ts.isSourceFile(parent)) {
-            return (hasUseStrictDirective(parent.statements) ||
-                (!isCjsJsFile(parent) && (isNodeEsmFile(parent) || ts.isExternalModule(parent))));
-        }
-    }
-    return false;
-}
 /** Statement-position `delete`: process.env keys → process.envUnset
  * (unsetenv), pure `Record<string, T>` keys → recordKeyDelete (the
  * overflow Map delete), declared OPTIONAL fields → the field's ABSENT
@@ -4666,7 +5561,29 @@ function lowerDeleteStatement(lowerer, expr) {
         };
     }
     let obj = lowerer.lowerExpr(target.expression);
-    if (isJsSourceFile(expr.getSourceFile()) && obj.type.kind === "object") {
+    // `delete this.stack` in an Error subclass that declares a `stack`
+    // accessor (quickjs-wasi's JSException): V8 gives each error an own
+    // `stack` that shadows the accessor, and the delete removes it so reads
+    // reach the accessor. Compiled errors keep the trace internally and
+    // class dispatch already reads the accessor, so only the receiver's
+    // evaluation remains.
+    if (obj.type.kind === "object" &&
+        ts.isPropertyAccessExpression(target) &&
+        target.name.text === "stack") {
+        let accessor = false;
+        let errorBase = false;
+        for (let c = lowerer.classes.get(obj.type.className); c; c = c.base ?? undefined) {
+            if (c.builtinError) {
+                errorBase = true;
+                break;
+            }
+            if (c.methods.has("get:stack"))
+                accessor = true;
+        }
+        if (accessor && errorBase)
+            return { kind: "exprStmt", expr: obj, loc };
+    }
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) && obj.type.kind === "object") {
         const info = lowerer.classes.get(obj.type.className);
         const keyType = ts.isElementAccessExpression(target)
             ? lowerer.typeOf(target.argumentExpression)
@@ -4686,13 +5603,13 @@ function lowerDeleteStatement(lowerer, expr) {
             };
         }
     }
-    if (isJsSourceFile(expr.getSourceFile()) &&
+    if (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         obj.type.kind === "func" &&
         lowerer.dynConvertible(obj.type)) {
         obj = lowerer.coerceToExpected(obj, DYN);
     }
     if (obj.type.kind === "dyn") {
-        const strict = { kind: "boolLit", value: isStrictDelete(expr), type: BOOL, loc };
+        const strict = { kind: "boolLit", value: isStrictCode(expr), type: BOOL, loc };
         if (ts.isElementAccessExpression(target)) {
             const key = lowerer.lowerExprExpecting(target.argumentExpression, DYN);
             return {
@@ -4779,7 +5696,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
     const assignExport = (nameNode, value, root) => {
         const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ??
             (ts.isIdentifier(nameNode) || ts.isPrivateIdentifier(nameNode)
-                ? lowerer.cjsModuleExportSymbol(cjs.expr.getSourceFile(), nameNode.text)
+                ? lowerer.cjsModuleExportSymbol(ts.getSourceFileOfNode(cjs.expr), nameNode.text)
                 : undefined);
         const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
         if (!g) {
@@ -4838,7 +5755,10 @@ function lowerCjsExportStatement(lowerer, cjs) {
         // storage — collectGlobals skipped it; importers re-resolve through
         // cjsMemberExportClassSymbol): the statement lowers to nothing.
         if (lowerer.cjsMemberExportClassSymbol(cjs.expr) !== null) {
-            return { kind: "block", body: [], loc };
+            // An inline require still evaluates its module here.
+            const req = inlineProgramRequireOf(lowerer, cjs.value);
+            const init = req !== null ? lowerer.requireInitStmt(req.spec, req.call) : null;
+            return init ?? { kind: "block", body: [], loc };
         }
         // The tsc VOID-INIT PREAMBLE (`exports.leaf = void 0;` with the real
         // `exports.leaf = leaf;` further down — every tsc-emitted dist file
@@ -4850,54 +5770,58 @@ function lowerCjsExportStatement(lowerer, cjs) {
         // the real assignment's position already orders. Preambles with no
         // later real assignment keep the ordinary path (the export IS
         // undefined then).
-        if (ts.isIdentifier(cjs.name)) {
-            const isExportsMember = (e) => ts.isPropertyAccessExpression(e) &&
-                ts.isIdentifier(e.name) &&
-                ((ts.isIdentifier(e.expression) && e.expression.text === "exports") ||
-                    (ts.isPropertyAccessExpression(e.expression) &&
-                        ts.isIdentifier(e.expression.expression) &&
-                        e.expression.expression.text === "module" &&
-                        ts.isIdentifier(e.expression.name) &&
-                        e.expression.name.text === "exports"));
-            const isVoid = (e) => {
-                while (ts.isParenthesizedExpression(e))
-                    e = e.expression;
-                return (e.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(e) && e.text === "undefined"));
-            };
-            // chains: `exports.a = exports.b = void 0;` collects every name
-            const names = [cjs.name.text];
-            let tail = cjs.value;
-            while (ts.isBinaryExpression(tail) &&
-                tail.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                isExportsMember(tail.left)) {
-                names.push(tail.left.name.text);
-                tail = tail.right;
-            }
-            if (isVoid(tail)) {
-                const sfHere = cjs.expr.getSourceFile();
-                const myPos = cjs.expr.getStart(sfHere);
-                const laterRealOf = (name) => sfHere.statements.some((s) => {
-                    const other = cjsExportAssignmentOf(s);
-                    if (other?.kind !== "member" || !ts.isIdentifier(other.name))
-                        return false;
-                    if (other.name.text !== name)
-                        return false;
-                    if (other.expr.getStart(sfHere) <= myPos)
-                        return false;
-                    return !isVoid(other.value);
-                });
-                if (names.every(laterRealOf))
-                    return { kind: "block", body: [], loc };
-            }
-        }
-        const sf = cjs.expr.getSourceFile();
+        if (cjsVoidInitPreambleReals(cjs) !== null)
+            return { kind: "block", body: [], loc };
+        const sf = ts.getSourceFileOfNode(cjs.expr);
         let root;
-        for (const stmt of sf.statements) {
+        for (const stmt of sf.statements.nodes) {
             const whole = cjsExportAssignmentOf(stmt);
             if (whole?.kind !== "table" || cjsExportDiscardReason(stmt) !== null)
                 continue;
             root = lowerer.globalsByDeclNode.get(whole.expr);
         }
+        // A CHAIN `exports.a = exports.b = value`: Node evaluates the value
+        // once, assigns the innermost member first, and every member holds
+        // the same value. Each member is its own export global
+        // (collectGlobals registers the inner ones too).
+        {
+            const chain = cjsExportChainOf(cjs.expr);
+            if (chain !== null && root?.type.kind !== "dyn") {
+                const globalOfName = (nameNode) => {
+                    const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ??
+                        lowerer.cjsModuleExportSymbol(sf, nameNode.text);
+                    const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
+                    if (!g) {
+                        lowerer.lowerExpr(chain.value);
+                        lowerer.badType(chain.value, lowerer.typeOf(chain.value));
+                    }
+                    return g;
+                };
+                const inner = chain.names[chain.names.length - 1];
+                const innerG = globalOfName(inner);
+                const body = [
+                    {
+                        kind: "assign",
+                        localId: innerG.id,
+                        value: lowerer.lowerExprExpecting(chain.value, innerG.type),
+                        loc: locOf(chain.value),
+                    },
+                ];
+                for (let i = chain.names.length - 2; i >= 0; i--) {
+                    const g = globalOfName(chain.names[i]);
+                    const read = { kind: "varRef", localId: innerG.id, type: innerG.type, loc };
+                    body.push({
+                        kind: "assign",
+                        localId: g.id,
+                        value: typeEquals(g.type, innerG.type)
+                            ? read
+                            : lowerer.coerceInto(chain.value, read, g.type),
+                        loc,
+                    });
+                }
+                return { kind: "block", body, loc };
+            }
+        }
         return assignExport(cjs.name, cjs.value, root);
     }
     let tableObj = cjs.obj;
@@ -4911,7 +5835,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
         // were already evaluated by the const's own declaration, so this
         // statement may not RE-evaluate anything: expression-valued entries
         // (which the direct-table lowering assigns here) keep a fence.
-        tableObj = cjsExportTargetLiteral(cjs.expr.right, cjs.expr.getSourceFile());
+        tableObj = cjsExportTargetLiteral(cjs.expr.right, ts.getSourceFileOfNode(cjs.expr));
         resolvedTarget = tableObj !== null;
         if (!tableObj) {
             const single = lowerCjsSingleValueExport(lowerer, cjs.expr, loc);
@@ -4934,7 +5858,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
             lowerer.unsupported("SC1090", nameNode, `exporting the mutable 'let' binding '${nameNode.text}' by reference (Node copies its VALUE at this statement — declare it const, or export a function that reads it)`);
         }
     };
-    for (const prop of table.properties) {
+    for (const prop of table.properties.nodes) {
         if (ts.isShorthandPropertyAssignment(prop)) {
             fenceMutable(prop.name);
             continue; // alias plumbing
@@ -4952,6 +5876,29 @@ function lowerCjsExportStatement(lowerer, cjs) {
             body.push(assignExport(prop.name, prop.initializer));
             continue;
         }
+        // METHOD entries: the export global holds the method's function,
+        // created at this statement like a function-expression entry. Node
+        // calls it with `this` bound to the table, which the static export
+        // table cannot represent, so a body that uses `this` keeps a fence.
+        {
+            const method = cjsTableMethodEntry(prop);
+            if (method !== null && !resolvedTarget) {
+                lowerer.rejectThisInObjectMethod(method.body);
+                const symbol = lowerer.checker.getSymbolAtLocation(method.name) ??
+                    lowerer.cjsModuleExportSymbol(ts.getSourceFileOfNode(cjs.expr), method.name.text);
+                const g = symbol ? lowerer.globalsBySymbol.get(symbol) : undefined;
+                if (g) {
+                    const fn = lowerer.lowerLambda(method);
+                    body.push({
+                        kind: "assign",
+                        localId: g.id,
+                        value: typeEquals(fn.type, g.type) ? fn : lowerer.coerceInto(method, fn, g.type),
+                        loc: locOf(method),
+                    });
+                    continue;
+                }
+            }
+        }
         // ACCESSOR entries: no storage and no code here — reads lift the
         // getter as a module-level function and call it per read
         // (cjsExportAccessorRead); writes through the setter keep their
@@ -4969,8 +5916,16 @@ function lowerCjsExportStatement(lowerer, cjs) {
             let inner = prop.expression;
             while (ts.isParenthesizedExpression(inner))
                 inner = inner.expression;
-            if (requireSpecOf(inner) !== null)
+            if (requireSpecOf(inner) !== null) {
+                // The spread still EVALUATES the module, at its place among the
+                // table's entries (a program module joins the graph through this
+                // inline require; cjs-inline-require.ts).
+                const req = inlineProgramRequireOf(lowerer, inner);
+                const init = req !== null ? lowerer.requireInitStmt(req.spec, req.call) : null;
+                if (init !== null && !resolvedTarget)
+                    body.push(init);
                 continue;
+            }
         }
         lowerer.unsupported("SC1090", prop, "module.exports table entries beyond plain 'name: value' properties (methods, accessors, spreads, computed names)");
     }
@@ -4995,6 +5950,16 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
     let rhs = expr.right;
     while (ts.isParenthesizedExpression(rhs))
         rhs = rhs.expression;
+    // `module.exports = require("./x")`: the module re-exports x's exports.
+    // Requirers resolve through the checker's alias to x's own export
+    // machinery; this statement is x's evaluation at this position.
+    {
+        const req = inlineProgramRequireOf(lowerer, rhs);
+        // With later member exports (`module.exports.extra = …`) the module
+        // extends that object, so it keeps the factory root registration.
+        if (req !== null && !lowerer.globalsByDeclNode.has(expr))
+            return lowerer.requireInitStmt(req.spec, req.call) ?? { kind: "block", body: [], loc };
+    }
     if (ts.isIdentifier(rhs)) {
         const sym = lowerer.resolveValueSymbol(rhs);
         if (!sym)
@@ -5004,6 +5969,14 @@ function lowerCjsSingleValueExport(lowerer, expr, loc) {
             lowerer.genericFnsBySymbol.has(sym)) {
             return { kind: "block", body: [], loc };
         }
+        // A require binding (`const x = require("./x"); module.exports = x`)
+        // re-exports that module exactly like the inline form (the binding's
+        // own statement already evaluated it), and a builtin global
+        // (`module.exports = TypeError`) is the global itself: requirer
+        // bindings alias straight through to it, so nothing is stored.
+        if (sym.declarations.some((d) => ts.isSourceFile(d)) || lowerer.isStdlibSymbol(sym)) {
+            return { kind: "block", body: [], loc };
+        }
         const g = lowerer.globalsBySymbol.get(sym);
         if (g) {
             if (g.mutable) {
@@ -5108,8 +6081,7 @@ export function lowerExprStatement(lowerer, expr) {
     // positions keep the first-class-namespace fences.
     if (ts.isIdentifier(expr)) {
         const sym = lowerer.checker.getSymbolAtLocation(expr);
-        if (sym !== undefined &&
-            lowerer.checker.declarationsOf(sym).some((d) => ts.isNamespaceImport(d))) {
+        if (sym !== undefined && sym.declarations.some((d) => ts.isNamespaceImport(d))) {
             return { kind: "block", body: [], loc: locOf(expr) };
         }
     }
@@ -5142,16 +6114,22 @@ export function lowerExprStatement(lowerer, expr) {
             return (lowerer.requireInitStmt(created.spec, expr) ?? { kind: "block", body: [], loc: locOf(expr) });
         }
         // syncBuiltinESMExports() is the other compiler-only statement: the
-        // call validates its zero-argument shape, then emits no code because
-        // the static builtin surface is immutable.
+        // call validates its zero-argument shape, then refreshes the events
+        // module's ES module namespace copy of defaultMaxListeners, the one
+        // builtin export a program can change.
         const bi = ts.isIdentifier(expr.expression)
             ? lowerer.builtinImportOf(expr.expression)
             : ts.isPropertyAccessExpression(expr.expression)
                 ? lowerer.builtinMemberOf(expr.expression)
                 : null;
         if (bi?.module === "module" && bi.member === "syncBuiltinESMExports") {
-            lowerNodeModuleCall(lowerer, expr, bi, locOf(expr));
-            return { kind: "block", body: [], loc: locOf(expr) };
+            const loc = locOf(expr);
+            lowerNodeModuleCall(lowerer, expr, bi, loc);
+            return {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "emitter.esmSync", args: [], type: VOID, loc },
+                loc,
+            };
         }
     }
     if (requireSpecOf(expr) !== null &&
@@ -5160,7 +6138,7 @@ export function lowerExprStatement(lowerer, expr) {
         // A binding NAMED require made by createRequire is not the CJS
         // global — the expression path owns it (lowerCreateRequireCall).
         createRequireCalleeFileOf(lowerer, expr.expression) === null) {
-        const sf = expr.getSourceFile();
+        const sf = ts.getSourceFileOfNode(expr);
         const spec = requireSpecOf(expr);
         if (lowerer.externalTypes.has(spec))
             lowerer.externalHostFence(spec, expr, false);
@@ -5174,16 +6152,12 @@ export function lowerExprStatement(lowerer, expr) {
             if (!isRelativeSpecifier(spec) && canonicalBuiltinModule(spec) === null) {
                 const refusal = probeNodeRequireRefusal(sf.fileName, spec);
                 if (refusal !== null) {
+                    // The same throw as the expression form (cjs-inline-require):
+                    // an Error carrying Node's MODULE_NOT_FOUND code.
                     const loc = locOf(expr);
                     return {
-                        kind: "throw",
-                        value: {
-                            kind: "libCall",
-                            fn: "error.new",
-                            args: [{ kind: "strLit", value: refusal.message, type: STRING, loc }],
-                            type: { kind: "object", className: "%Error" },
-                            loc,
-                        },
+                        kind: "exprStmt",
+                        expr: nodeThrowExpr(0, "MODULE_NOT_FOUND", refusal.message, VOID, loc),
                         loc,
                     };
                 }
@@ -5199,7 +6173,30 @@ export function lowerExprStatement(lowerer, expr) {
             return { kind: "block", body: [], loc: locOf(expr) };
         lowerer.unsupported("SC1090", expr, "require() outside the module's top level (move it to the top of the file)");
     }
+    // Replacing the export object (or rebinding `exports`) anywhere but a
+    // top-level statement makes the module's exports depend on which path
+    // ran (`cond ? module.exports = a : module.exports = b`, an
+    // environment-dependent branch); the static export table has one shape.
+    if (!topLevelJs &&
+        isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+        ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        (isCjsModuleExports(lowerer, expr.left) || isCjsExportsIdentifier(lowerer, expr.left))) {
+        lowerer.unsupported("SC1090", expr.left, isCjsModuleExports(lowerer, expr.left)
+            ? "replacing module.exports outside a top-level statement (a conditional or environment-dependent export object)"
+            : "rebinding 'exports' outside a top-level statement (a conditional or environment-dependent export object)");
+    }
     if (topLevelJs && ts.isExpressionStatement(stmtNode)) {
+        if (isFreshExportsReset(lowerer, stmtNode))
+            return { kind: "block", body: [], loc: locOf(expr) };
+        // Any other `exports = …` rebinds the wrapper's exports binding: the
+        // members later attached through it belong to the new value.
+        if (ts.isBinaryExpression(expr) &&
+            expr.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            isCjsExportsIdentifier(lowerer, expr.left) &&
+            cjsExportAssignmentOf(stmtNode)?.kind !== "table") {
+            lowerer.unsupported("SC1090", expr.left, "rebinding 'exports' without module.exports (exports = value): members attached through 'exports' afterwards are properties of that value, which module.exports does not hold — write exports = module.exports = value");
+        }
         const cjs = cjsExportAssignmentOf(stmtNode);
         if (cjs)
             return lowerCjsExportStatement(lowerer, cjs);
@@ -5399,7 +6396,9 @@ export function lowerExprStatement(lowerer, expr) {
                     }
                     else {
                         const recvT = lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression));
-                        if (recvT?.kind === "classval") {
+                        // A runtime-provided class (`Error.stackTraceLimit = 0`) keeps
+                        // its static lowering below.
+                        if (recvT?.kind === "classval" && !lowerer.classes.get(recvT.className)?.def.runtime) {
                             // A static write through a class VALUE: sound exactly when
                             // the value can only BE the declaring class — a LEAF class
                             // (no strict descendants can flow into the slot, so JS's
@@ -5499,9 +6498,12 @@ export function lowerExprStatement(lowerer, expr) {
                     lowerer.stdlibGlobalMember(expr.left, "process") === "exitCode") {
                     const loc = locOf(expr);
                     const value = lowerer.lowerExprExpecting(expr.right, F64);
+                    const fn = programReadsExitCode(lowerer)
+                        ? "process.setExitCodeTracked"
+                        : "process.setExitCode";
                     return {
                         kind: "exprStmt",
-                        expr: { kind: "libCall", fn: "process.setExitCode", args: [value], type: VOID, loc },
+                        expr: { kind: "libCall", fn, args: [value], type: VOID, loc },
                         loc,
                     };
                 }
@@ -5522,6 +6524,30 @@ export function lowerExprStatement(lowerer, expr) {
                             loc,
                         };
                     }
+                    // process.emitWarning = fn: an ordinary writable property. Later
+                    // process.emitWarning(...) calls, and the warnings Node's own
+                    // modules emit through process.emitWarning, call the replacement
+                    // instead (silencing them when it does nothing).
+                    if (flag === "emitWarning") {
+                        const loc = locOf(expr);
+                        let rhs = expr.right;
+                        while (ts.isParenthesizedExpression(rhs) ||
+                            ts.isAsExpression(rhs) ||
+                            ts.isSatisfiesExpression(rhs))
+                            rhs = rhs.expression;
+                        const value = lowerer.lowerExprExpecting(rhs, DYN);
+                        return {
+                            kind: "exprStmt",
+                            expr: {
+                                kind: "libCall",
+                                fn: "process.setEmitWarning",
+                                args: [value],
+                                type: VOID,
+                                loc,
+                            },
+                            loc,
+                        };
+                    }
                     // process.title = name: libuv's uv_set_process_title (the
                     // runtime truncates to the original argument area on POSIX).
                     if (flag === "title") {
@@ -5586,7 +6612,7 @@ export function lowerExprStatement(lowerer, expr) {
                     const recv = tryLowerExpression(lowerer, expr.left.expression);
                     if (recv &&
                         (recv.type.kind === "dyn" ||
-                            (isJsSourceFile(expr.getSourceFile()) &&
+                            (isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
                                 recv.type.kind === "union" &&
                                 lowerer.dynConvertible(recv.type)))) {
                         const loc = locOf(expr);
@@ -5606,6 +6632,34 @@ export function lowerExprStatement(lowerer, expr) {
                             loc,
                         };
                     }
+                    if (recv?.type.kind === "child" && isJsSourceFile(ts.getSourceFileOfNode(expr)))
+                        return lowerChildPropertyWrite(lowerer, recv, expr.left, expr.right, locOf(expr));
+                    // `err.code = v` on an Error value (`err as Error & { code?:
+                    // string }`): typed reads come from the runtime error's code
+                    // slot, so the write lands there. A value that is not statically
+                    // a string checks at runtime: strings take the slot, anything
+                    // else clears it and stays a dynamic own property. The
+                    // system-error members (errno, syscall, path, dest) read
+                    // through the checked-dynamic node and keep the dynamic write, as
+                    // do JavaScript files, whose reads use that node too.
+                    if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
+                        recv?.type.kind === "object" &&
+                        lowerer.isErrorRootedClass(recv.type.className) &&
+                        expr.left.name.text === "code") {
+                        const loc = locOf(expr);
+                        const stringValue = isStringTyped(lowerer.typeOf(expr.right));
+                        return {
+                            kind: "exprStmt",
+                            expr: {
+                                kind: "libCall",
+                                fn: stringValue ? "error.setCode" : "error.setCodeDyn",
+                                args: [recv, lowerer.lowerExprExpecting(expr.right, stringValue ? STRING : DYN)],
+                                type: VOID,
+                                loc,
+                            },
+                            loc,
+                        };
+                    }
                     if (recv?.type.kind === "object" && recv.type.className === "%Error") {
                         const loc = locOf(expr);
                         return {
@@ -5657,6 +6711,25 @@ export function lowerExprStatement(lowerer, expr) {
                 const recvIr = lowerer.mapTypeOf(lowerer.typeOf(expr.left.expression));
                 if (recvIr?.kind === "record") {
                     const shape = lowerer.shapes.get(recvIr.shapeId);
+                    if (shape?.indexValue &&
+                        shape.fields.length === 0 &&
+                        declaredMemberOf(lowerer, expr.left.expression, expr.left.name.text)) {
+                        // A declared member of a literal stored as a pure index-signature
+                        // record (dictSpreadLiteralShape): a keyed write of that key.
+                        const loc = locOf(expr);
+                        const obj = lowerer.lowerExpr(expr.left.expression);
+                        if (obj.type.kind === "record") {
+                            const value = lowerer.intoIndexValueSlot(lowerer.lowerExprExpecting(expr.right, shape.indexValue), shape.indexValue, expr.right);
+                            return {
+                                kind: "recordKeySet",
+                                obj,
+                                shapeId: obj.type.shapeId,
+                                key: { kind: "strLit", value: expr.left.name.text, type: STRING, loc },
+                                value,
+                                loc,
+                            };
+                        }
+                    }
                     if (shape?.indexValue &&
                         !shape.fields.some((f) => f.name === expr.left.name.text)) {
                         lowerer.unsupported("SC1090", expr.left, `dot writes to index-signature keys (spell it r["${expr.left.name.text}"] = v — brackets are the index-signature form)`);
@@ -5673,6 +6746,19 @@ export function lowerExprStatement(lowerer, expr) {
                 const parts = lowerDestructuringAssignParts(lowerer, expr.left, expr.right, locOf(expr));
                 return { kind: "block", body: parts.stmts, loc: locOf(expr) };
             }
+            // `exports.x = v` inside a function updates the member's export
+            // global (cjs-exports-object.ts).
+            if (ts.isPropertyAccessExpression(expr.left)) {
+                const g = cjsExportMemberWriteGlobalOf(lowerer, expr.left);
+                if (g) {
+                    return {
+                        kind: "assign",
+                        localId: g.id,
+                        value: lowerer.lowerExprExpecting(expr.right, g.type),
+                        loc: locOf(expr),
+                    };
+                }
+            }
             if (!ts.isIdentifier(expr.left)) {
                 lowerer.unsupported("SC1090", expr.left, "assignment to non-variables");
             }
@@ -5768,6 +6854,13 @@ 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) &&
+        (expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+            expr.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
+        return lowerDiscardedLogical(lowerer, expr);
+    }
     const value = lowerer.lowerExpr(expr);
     // A bare unit-literal statement (`undefined;`): a pure no-op in JS,
     // and the IR has no bare-unit VALUE outside a union wrap — drop it
@@ -5776,6 +6869,55 @@ export function lowerExprStatement(lowerer, expr) {
         return { kind: "block", body: [], loc: locOf(expr) };
     return { kind: "exprStmt", expr: value, loc: locOf(expr) };
 }
+/** A discarded `a && b` / `a || b` statement (the minifier's `if`). The
+ * value form lowers first, exactly as before. Only when it fails on the
+ * logical's own result type — the operands have no common representation
+ * (jose's `(!m || m[4] && m[1]) && invalid()` joins a boolean, a string
+ * and undefined into the checker's `string`) — does the statement lower
+ * as the control flow it is: `if (a) b;` / `if (!a) b;`, a condition test
+ * that needs no result value. Diagnostics outside the statement, and
+ * internal errors, keep the original failure. */
+function lowerDiscardedLogical(lowerer, expr) {
+    const diagsBefore = lowerer.diags.length;
+    try {
+        const value = lowerer.lowerExpr(expr);
+        if (value.kind === "unitLit")
+            return { kind: "block", body: [], loc: locOf(expr) };
+        return { kind: "exprStmt", expr: value, loc: locOf(expr) };
+    }
+    catch (e) {
+        // A probe (a capture buffer is active) keeps its failure: its owner
+        // picks another lowering, exactly as before.
+        if (!(e instanceof PoisonError) || lowerer.diagSink !== null)
+            throw e;
+        const added = lowerer.diags.slice(diagsBefore);
+        const file = ts.getSourceFileOfNode(expr).fileName;
+        const start = ts.tokenStartOfNode(expr);
+        const local = added.length > 0 &&
+            added.every((d) => d.code !== "SC9001" &&
+                d.loc.file === file &&
+                d.loc.start >= start &&
+                d.loc.end <= expr.end);
+        if (!local)
+            throw e;
+        lowerer.diags.length = diagsBefore;
+    }
+    const and = expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken;
+    const cond = lowerer.lowerCondition(expr.left);
+    if (cond.kind === "boolLit") {
+        return cond.value === and
+            ? lowerExprStatement(lowerer, expr.right)
+            : { kind: "block", body: [], loc: locOf(expr) };
+    }
+    const right = () => lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, expr.left, and), () => and
+        ? withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, expr.left), () => [
+            lowerExprStatement(lowerer, expr.right),
+        ])
+        : [lowerExprStatement(lowerer, expr.right)]);
+    return and
+        ? { kind: "if", cond, then: right(), else_: [], loc: locOf(expr) }
+        : { kind: "if", cond, then: [], else_: right(), loc: locOf(expr) };
+}
 /** True for a statement-position expression whose evaluation cannot be
  * observed once the value is discarded:
  *   - a property/element READ (`?.` included) whose receiver IS a
@@ -5809,7 +6951,7 @@ function droppedPureStdlibStatement(lowerer, expr) {
         const root = stdlibGlobalNameOf(lowerer, strip(proto.expression));
         if (root !== "Array" && root !== "String")
             return false;
-        return expr.arguments.every((a) => sideEffectFreeOptionValue(a));
+        return expr.arguments.nodes.every((a) => sideEffectFreeOptionValue(a));
     }
     if (ts.isPropertyAccessExpression(expr)) {
         return stdlibGlobalNameOf(lowerer, strip(expr.expression)) !== null;
@@ -5877,18 +7019,46 @@ export function lowerDestructuringAssign(lowerer, target, init, blame, loc) {
 }
 /** V8's spelling of a destructuring RHS in its TypeError message
  * ("Cannot destructure 'a' as it is undefined.") — plain identifiers
- * spell their name (parens unwrap), and calls append an ellipsis to a
- * supported callee spelling. Other CallPrinter forms keep a fence. */
+ * spell their name (parens unwrap), `this`, property chains and
+ * identifier or numeric element reads spell their source, awaited and
+ * yielded values spell "(intermediate value)", and calls append an
+ * ellipsis to a supported callee spelling. Other CallPrinter forms keep
+ * a fence. */
 function destrSpellingOf(rhs) {
     let e = rhs;
-    while (ts.isParenthesizedExpression(e))
+    // Parentheses and the type-only wrappers are not part of the emitted
+    // JavaScript expression V8 prints.
+    while (ts.isParenthesizedExpression(e) ||
+        ts.isAsExpression(e) ||
+        ts.isSatisfiesExpression(e) ||
+        ts.isTypeAssertion(e) ||
+        ts.isNonNullExpression(e)) {
         e = e.expression;
+    }
     if (ts.isIdentifier(e))
         return e.text;
+    if (e.kind === ts.SyntaxKind.ThisKeyword)
+        return "this";
+    // V8 prints an awaited or yielded operand as "(intermediate value)".
+    if (ts.isAwaitExpression(e) || ts.isYieldExpression(e))
+        return "(intermediate value)";
     if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) {
         const base = destrSpellingOf(e.expression);
         return base === null ? null : `${base}.${e.name.text}`;
     }
+    // `table[key]` and `list[0]`; V8 prints a numeric key in its canonical
+    // number form (`o[1.50]` reads "o[1.5]").
+    if (ts.isElementAccessExpression(e) && !e.questionDotToken) {
+        const base = destrSpellingOf(e.expression);
+        const key = e.argumentExpression;
+        if (base === null)
+            return null;
+        if (ts.isIdentifier(key))
+            return `${base}[${key.text}]`;
+        if (ts.isNumericLiteral(key))
+            return `${base}[${String(Number(key.text))}]`;
+        return null;
+    }
     if (ts.isCallExpression(e) && !e.questionDotToken) {
         const callee = destrSpellingOf(e.expression);
         return callee === null ? null : `${callee}(...)`;
@@ -5953,9 +7123,9 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
     // globals and strings alike).
     {
         const patternEmpty = ts.isObjectLiteralExpression(target)
-            ? target.properties.length === 0
-            : target.elements.length === 0;
-        if (!patternEmpty && rhs !== null && isJsSourceFile(rhs.getSourceFile())) {
+            ? target.properties.nodes.length === 0
+            : target.elements.nodes.length === 0;
+        if (!patternEmpty && rhs !== null && isJsSourceFile(ts.getSourceFileOfNode(rhs))) {
             const globalName = stdlibGlobalNameOf(lowerer, rhs);
             if (globalName !== null) {
                 lowerer.unsupported("SC1031", blame, `destructuring assignment from the builtin global '${globalName}' (bind the members with a const destructuring declaration instead)`);
@@ -5996,7 +7166,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
                 lowerer.unsupported("SC1031", blame, "destructuring assignment from a checked-dynamic source whose expression spelling is unsupported (use a variable, ordinary property chain, or ordinary call)");
             }
             let firstProp;
-            const p0 = target.properties[0];
+            const p0 = target.properties.nodes[0];
             if (p0 !== undefined) {
                 if (ts.isShorthandPropertyAssignment(p0))
                     firstProp = p0.name.text;
@@ -6020,7 +7190,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
                 loc,
             });
         }
-        for (const prop of target.properties) {
+        for (const prop of target.properties.nodes) {
             const piece = destructAssignPiece(lowerer, prop);
             const read = {
                 kind: "dynKeyGet",
@@ -6038,7 +7208,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
         }
         return { stmts: out, value };
     }
-    if (target.properties.length === 0) {
+    if (target.properties.nodes.length === 0) {
         // `({} = e)`: RequireObjectCoercible and nothing else. A source the
         // type system already proves non-nullish is a pure no-op past the
         // RHS's own evaluation; possibly-nullish unions would throw in JS
@@ -6063,14 +7233,14 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
             lowerer.flushDeferredClass(objT.className);
         const info = lowerer.classes.get(objT.className);
         if (info) {
-            for (const prop of target.properties) {
+            for (const prop of target.properties.nodes) {
                 const propLoc = locOf(prop);
                 if (ts.isSpreadAssignment(prop)) {
                     let restTo = prop.expression;
                     while (ts.isParenthesizedExpression(restTo))
                         restTo = restTo.expression;
                     const consumed = new Set();
-                    for (const p of target.properties) {
+                    for (const p of target.properties.nodes) {
                         if (ts.isShorthandPropertyAssignment(p))
                             consumed.add(p.name.text);
                         else if (ts.isPropertyAssignment(p)) {
@@ -6184,7 +7354,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
     // properties keep the declaration path's named fences. Callers vetted
     // the source as a checker-typed string.
     if (init.type.kind === "string") {
-        for (const prop of target.properties) {
+        for (const prop of target.properties.nodes) {
             const propLoc = locOf(prop);
             if (ts.isSpreadAssignment(prop)) {
                 lowerer.unsupported("SC1031", prop, "rest bindings over string sources (JS packs the wrapper's per-code-unit indices — split with [...s] instead)");
@@ -6246,7 +7416,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
     const shape = lowerer.shapes.get(srcType.shapeId);
     if (!shape)
         throw new InternalCompilerError(`lowerer bug: destructuring unknown shape ${srcType.shapeId}`);
-    for (const prop of target.properties) {
+    for (const prop of target.properties.nodes) {
         // Shorthand `{ a }` assigns local a from field a; `{ a: x }` assigns
         // x from field a (a PropertyAssignment whose initializer is the
         // target — JS reuses the literal syntax with inverted roles).
@@ -6263,7 +7433,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
                 lowerer.unsupported("SC1031", prop, "rest bindings over index-signature shapes (the undeclared entries would need overflow packing)");
             }
             const consumed = new Set();
-            for (const p of target.properties) {
+            for (const p of target.properties.nodes) {
                 if (ts.isShorthandPropertyAssignment(p))
                     consumed.add(p.name.text);
                 else if (ts.isPropertyAssignment(p)) {
@@ -6278,7 +7448,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
             if (restOrder !== undefined) {
                 lowerer.shapeOrderMetadataFinalizers.push(lowerer.shapes.declaredOrderFinalizer(restShapeId, restOrder, () => lowerer.shapes.get(srcType.shapeId)?.declaredOrder?.filter((n) => !consumed.has(n))));
             }
-            const packed = {
+            const packed = lowerer.keyOrder.copy({
                 kind: "recordLit",
                 fields: remaining.map((f) => ({
                     name: f.name,
@@ -6293,7 +7463,7 @@ function destructuringAssignInto(lowerer, target, init, rhs, blame, loc) {
                 })),
                 type: { kind: "record", shapeId: restShapeId },
                 loc: locOf(prop),
-            };
+            }, srcType.shapeId);
             if (!ts.isIdentifier(restTo)) {
                 // `({ a, ...box.rest } = src)` — the rest packs identically and
                 // lands through the property/element write machinery.
@@ -6439,7 +7609,7 @@ function lowerAssignTargetInto(lowerer, out, targetNode, blame, dflt, valueOf) {
             if (arr.type.kind === "array") {
                 const recv = lowerer.declareHiddenLocal("%dtRecv", arr.type);
                 out.push({ kind: "varDecl", localId: recv.id, init: arr, loc });
-                const index = lowerer.lowerExpr(t.argumentExpression);
+                const index = lowerOptionalNumber(lowerer, lowerer.lowerExpr(t.argumentExpression), locOf(t.argumentExpression), t.argumentExpression);
                 if (index.type.kind !== "f64") {
                     lowerer.unsupported("SC1090", t.argumentExpression, "indexing with non-number keys");
                 }
@@ -6452,6 +7622,30 @@ function lowerAssignTargetInto(lowerer, out, targetNode, blame, dflt, valueOf) {
                 return;
             }
         }
+        else if (recvT?.kind === "bytes") {
+            // A typed-array element (`[a[i], b[i]] = [h, l]`): the receiver, then
+            // the index, then the value, as the plain element write `b[i] = v`
+            // stores it (an f64 the runtime coerces; invalid indices are ignored).
+            const arr = lowerer.lowerExpr(t.expression);
+            if (arr.type.kind === "bytes") {
+                const recv = lowerer.declareHiddenLocal("%dtRecv", arr.type);
+                out.push({ kind: "varDecl", localId: recv.id, init: arr, loc });
+                const index = lowerer.lowerExpr(t.argumentExpression);
+                if (index.type.kind !== "f64") {
+                    lowerer.unsupported("SC1090", t.argumentExpression, "indexing with non-number keys");
+                }
+                const idx = lowerer.declareHiddenLocal("%dtIdx", F64);
+                out.push({ kind: "varDecl", localId: idx.id, init: index, loc });
+                out.push({
+                    kind: "bytesSet",
+                    arr: varRef(recv.id, arr.type, loc),
+                    index: varRef(idx.id, F64, loc),
+                    value: lowerer.coerceInto(blame, valueOf(F64), F64),
+                    loc,
+                });
+                return;
+            }
+        }
         else if (recvT?.kind === "record") {
             // Tuple positions and LITERAL declared record keys are field
             // writes (the element-write lowering's own rule); runtime keys
@@ -6538,7 +7732,7 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
     // array divergence). The EMPTY pattern skips the split — GetIterator
     // + close, nothing observable — through the iterable early-return
     // below. Callers vetted the source as a checker-typed string.
-    if (srcType.kind === "string" && target.elements.length > 0) {
+    if (srcType.kind === "string" && target.elements.nodes.length > 0) {
         const charsT = arrayOf(STRING);
         const chars = lowerer.declareHiddenLocal("%dchars", charsT);
         out.push({
@@ -6556,11 +7750,11 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
     // consumes exactly the elements the inner pattern alone would, so the
     // unwrap is exact. Identifier rest operands pack in the element loop
     // below.
-    let elements = target.elements;
+    let elements = target.elements.nodes;
     if (elements.length === 1 &&
         ts.isSpreadElement(elements[0]) &&
         ts.isArrayLiteralExpression(elements[0].expression)) {
-        elements = elements[0].expression.elements;
+        elements = elements[0].expression.elements.nodes;
     }
     // The element-read builder per source kind; null when the source
     // cannot destructure.
@@ -6753,6 +7947,14 @@ function lowerArrayAssignInto(lowerer, out, target, tmpRef, blame, loc) {
  * specific diagnostics; other iterables fail on their types. The loop
  * variable is a fresh const binding per iteration (its own scope, like a
  * loop body). */
+/** Whether a `for await` head is untyped: the checker answers any or
+ * unknown, or a type that maps to a checked-dynamic value. */
+function isUntypedIterable(lowerer, node) {
+    const type = lowerer.typeOf(node);
+    if ((type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0)
+        return true;
+    return lowerer.mapTypeOf(type)?.kind === "dyn";
+}
 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
@@ -6787,13 +7989,43 @@ export function lowerForOf(lowerer, stmt) {
                 }
             }
         }
+        {
+            const opened = classAsyncGeneratorIterator(lowerer, stmt.expression);
+            if (opened)
+                return lowerForAwaitGenerator(lowerer, stmt, opened, labels);
+        }
         if (ts.isPropertyAccessExpression(stmt.expression) &&
             lowerer.stdlibGlobalMember(stmt.expression, "process") === "stdin") {
             return lowerForAwaitStdin(lowerer, stmt);
         }
+        // A checked-dynamic NodeJS.ReadableStream iterates its native stream.
+        const dynStream = lowerForAwaitDynStream(lowerer, stmt, () => lowerForAwaitBuiltin(lowerer, stmt));
+        if (dynStream)
+            return dynStream;
         const builtin = lowerForAwaitBuiltin(lowerer, stmt);
         if (builtin)
             return builtin;
+        // An untyped value (a JavaScript async generator whose recursive
+        // return the checker types `any`): a compiled async generator steps
+        // natively; any other value takes the checked-dynamic async protocol.
+        // A synchronous generator, and in JavaScript any other head that
+        // reaches here, takes the same protocol: values of a synchronous
+        // iterator are awaited as the async-from-sync iterator awaits them, and
+        // a value that is not iterable throws Node's TypeError.
+        const headT = lowerer.mapTypeOf(lowerer.typeOf(stmt.expression));
+        const syncGenerator = (headT?.kind === "generator" && headT.async !== true) || isJsSourceFile(stmt.getSourceFile());
+        if (lowerer.ctx.isAsync && (syncGenerator || isUntypedIterable(lowerer, stmt.expression))) {
+            const iterable = lowerer.lowerExpr(stmt.expression);
+            if (iterable.type.kind === "generator" && iterable.type.async)
+                return lowerForAwaitGenerator(lowerer, stmt, iterable, labels);
+            if (iterable.type.kind === "dyn")
+                return lowerForOfDyn(lowerer, stmt, iterable, labels, true);
+            if ((iterable.type.kind === "generator" || isJsSourceFile(stmt.getSourceFile())) &&
+                lowerer.dynConvertible(iterable.type))
+                return lowerForOfDyn(lowerer, stmt, lowerer.coerceToExpected(iterable, DYN), labels, true);
+        }
+        // A NodeJS.ReadableStream iterates as the general Readable.
+        requestGeneralStreamSurface(lowerer, stmt.expression);
         lowerer.unsupported("SC1070", stmt, "'for await' over this value (supported: typed async generators, represented class async iterators, process.stdin, and Node/Web readable streams)");
     }
     if (awaitArray && !lowerer.ctx.isAsync) {
@@ -6816,6 +8048,13 @@ export function lowerForOf(lowerer, stmt) {
             }
         }
     }
+    // A head that is a chain of iterator-helper stages runs as one loop
+    // over the chain's source.
+    {
+        const fused = lowerForOfHelperChain(lowerer, stmt, labels);
+        if (fused)
+            return fused;
+    }
     // `for (const k of m.keys())` / `.values()` / `.entries()`: the
     // iterator methods consumed DIRECTLY by a for-of head ride the
     // container's live walk — exactly `for..of m` with the projection
@@ -6828,7 +8067,7 @@ export function lowerForOf(lowerer, stmt) {
         while (ts.isParenthesizedExpression(src))
             src = src.expression;
         if (ts.isCallExpression(src) &&
-            src.arguments.length === 0 &&
+            src.arguments.nodes.length === 0 &&
             !src.questionDotToken &&
             ts.isPropertyAccessExpression(src.expression) &&
             !src.expression.questionDotToken &&
@@ -6886,7 +8125,7 @@ export function lowerForOf(lowerer, stmt) {
             src = src.expression;
         const constIdentBinding = ts.isVariableDeclarationList(stmt.initializer) &&
             (stmt.initializer.flags & ts.NodeFlags.Const) !== 0 &&
-            ts.isIdentifier(stmt.initializer.declarations[0].name);
+            ts.isIdentifier(stmt.initializer.declarations.nodes[0].name);
         if (constIdentBinding) {
             const call = directMatchAllCallOf(lowerer, src);
             if (call)
@@ -6918,7 +8157,7 @@ export function lowerForOf(lowerer, stmt) {
             e = e.expression;
         if (ts.isCallExpression(e) &&
             !e.questionDotToken &&
-            e.arguments.length === 0 &&
+            e.arguments.nodes.length === 0 &&
             ts.isPropertyAccessExpression(e.expression) &&
             !e.expression.questionDotToken &&
             e.expression.name.text === "values" &&
@@ -6992,6 +8231,11 @@ export function lowerForOf(lowerer, stmt) {
             return lowerForOfGenerator(lowerer, stmt, iterable, labels);
         }
         if (iterable.type.kind === "object") {
+            // A [Symbol.iterator] generator method: the loop drives the
+            // generator it returns.
+            const generator = classGeneratorIterable(lowerer, iterable);
+            if (generator)
+                return lowerForOfGenerator(lowerer, stmt, generator, labels);
             // Class iterables ([Symbol.iterator]() + next() — classIteratorOf)
             // drive the same protocol with ordinary method calls.
             const cit = lowerer.classIteratorOf(iterable.type);
@@ -7038,9 +8282,11 @@ export function lowerForOf(lowerer, stmt) {
         }
         // A CHECKED-DYNAMIC iterable (`unknown[]`, the collapsed
         // `(string | object)[]`, JSON-parsed values): a checked IteratorRecord
-        // binds each yielded dyn value.
+        // binds each yielded dyn value. Under `for await` (a JavaScript array
+        // literal mixing promises and plain values) the async-from-sync rules
+        // await each value.
         if (iterable.type.kind === "dyn") {
-            return lowerForOfDyn(lowerer, stmt, iterable, labels);
+            return lowerForOfDyn(lowerer, stmt, iterable, labels, stmt.awaitModifier !== undefined);
         }
         if (tupleSource === null) {
             lowerer.badType(stmt.expression, lowerer.typeOf(stmt.expression));
@@ -7376,7 +8622,7 @@ export function lowerForOf(lowerer, stmt) {
     const list = stmt.initializer;
     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
+    const decl = list.declarations.nodes[0]; // the grammar allows exactly one
     // `for (const [k, v] of pairs)` — a destructuring loop variable: the
     // element binds to a hidden per-iteration local and the pattern
     // desugars to reads of it at the top of the body, exactly the
@@ -7406,7 +8652,7 @@ export function lowerForOf(lowerer, stmt) {
         // local and the body opens by ASSIGNING it into the one hoisted
         // binding — closures capture the shared slot, and the value persists
         // after the loop (both Node-exact for var).
-        const varTarget = forOfVarTarget(lowerer, decl);
+        const varTarget = forOfVarTarget(lowerer, decl, elemValueT);
         if (varTarget) {
             const elemType = elemValueT;
             const loc = locOf(decl.name);
@@ -7523,7 +8769,7 @@ function lowerForOfStoredNumericIterator(lowerer, stmt, state, labels) {
         lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
     }
     const isLet = list !== null && (list.flags & ts.NodeFlags.Let) !== 0;
-    const decl = list ? list.declarations[0] : null;
+    const decl = list ? list.declarations.nodes[0] : null;
     if (decl && !ts.isIdentifier(decl.name))
         lowerer.unsupported("SC1031", decl.name);
     const loc = locOf(stmt);
@@ -7651,13 +8897,13 @@ function directMatchAllCallOf(lowerer, e) {
         src = src.expression;
     if (ts.isCallExpression(src) &&
         !src.questionDotToken &&
-        src.arguments.length === 1 &&
+        src.arguments.nodes.length === 1 &&
         ts.isPropertyAccessExpression(src.expression) &&
         !src.expression.questionDotToken &&
         src.expression.name.text === "matchAll" &&
         lowerer.isStdlibMember(src.expression) &&
         lowerer.mapTypeOf(lowerer.typeOf(src.expression.expression))?.kind === "string" &&
-        lowerer.mapTypeOf(lowerer.typeOf(src.arguments[0]))?.kind === "regex") {
+        lowerer.mapTypeOf(lowerer.typeOf(src.arguments.nodes[0]))?.kind === "regex") {
         return src;
     }
     return null;
@@ -7682,7 +8928,7 @@ function directMatchAllCallOf(lowerer, e) {
  */
 function lowerForOfMatchAll(lowerer, stmt, call, stored) {
     const list = stmt.initializer;
-    const decl = list.declarations[0];
+    const decl = list.declarations.nodes[0];
     const name = decl.name;
     const loc = locOf(stmt);
     const rowT = arrayOf(STRING);
@@ -7696,7 +8942,7 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
     if (call !== null) {
         const access = call.expression;
         const receiver = lowerer.lowerExpr(access.expression);
-        const re = lowerer.lowerExpr(call.arguments[0]);
+        const re = lowerer.lowerExpr(call.arguments.nodes[0]);
         const idxs = lowerer.declareHiddenLocal("%midxs", idxsT);
         idxsLocalId = idxs.id;
         prelude.push({
@@ -7707,7 +8953,9 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
         });
         rowsInit = {
             kind: "regexIntrinsic",
-            method: "matchAllInto",
+            method: matchAllRowsReadByElements(lowerer, call, true)
+                ? "matchAllCapturesInto"
+                : "matchAllInto",
             receiver,
             args: [re, { kind: "varRef", localId: idxs.id, type: idxsT, loc }],
             type: rowsT,
@@ -7846,7 +9094,7 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
         lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
     }
     const isLet = list !== null && (list.flags & ts.NodeFlags.Let) !== 0;
-    const decl = list ? list.declarations[0] : null;
+    const decl = list ? list.declarations.nodes[0] : null;
     if (decl && !ts.isIdentifier(decl.name))
         lowerer.unsupported("SC1031", decl.name);
     const loc = locOf(stmt);
@@ -7942,24 +9190,9 @@ function lowerForOfClassIterator(lowerer, stmt, iterable, cit, labels) {
 /** A checked IteratorRecord stays live throughout the loop. Cache next once,
  * read done before value, and close only after a yielded value has arrived.
  * Abrupt body throws retain precedence over errors raised by return(). */
-function lowerForOfDyn(lowerer, stmt, iterable, labels) {
+function lowerForOfDyn(lowerer, stmt, iterable, labels, asyncLoop = false) {
     const loc = locOf(stmt);
-    const headText = (e) => {
-        if (ts.isIdentifier(e))
-            return e.text;
-        if (ts.isPropertyAccessExpression(e) && !e.questionDotToken && ts.isIdentifier(e.name)) {
-            const base = headText(e.expression);
-            return base === null ? null : `${base}.${e.name.text}`;
-        }
-        return null;
-    };
-    const name = headText(stmt.expression);
-    const callee = ts.isCallExpression(stmt.expression) ? headText(stmt.expression.expression) : null;
-    const spell = name !== null
-        ? `${name} is not iterable`
-        : callee !== null
-            ? `${callee} is not a function or its return value is not iterable`
-            : "";
+    const spell = notIterableSpelling(stmt.expression, asyncLoop ? "async iterable" : "iterable");
     const iterator = lowerer.declareHiddenLocal("%dofIterator", DYN);
     const next = lowerer.declareHiddenLocal("%dofNext", DYN);
     const fast = lowerer.declareHiddenLocal("%dofNative", BOOL);
@@ -7970,6 +9203,14 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
     const needsClose = lowerer.declareHiddenLocal("%dofNeedsClose", BOOL);
     needsClose.mutable = true;
     const error = lowerer.declareHiddenLocal("%dofError", CAUGHT);
+    const syncIterator = asyncLoop ? lowerer.declareHiddenLocal("%dofSync", BOOL) : null;
+    const awaitDyn = (value) => ({
+        kind: "libCall",
+        fn: "async.awaitDyn",
+        args: [value],
+        type: DYN,
+        loc,
+    });
     const get = (source, key) => ({
         kind: "dynKeyGet",
         value: source,
@@ -8021,7 +9262,24 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
                 type: BOOL,
                 loc,
             },
-            then: [{ kind: "exprStmt", expr: call(varRef(returned.id, DYN, loc)), loc }],
+            then: [
+                {
+                    kind: "exprStmt",
+                    // return()'s (awaited) result must be an object, as for next().
+                    expr: asyncLoop
+                        ? check(awaitDyn({
+                            kind: "dynCall",
+                            callee: varRef(returned.id, DYN, loc),
+                            receiver: varRef(iterator.id, DYN, loc),
+                            calleeName: "iterator method",
+                            args: [],
+                            type: DYN,
+                            loc,
+                        }))
+                        : call(varRef(returned.id, DYN, loc)),
+                    loc,
+                },
+            ],
             else_: null,
             loc,
         },
@@ -8063,14 +9321,14 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
                 lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
             }
             const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
-            const decl = list.declarations[0];
+            const decl = list.declarations.nodes[0];
             if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
                 const tmp = lowerer.declareHiddenLocal("%destr", DYN);
                 binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
                 lowerer.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: DYN, loc }), DYN, isLet, binds);
             }
             else if (ts.isIdentifier(decl.name)) {
-                const varTarget = forOfVarTarget(lowerer, decl);
+                const varTarget = forOfVarTarget(lowerer, decl, DYN);
                 if (varTarget) {
                     // `for (var x of d)`: the element mechanics stay on a hidden
                     // per-iteration local; the body opens by assigning the ONE
@@ -8102,7 +9360,9 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
                 {
                     kind: "varDecl",
                     localId: value.id,
-                    init: iteratorValue(lowerer, varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), varRef(fast.id, BOOL, loc), done, loc, "iterator method"),
+                    init: syncIterator
+                        ? asyncIteratorValue(lowerer, varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), varRef(syncIterator.id, BOOL, loc), done, loc)
+                        : iteratorValue(lowerer, varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), varRef(fast.id, BOOL, loc), done, loc, "iterator method"),
                     loc,
                 },
                 {
@@ -8127,13 +9387,29 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
                     localId: iterator.id,
                     init: check({
                         kind: "libCall",
-                        fn: "dyn.iterator",
+                        fn: asyncLoop ? "dyn.asyncIteratorOpen" : "dyn.iterator",
                         args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }],
                         type: DYN,
                         loc,
                     }),
                     loc,
                 },
+                ...(syncIterator
+                    ? [
+                        {
+                            kind: "varDecl",
+                            localId: syncIterator.id,
+                            init: {
+                                kind: "libCall",
+                                fn: "dyn.asyncIteratorWasSync",
+                                args: [],
+                                type: BOOL,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ]
+                    : []),
                 {
                     kind: "varDecl",
                     localId: next.id,
@@ -8143,7 +9419,9 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
                 {
                     kind: "varDecl",
                     localId: fast.id,
-                    init: iteratorCanStep(varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), loc),
+                    init: asyncLoop
+                        ? { kind: "boolLit", value: false, type: BOOL, loc }
+                        : iteratorCanStep(varRef(iterator.id, DYN, loc), varRef(next.id, DYN, loc), loc),
                     loc,
                 },
                 {
@@ -8195,6 +9473,91 @@ function lowerForOfDyn(lowerer, stmt, iterable, labels) {
         lowerer.scopes.pop();
     }
 }
+/** One step of `for await` over a checked-dynamic iterator: await next()'s
+ * result, read done before value, and await each value of a synchronous
+ * iterator, including its final one, as the async-from-sync iterator does. */
+function asyncIteratorValue(lowerer, iterator, next, sync, done, loc) {
+    const result = lowerer.declareHiddenLocal("%asyncIteratorResult", DYN);
+    const get = (key) => ({
+        kind: "dynKeyGet",
+        value: varRef(result.id, DYN, loc),
+        key: { kind: "strLit", value: key, type: STRING, loc },
+        type: DYN,
+        loc,
+    });
+    const awaitDyn = (value) => ({
+        kind: "libCall",
+        fn: "async.awaitDyn",
+        args: [value],
+        type: DYN,
+        loc,
+    });
+    return {
+        kind: "seqExpr",
+        type: DYN,
+        loc,
+        stmts: [
+            {
+                kind: "varDecl",
+                localId: result.id,
+                init: {
+                    kind: "libCall",
+                    fn: "dyn.iteratorResult",
+                    args: [
+                        awaitDyn({
+                            kind: "dynCall",
+                            callee: next,
+                            receiver: iterator,
+                            calleeName: "iterator method",
+                            args: [],
+                            type: DYN,
+                            loc,
+                        }),
+                    ],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            },
+            {
+                kind: "assign",
+                localId: done.id,
+                value: { kind: "dynTest", test: "truthy", value: get("done"), type: BOOL, loc },
+                loc,
+            },
+        ],
+        // A synchronous iterator's final value is still read and awaited, so a
+        // throwing getter or a rejected promise there rejects the loop.
+        result: {
+            kind: "ternary",
+            cond: sync,
+            then: {
+                kind: "ternary",
+                cond: varRef(done.id, BOOL, loc),
+                then: {
+                    kind: "seqExpr",
+                    stmts: [{ kind: "exprStmt", expr: awaitDyn(get("value")), loc }],
+                    result: dynUndefinedExpr(loc),
+                    type: DYN,
+                    loc,
+                },
+                else_: awaitDyn(get("value")),
+                type: DYN,
+                loc,
+            },
+            else_: {
+                kind: "ternary",
+                cond: varRef(done.id, BOOL, loc),
+                then: dynUndefinedExpr(loc),
+                else_: get("value"),
+                type: DYN,
+                loc,
+            },
+            type: DYN,
+            loc,
+        },
+    };
+}
 function lowerForOfString(lowerer, stmt, iterable, labels) {
     let exprTarget = null;
     let exprTargetNode = null;
@@ -8224,7 +9587,7 @@ function lowerForOfString(lowerer, stmt, iterable, labels) {
         lowerer.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
     }
     const isLet = list !== null && (list.flags & ts.NodeFlags.Let) !== 0;
-    const decl = list ? list.declarations[0] : null; // the grammar allows exactly one
+    const decl = list ? list.declarations.nodes[0] : null; // the grammar allows exactly one
     const loc = locOf(stmt);
     lowerer.scopes.push(new Map());
     try {
@@ -8383,7 +9746,7 @@ function lowerForIn(lowerer, stmt) {
         while (root?.base)
             root = root.base;
         if (info?.decl &&
-            isJsSourceFile(info.decl.getSourceFile()) &&
+            isJsSourceFile(ts.getSourceFileOfNode(info.decl)) &&
             !info.def.runtime &&
             !root?.def.runtime &&
             !info.builtinError &&
@@ -8536,7 +9899,7 @@ function lowerForInOverKeys(lowerer, stmt, keys, labels, guard) {
         lowerer.unsupported("SC1090", stmt.initializer, "for-in over this assignment target (declare the key in the head — for (const k in obj) — or assign a plain declared variable)");
     }
     const list = stmt.initializer;
-    const decl = list.declarations[0]; // the grammar allows exactly one
+    const decl = list.declarations.nodes[0]; // the grammar allows exactly one
     if (!ts.isIdentifier(decl.name))
         lowerer.unsupported("SC1031", decl.name);
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
@@ -8633,7 +9996,7 @@ function lowerForInArray(lowerer, stmt, labels, arrExpr) {
             ];
         }
         else {
-            const decl = stmt.initializer.declarations[0];
+            const decl = stmt.initializer.declarations.nodes[0];
             if (!ts.isIdentifier(decl.name))
                 lowerer.unsupported("SC1031", decl.name);
             const isLet = (stmt.initializer.flags & ts.NodeFlags.Let) !== 0 ||
@@ -8736,7 +10099,7 @@ function lowerForAwaitStdin(lowerer, stmt) {
     // 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]; // the grammar allows exactly one
+    const decl = list.declarations.nodes[0]; // the grammar allows exactly one
     if (!ts.isIdentifier(decl.name))
         lowerer.unsupported("SC1031", decl.name);
     const loc = locOf(stmt);
@@ -8822,4 +10185,158 @@ export function lowerForStatement(lowerer, stmt) {
         lowerer.scopes.pop();
     }
 }
+/** safe-buffer's `var Buffer = buffer.Buffer` (or `var pna = process`, the
+ * process-nextick-args binding once it compiles as process) at file scope:
+ * a `var` alias of a surfaced global other than the global object itself
+ * is the same alias plumbing as the const spelling when nothing reassigns
+ * it and no code that runs before the declaration can read it (the
+ * require-binding early-reference analysis), so the hoisted undefined is
+ * unobservable. */
+export function stdlibBufferVarAlias(lowerer, decl) {
+    if (!ts.isIdentifier(decl.name) ||
+        !ts.isVariableDeclarationList(decl.parent) ||
+        (decl.parent.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0 ||
+        decl.initializer === undefined ||
+        !(bufferNamespaceMember(lowerer, decl.initializer) ||
+            (stdlibGlobalAliasNameOf(lowerer, decl.initializer) ?? "globalThis") !== "globalThis"))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+    return (symbol !== undefined &&
+        bindingNeverReassigned(lowerer, symbol, decl) &&
+        requireEarlyReference(lowerer.program, decl) === null);
+}
+/** A checker type that is a string or string literal (or a union of them). */
+function isStringTyped(t) {
+    if (t.isUnionType())
+        return ts.constituentTypes(t).every(isStringTyped);
+    return (t.flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral)) !== 0;
+}
+/** The Error-subclass prototype reset of transpiled code, inside a class
+ * constructor:
+ *
+ *     const proto = new.target.prototype;
+ *     if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+ *     else this.__proto__ = proto;
+ *
+ * (also `Object.setPrototypeOf(this, new.target.prototype)` and
+ * `Object.setPrototypeOf(this, C.prototype)` in C's own constructor when no
+ * class extends C). A compiled instance already has exactly that prototype,
+ * so each statement is a no-op. True for those statements. */
+function ownPrototypeResetStatement(lowerer, stmt) {
+    if (ts.isVariableStatement(stmt)) {
+        const decls = stmt.declarationList.declarations.nodes;
+        if (decls.length !== 1 || (stmt.declarationList.flags & ts.NodeFlags.Const) === 0)
+            return false;
+        const decl = decls[0];
+        if (!ts.isIdentifier(decl.name) || !decl.initializer)
+            return false;
+        const ctor = enclosingConstructor(decl);
+        if (!ctor || !ownPrototypeRef(lowerer, decl.initializer, ctor))
+            return false;
+        const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+        if (!symbol)
+            return false;
+        // Every other use of the binding must be one of the reset statements.
+        let onlyResets = true;
+        ts.walkPreorder(ctor, (n) => {
+            if (!onlyResets)
+                return "stop";
+            if (!ts.isIdentifier(n) || n === decl.name)
+                return undefined;
+            if (lowerer.checker.getSymbolAtLocation(n) !== symbol)
+                return undefined;
+            const statement = n.parent?.parent;
+            if (!statement ||
+                !ts.isExpressionStatement(statement) ||
+                resetTarget(lowerer, statement.expression) !== n)
+                onlyResets = false;
+            return undefined;
+        });
+        return onlyResets;
+    }
+    if (!ts.isExpressionStatement(stmt))
+        return false;
+    const ctor = enclosingConstructor(stmt);
+    if (!ctor)
+        return false;
+    const target = resetTarget(lowerer, stmt.expression);
+    return target !== null && ownPrototypeRef(lowerer, target, ctor);
+}
+/** The prototype operand of `Object.setPrototypeOf(this, P)` or
+ * `this.__proto__ = P`, or null. */
+function resetTarget(lowerer, expr) {
+    if (ts.isCallExpression(expr) &&
+        expr.arguments.nodes.length === 2 &&
+        expr.arguments.nodes[0].kind === ts.SyntaxKind.ThisKeyword &&
+        ts.isPropertyAccessExpression(expr.expression) &&
+        expr.expression.name.text === "setPrototypeOf" &&
+        lowerer.isStdlibGlobal(expr.expression.expression, "Object"))
+        return expr.arguments.nodes[1];
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isPropertyAccessExpression(expr.left) &&
+        expr.left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+        expr.left.name.text === "__proto__")
+        return expr.right;
+    return null;
+}
+/** The class constructor whose body holds `node`, crossing only statements
+ * and blocks (any nested function rebinds `this`). */
+function enclosingConstructor(node) {
+    for (let cur = node.parent; cur !== undefined; cur = cur.parent) {
+        if (ts.isConstructorDeclaration(cur))
+            return cur;
+        if (ts.isFunctionLike(cur) ||
+            ts.isClassDeclaration(cur) ||
+            ts.isClassExpression(cur) ||
+            ts.isSourceFile(cur))
+            return null;
+    }
+    return null;
+}
+/** Whether `node` denotes the prototype of the object `ctor` constructs:
+ * `new.target.prototype`, a const holding it, or the class's own
+ * `C.prototype` when no class extends C. */
+function ownPrototypeRef(lowerer, node, ctor) {
+    while (ts.isParenthesizedExpression(node))
+        node = node.expression;
+    if (ts.isPropertyAccessExpression(node) && node.name.text === "prototype") {
+        const base = node.expression;
+        if (ts.isMetaProperty(base) &&
+            base.keywordToken === ts.SyntaxKind.NewKeyword &&
+            base.name.text === "target")
+            return true;
+        const cls = ctor.parent;
+        if (!ts.isIdentifier(base) || !(ts.isClassDeclaration(cls) || ts.isClassExpression(cls)))
+            return false;
+        const symbol = lowerer.resolveValueSymbol(base);
+        const info = symbol ? lowerer.classBySymbol.get(symbol) : undefined;
+        if (!info || symbol.valueDeclaration !== cls)
+            return false;
+        for (const other of lowerer.classes.values()) {
+            if (other !== info && lowerer.isSubclassOf(other.def.name, info.def.name))
+                return false;
+        }
+        return true;
+    }
+    if (ts.isIdentifier(node)) {
+        const symbol = lowerer.resolveValueSymbol(node);
+        const decl = symbol?.valueDeclaration;
+        return (decl !== undefined &&
+            ts.isVariableDeclaration(decl) &&
+            decl.initializer !== undefined &&
+            ts.isVariableDeclarationList(decl.parent) &&
+            (decl.parent.flags & ts.NodeFlags.Const) !== 0 &&
+            enclosingConstructor(decl) === ctor &&
+            !ts.isIdentifier(decl.initializer) &&
+            ownPrototypeRef(lowerer, decl.initializer, ctor));
+    }
+    return false;
+}
+function isAssertionInitializer(node) {
+    let e = node;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return ts.isAsExpression(e) || ts.isTypeAssertion(e);
+}
 //# sourceMappingURL=lower-stmts.js.map