@scriptc/compiler 0.0.10 → 0.0.12

package/dist/frontend/lowering/lower-stmts.d.ts

@@ -98,7 +98,7 @@ export declare function hoistVarBinding(L: Lowerer, symbol: ts.Symbol, nameNode:
    * such reads `undefined`, never a TDZ error, so the hoisted slot must
    * hold `undefined` from function entry — which is only honest for
    * undefined-armed union types (the interned arm) and checked-dynamic
-   * bindings (the DOM undefined). Everything else returns false
+   * bindings (the dyn undefined). Everything else returns false
    * and the reference lands on the named fence in rejectUnresolvedSymbol:
    * a slot of a narrower type has no bit pattern for the `undefined` Node
    * would yield if the capture ran early, and guessing "it won't" is the

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

@@ -10,7 +10,7 @@ import { enforceLibBoundary } from "./lib-boundary.js";
 import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isJsSourceFile, locOf, requireSpecOf } from "../program.js";
 import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalNameOf } from "./surfaces.js";
 import { isProvenanceSourceFile } from "../provenance-registry.js";
-import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget } from "./lower-namespaces.js";
+import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
@@ -18,9 +18,9 @@ import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl, streamSidesOf } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf } from "./lower-builtins.js";
+import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
-import { abstractPropertyDeclOf, aliasTypeofNarrows, probeLower, pureReemittable, symbolFieldInfo } from "./lower-exprs.js";
+import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerGroupsProjection, matchResultNamedGroupsOf, probeLower, pureReemittable, symbolFieldInfo } from "./lower-exprs.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
 import { canonicalBuiltinModule, isRelativeSpecifier } from "../shared.js";
@@ -486,7 +486,7 @@ export function hoistVarBinding(L, symbol, nameNode) {
     const local = { id: `${name}.${count}`, name, type, mutable: true };
     L.ctx.locals.push(local);
     L.ctx.scopes[0].set(symbol, local);
-    // A checked-dynamic slot holds the DOM undefined (a NULL dyn is a
+    // A checked-dynamic slot holds the dyn undefined (a NULL dyn is a
     // trap); everything else rides unassignedSlotInit (interned union arm,
     // engine undefined for jsval).
     const wrapped = type.kind === "dyn" ? dynUndefinedExpr(locOf(nameNode)) : L.unassignedSlotInit(type, locOf(nameNode));
@@ -502,7 +502,7 @@ export function hoistVarBinding(L, symbol, nameNode) {
    * such reads `undefined`, never a TDZ error, so the hoisted slot must
    * hold `undefined` from function entry — which is only honest for
    * undefined-armed union types (the interned arm) and checked-dynamic
-   * bindings (the DOM undefined). Everything else returns false
+   * bindings (the dyn undefined). Everything else returns false
    * and the reference lands on the named fence in rejectUnresolvedSymbol:
    * a slot of a narrower type has no bit pattern for the `undefined` Node
    * would yield if the capture ran early, and guessing "it won't" is the
@@ -536,7 +536,7 @@ export function predeclareForwardVar(L, symbol) {
     const ctx = owner.ctx;
     // Only a slot that can hold `undefined` can carry the pre-
     // initialization reads: an undefined-armed union (the interned arm),
-    // a checked-dynamic binding (the DOM undefined), or a jsval 'any'
+    // a checked-dynamic binding (the dyn undefined), or a jsval 'any'
     // binding (the engine's undefined).
     const type = varBindingType(L, nameNode);
     if (!type)
@@ -757,7 +757,7 @@ export function lowerStmt(L, stmt) {
         // A bare `return;` in a union-returning function yields undefined
         // (JS), which the undefined arm carries — tsc only allows the bare
         // form when the return type includes undefined/void. A CHECKED-
-        // DYNAMIC return slot holds the DOM undefined directly (the
+        // DYNAMIC return slot holds the dyn undefined directly (the
         // appendImplicitUndefinedReturn rule). What remains is JS-only —
         // a JSDoc return claim the body contradicts (ms's parse: `@return
         // {Number}` with a bare early `return;`): no undefined fits the
@@ -819,11 +819,11 @@ export function lowerStmt(L, stmt) {
         const value = L.lowerExpr(stmt.expression);
         if (value.type.kind === "void")
             L.badType(stmt.expression, L.typeOf(stmt.expression));
-        // A dyn throw rides the REF cell arm (scr_throw_ref over the DOM
+        // A dyn throw rides the REF cell arm (scr_throw_ref over the checked-dynamic tree
         // node — identity preserved through catch bindings, caughtToDyn
         // passes it back by reference). The JS-lane traced-call shape:
-        // `throw err` where err arrived as a DOM argument. instanceof
-        // narrowing over the payload stays false (the DOM's %error encoding
+        // `throw err` where err arrived as a dyn argument. instanceof
+        // narrowing over the payload stays false (the checked-dynamic tree's %error encoding
         // is not a hierarchy object — SEMANTICS.md).
         return { kind: "throw", value, loc: locOf(stmt) };
     }
@@ -1018,7 +1018,7 @@ export function lowerDestructuringDecl(L, decl, isLet) {
     let init = L.lowerExpr(decl.initializer);
     // A TS `any`-origin source whose lowered value is NOT a destructurable
     // shape (`var { x } = <any>0` — the cast erases to the f64; a dyn
-    // value — the DOM has no destructure): JS reads the properties off
+    // value — the checked-dynamic tree has no destructure): JS reads the properties off
     // whatever the value is (a number answers undefined) — engine
     // semantics, the dynamic-family fence. Record and array sources fall
     // through to their lowerings, island handles to theirs (--dynamic
@@ -1103,6 +1103,39 @@ export function lowerDestructuringDecl(L, 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(L, 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(L, decl.initializer);
+        if (groups !== null && groups.length > 0) {
+            const proj = lowerGroupsProjection(L, init, groups, loc);
+            const outerShape = L.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 tmp = L.declareHiddenLocal("%destr", init.type);
     out.push({ kind: "varDecl", localId: tmp.id, init, loc });
     // V8's destructuring TypeError spells STATIC sources: an identifier
@@ -1243,16 +1276,16 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
             L.lowerBindingPattern(pattern, () => ({ kind: "varRef", localId: chars.id, type: charsT, loc }), charsT, isLet, out);
             return;
         }
-        // DYN sources (`const [a, b] = d` over a DOM value, `([_, code]) =>`
+        // DYN sources (`const [a, b] = d` over a dyn value, `([_, code]) =>`
         // params destructuring dyn callback arguments — the suite harness's
         // _expectWarning shapes): the source packs ONCE through the spread
         // walk (dyn.iterPack — arrays element-by-element, strings by code
         // point, bytes by byte; every other kind throws V8's destructuring
         // TypeError, the compile-time spelling when the source has one),
         // then positions bind the pack's index keys as dyn values — reads
-        // past the end bind undefined, exactly JS. Defaults fire on the DOM
+        // past the end bind undefined, exactly JS. Defaults fire on the checked-dynamic tree
         // undefined (JS's rule); rest elements keep the fence (surplus
-        // packing over the DOM needs a slice the IR does not spell yet).
+        // packing over the checked-dynamic tree needs a slice the IR does not spell yet).
         if (srcType.kind === "dyn") {
             const loc = locOf(pattern);
             const pack = L.declareHiddenLocal("%dpack", DYN);
@@ -1283,14 +1316,14 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
                     loc: elLoc,
                 };
                 if (el.initializer) {
-                    // The default fires exactly on the DOM undefined (JS's rule),
-                    // its value converting into the DOM like any dyn-slot value.
+                    // The default fires exactly on the dyn undefined (JS's rule),
+                    // its value converting into the checked-dynamic tree like any dyn-slot value.
                     const rl = L.declareHiddenLocal("%delem", DYN);
                     out.push({ kind: "varDecl", localId: rl.id, init: value, loc: elLoc });
                     const ref = () => ({ kind: "varRef", localId: rl.id, type: DYN, loc: elLoc });
                     const dflt = L.coerceToExpected(L.lowerExpr(el.initializer), DYN);
                     if (dflt.type.kind !== "dyn") {
-                        L.unsupported("SC1031", el.initializer, `defaults of '${L.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the DOM)`);
+                        L.unsupported("SC1031", el.initializer, `defaults of '${L.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the checked-dynamic tree)`);
                     }
                     value = {
                         kind: "ternary",
@@ -1586,6 +1619,29 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
             continue;
         }
         const fieldType = shape.fields.find((f) => f.name === propName)?.type;
+        if (!fieldType && shape.indexValue !== undefined && !shape.tuple) {
+            // 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).
+            const loc = locOf(el);
+            let value = {
+                kind: "recordKeyGet",
+                obj: srcRef(),
+                shapeId: srcType.shapeId,
+                key: { kind: "strLit", value: propName, type: STRING, loc },
+                overflowOnly: true,
+                type: shape.indexValue,
+                loc,
+            };
+            if (el.initializer)
+                value = applyBindingDefault(L, el, value);
+            L.bindPatternTarget(el.name, value, isLet, out);
+            continue;
+        }
         if (!fieldType) {
             // The pattern names a field the source SHAPE does not carry —
             // `for (let {x = 1} of [{}])` (signature 08): tsc types the binding
@@ -2481,7 +2537,7 @@ export function bindPatternTarget(L, name, value, isLet, out) {
         // a pattern binding whose VALUE lowered checked-dynamic stays dyn
         // where the checker spells an island-world type (`function f({
         // plugins = [] } = {})` over a JSDoc '(string | object)[]=' member —
-        // the read is a DOM keyed read whose members may be wrapped island
+        // the read is a dyn keyed read whose members may be wrapped island
         // values) or a type with no mapping at all (the varDecl rule's
         // unmappable-declared-type stance, `string | object` bindings
         // included). Marshaling here would fence or deep-copy; the value's
@@ -2566,8 +2622,10 @@ export function lowerVarDecl(L, decl, isLet) {
     // statement lowers to exactly that throw; the binding registers as a
     // trap (references lower to the same never-reached shape), and no
     // storage or type mapping is needed for a value that never exists.
-    if (decl.initializer !== undefined) {
-        const root = ambientUndefVarRootOf(L, decl.initializer);
+    // Written bindings keep ordinary storage (trapDeclRootOf) — the
+    // initializer read still lowers to the root's throw below.
+    {
+        const root = trapDeclRootOf(L, decl);
         if (root !== null) {
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const sym = L.checker.getSymbolAtLocation(nameNode);
@@ -2631,6 +2689,17 @@ export function lowerVarDecl(L, decl, isLet) {
     // skipped its global by the same test).
     if (builtinMemberRequireDecl(decl.name, decl.initializer))
         return null;
+    // `const require = createRequire(import.meta.url)` — compile-time
+    // plumbing: each call through the binding resolves per site
+    // (lowerCreateRequireCall); no storage, no code (collectGlobals
+    // skipped its global by the same test).
+    if (!isLet && createRequireBindingDecl(L, decl.name, decl.initializer))
+        return null;
+    // `const fs = require("node:fs")` through that binding — a builtin
+    // namespace import in const clothing: alias plumbing, no storage
+    // (builtinNamespaceModuleOf resolves member uses).
+    if (!isLet && createRequireNamespaceDecl(L, decl.name, decl.initializer))
+        return null;
     // `const { NGHTTP2_CANCEL } = http2.constants` — a destructure over
     // the baked constants table: alias plumbing, no storage (uses read
     // their literals via http2ConstantBindingOf; collectGlobals skipped
@@ -2721,7 +2790,7 @@ export function lowerVarDecl(L, decl, isLet) {
             // a loop — must NOT reset the persisting binding.
             if (isVarDeclared(decl))
                 return null;
-            // Checked-dynamic globals hold the DOM undefined from their
+            // Checked-dynamic globals hold the dyn undefined from their
             // declaration statement on; unions and jsval ride
             // unassignedSlotInit's arms.
             const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(locOf(decl)) : L.unassignedSlotInit(g.type, locOf(decl));
@@ -2776,7 +2845,7 @@ export function lowerVarDecl(L, decl, isLet) {
         const local = L.declareLocal(decl.name, decl.name.text, type, isLet);
         // tsc's definite-assignment analysis never guards `any` reads, so
         // uninitialized bindings must hold their world's undefined, never
-        // NULL: unions the interned arm, dyn the DOM undefined, jsval the
+        // NULL: unions the interned arm, dyn the dyn undefined, jsval the
         // engine's — all readable immediately, exactly Node.
         const init = type.kind === "dyn" ? dynUndefinedExpr(locOf(decl)) : L.unassignedSlotInit(type, locOf(decl));
         return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
@@ -2800,7 +2869,7 @@ export function lowerVarDecl(L, decl, isLet) {
     }
     // A dyn initializer under an unmappable declared type (`const ws =
     // pkg.workspaces` — the lowering world types the unknown-receiver read
-    // `any`, which a static build cannot hold): the VALUE is a DOM
+    // `any`, which a static build cannot hold): the VALUE is a dyn
     // subtree, so the local stays dyn — later narrowing tests and checked
     // casts read it like any JSON.parse result.
     // `const p = import("./m")` / `const ns = await import("./m")`: the
@@ -2825,7 +2894,7 @@ export function lowerVarDecl(L, decl, isLet) {
         // the island-HANDLE local rule's mirror): a binding whose
         // INITIALIZER lowered checked-dynamic stays dyn even where the
         // checker spells 'any' (`const parsers = options.parsers ?? {}` over
-        // an 'object'-typed bag — the read is a DOM keyed read). Marshaling
+        // an 'object'-typed bag — the read is a dyn keyed read). Marshaling
         // into the engine here would deep-copy data and sever aliasing; the
         // value's world is the honest dispatch, and every use site already
         // handles dyn (validated exits, routed engine ops for wrapped
@@ -2852,7 +2921,7 @@ export function lowerVarDecl(L, decl, isLet) {
     // pushes of anything non-numeric would fence and typed exits would
     // mismatch the checker's evolved reads downstream. The binding is
     // checked-dynamic instead (the `let x = {}` stance, and lower-modules'
-    // file-scope evolving-array rule): pushes ride the DOM array, typed
+    // file-scope evolving-array rule): pushes ride the dyn array, typed
     // exits dynCheck.
     if ((type === null || type.kind === "array") && isJsSourceFile(decl.getSourceFile())) {
         let initExpr = decl.initializer;
@@ -2931,6 +3000,15 @@ export function lowerVarDecl(L, decl, isLet) {
     // bridge is an independent observer of the same settlement).
     if (init.type.kind === "jsval" && type.kind === "promise")
         type = JSVAL;
+    // An island value under an `any[]`-declared LOCAL spelling stays an
+    // island HANDLE too (the runtime-world rule): the jsval-element-array
+    // exit is a CALL-boundary conversion (the loadPlugins param ABI) —
+    // converting a local would strand the engine's own prototypes
+    // (join/map/... on a native handle-element array), where the handle
+    // routes every use engine-side.
+    if (init.type.kind === "jsval" && type.kind === "array" && type.elem.kind === "jsval") {
+        type = JSVAL;
+    }
     // A STATIC array of island HANDLES under an unannotated declared type
     // spelling evolved elements (`const kept = fns.filter(...)` over an
     // evolving-`any` receiver — the handle-element lowering keeps the
@@ -3647,7 +3725,12 @@ export function lowerExprStatement(L, expr) {
         ts.isExpressionStatement(stmtNode) &&
         ts.isSourceFile(stmtNode.parent) &&
         isJsSourceFile(stmtNode.parent);
-    if (requireSpecOf(expr) !== null && ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+    if (requireSpecOf(expr) !== null &&
+        ts.isCallExpression(expr) &&
+        ts.isIdentifier(expr.expression) &&
+        // A binding NAMED require made by createRequire is not the CJS
+        // global — the expression path owns it (lowerCreateRequireCall).
+        createRequireCalleeFileOf(L, expr.expression) === null) {
         const sf = expr.getSourceFile();
         // A bare require of a package NOTHING INSTALLED resolves, in ANY
         // CommonJS JS file (the export-assignment spellings tsgo marks
@@ -3773,7 +3856,7 @@ export function lowerExprStatement(L, expr) {
                     const loc = locOf(expr);
                     // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
                     // receiver whose value LOWERED checked-dynamic (`bag.nested.x
-                    // = v` behind an 'object'-typed bag) takes the DOM keyed
+                    // = v` behind an 'object'-typed bag) takes the dyn keyed
                     // write — the routed JSVAL arm lands it on the real engine
                     // object.
                     if (obj.type.kind === "dyn") {
@@ -3870,7 +3953,7 @@ export function lowerExprStatement(L, expr) {
                 }
                 // `h.onDone = cb` on a CHECKED-DYNAMIC receiver (a JS `let h =
                 // {}` evolving object, an implicit-any param, a dyn member
-                // chain): the DOM keyed write — the value converts INTO dyn
+                // chain): the dyn keyed write — the value converts INTO dyn
                 // (closures box), the runtime sets the member on OBJ receivers
                 // and throws Node's TypeErrors on the rest. The receiver is
                 // PROBED (probeLower) and claimed exactly when it lowers to
@@ -3890,7 +3973,7 @@ export function lowerExprStatement(L, expr) {
                 }
                 // `events.defaultMaxListeners = v` in STATEMENT position — the
                 // module-property write Node validates (the lowerBinary
-                // expression twin): the value crosses into the DOM, the runtime
+                // expression twin): the value crosses into the checked-dynamic tree, the runtime
                 // ladder throws Node's exact errors, valid numbers apply.
                 if (!expr.left.questionDotToken && expr.left.name.text === "defaultMaxListeners") {
                     const bi = L.builtinMemberOf(expr.left);
@@ -4194,7 +4277,7 @@ function lowerCompoundToTarget(L, expr, compound, target) {
         isJsSourceFile(expr.getSourceFile())) {
         // JS any-origin operands: check to number and compute natively
         // (the binary-operator stance) — the dyn target takes the result
-        // back through the usual DOM conversion.
+        // back through the usual dyn conversion.
         const checkNum = (e) => e.type.kind === "dyn" ? { kind: "dynCheck", value: e, type: F64, loc: e.loc } : e;
         const computed = { kind: "bin", op: compound, left: checkNum(read), right: checkNum(rhs), type: F64, loc };
         value = target.type.kind === "dyn" ? { kind: "dynFrom", value: computed, type: DYN, loc } : computed;
@@ -5026,7 +5109,7 @@ function destructAssignPiece(L, prop, islandSource) {
         // keys resolve statically (the record path's rule) — the keyed read
         // below takes the folded name. A RUNTIME-valued key over an ISLAND
         // source reads through the engine's own indexing at the element's
-        // pattern position (`({ [key]: w } = src)`); over the DOM the fence
+        // pattern position (`({ [key]: w } = src)`); over the checked-dynamic tree the fence
         // stays.
         const folded = patternKeyNameOf(L, prop.name);
         if (folded === null) {
@@ -5476,12 +5559,12 @@ export function lowerForOf(L, stmt) {
         if (iterable.type.kind === "jsval") {
             return lowerForOfIsland(L, stmt, iterable, labels);
         }
-        // A CHECKED-DYNAMIC iterable (`unknown[]` and the collapsed
-        // `(string | object)[]` are DOM values now, so the TYPE maps —
-        // badType would tell a stale component story): the OPERATION is
-        // the gap — name it, with the validated-cast escape hatch.
+        // A CHECKED-DYNAMIC iterable (`unknown[]`, the collapsed
+        // `(string | object)[]`, JSON-parsed values, wrapped engine
+        // values): the source packs ONCE through the spread walk and a
+        // hidden index loop binds each element as a dyn value.
         if (iterable.type.kind === "dyn") {
-            L.unsupported("SC1090", stmt.expression, "for-of over checked-dynamic ('unknown') values (validate into a typed array first — `u as string[]` — or index with a counted loop: length and element reads compile)");
+            return lowerForOfDyn(L, stmt, iterable, labels);
         }
         if (iterable.type.kind !== "array") {
             L.badType(stmt.expression, L.typeOf(stmt.expression));
@@ -5854,6 +5937,158 @@ function lowerForOfClassIterator(L, stmt, iterable, cit, labels) {
  * (break/return out of a partial iteration calling it.return()) is NOT
  * run — a divergence only a custom island iterator with a return()
  * method can observe. */
+/** For-of over a CHECKED-DYNAMIC iterable: the source packs ONCE
+ * through the spread walk (dyn.iterPack — dyn arrays element-by-
+ * element, strings by code point, bytes by byte; a WRAPPED engine
+ * value drains through the ENGINE's own iterator protocol via the
+ * iter_drain arm; every other kind throws V8's not-iterable
+ * TypeError, the identifier spelling when the head has one), then a
+ * hidden index loop binds each element as a dyn value. The pack is an
+ * eager SNAPSHOT (the matchAll stance): body mutations of a dyn-array
+ * source don't extend the iteration where JS's live array iterator
+ * would — documented divergence; engine sources drain through their
+ * own protocol, so generators/Maps/Sets step exactly once like Node. */
+function lowerForOfDyn(L, stmt, iterable, labels) {
+    const loc = locOf(stmt);
+    const head = stmt.expression;
+    // V8's for-of CallPrinter spellings: named sources (identifiers and
+    // plain property chains) read "<src> is not iterable", call heads
+    // with a nameable callee "<callee> is not a function or its return
+    // value is not iterable"; everything else keeps the runtime kind
+    // wording. The runtime uses the spelling VERBATIM when non-empty.
+    const headText = (e) => {
+        if (ts.isIdentifier(e))
+            return e.text;
+        if (ts.isPropertyAccessExpression(e) && !e.questionDotToken && ts.isIdentifier(e.name)) {
+            const base = headText(e.expression);
+            return base !== null ? `${base}.${e.name.text}` : null;
+        }
+        return null;
+    };
+    const headName = headText(head);
+    const calleeName = ts.isCallExpression(head) ? headText(head.expression) : null;
+    const spell = headName !== null
+        ? `${headName} is not iterable`
+        : calleeName !== null
+            ? `${calleeName} is not a function or its return value is not iterable`
+            : "";
+    const pack = L.declareHiddenLocal("%dofpack", DYN);
+    const idx = L.declareHiddenLocal("%dofi", F64);
+    idx.mutable = true;
+    const packRef = () => ({ kind: "varRef", localId: pack.id, type: DYN, loc });
+    const iRef = () => ({ kind: "varRef", localId: idx.id, type: F64, loc });
+    const elemInit = () => ({ kind: "libCall", fn: "dyn.arrAt", args: [packRef(), iRef()], type: DYN, loc });
+    L.scopes.push(new Map());
+    try {
+        const binds = [];
+        if (!ts.isVariableDeclarationList(stmt.initializer)) {
+            // Pre-declared heads: identifier targets assign the existing
+            // binding once per pass (JS's shared-binding rule); literal
+            // patterns run the destructuring-assignment machinery over the
+            // dyn element; member targets keep the fence.
+            let target = stmt.initializer;
+            while (ts.isParenthesizedExpression(target))
+                target = target.expression;
+            const tmp = L.declareHiddenLocal("%vof", DYN);
+            binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+            const elemRef = { kind: "varRef", localId: tmp.id, type: DYN, loc };
+            if (ts.isArrayLiteralExpression(target) || ts.isObjectLiteralExpression(target)) {
+                binds.push(lowerDestructuringAssign(L, target, elemRef, target, loc));
+            }
+            else if (ts.isIdentifier(target) && L.resolveWritable(target)) {
+                const writable = L.resolveWritable(target);
+                binds.push({
+                    kind: "assign",
+                    localId: writable.id,
+                    value: L.coerceInto(target, elemRef, writable.type),
+                    loc,
+                });
+            }
+            else {
+                L.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
+            }
+        }
+        else {
+            const list = stmt.initializer;
+            if ((list.flags & ts.NodeFlags.Using) !== 0) {
+                L.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];
+            if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
+                const tmp = L.declareHiddenLocal("%destr", DYN);
+                binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+                L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: DYN, loc }), DYN, isLet, binds);
+            }
+            else if (ts.isIdentifier(decl.name)) {
+                const varTarget = forOfVarTarget(L, decl);
+                if (varTarget) {
+                    // `for (var x of d)`: the element mechanics stay on a hidden
+                    // per-iteration local; the body opens by assigning the ONE
+                    // hoisted var binding (the array head's rule).
+                    const tmp = L.declareHiddenLocal("%vof", DYN);
+                    binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+                    binds.push({
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(decl.name, { kind: "varRef", localId: tmp.id, type: DYN, loc }, varTarget.type),
+                        loc,
+                    });
+                }
+                else {
+                    const local = L.declareLocal(decl.name, decl.name.text, DYN, isLet);
+                    binds.push({ kind: "varDecl", localId: local.id, init: elemInit(), loc });
+                }
+            }
+            else {
+                L.unsupported("SC1031", decl.name);
+            }
+        }
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement), labels);
+        return {
+            kind: "block",
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: pack.id,
+                    init: {
+                        kind: "libCall",
+                        fn: "dyn.iterPack",
+                        args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: idx.id, init: { kind: "numLit", value: 0, type: F64, loc }, loc },
+                    cond: {
+                        kind: "bin",
+                        op: "<",
+                        left: iRef(),
+                        right: { kind: "libCall", fn: "dyn.arrLen", args: [packRef()], type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    update: {
+                        kind: "assign",
+                        localId: idx.id,
+                        value: { kind: "bin", op: "+", left: iRef(), right: { kind: "numLit", value: 1, type: F64, loc }, type: F64, loc },
+                        loc,
+                    },
+                    body: [...binds, ...body],
+                    ...(labels && { labels }),
+                    loc,
+                },
+            ],
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 function lowerForOfIsland(L, stmt, iterable, labels) {
     const loc = locOf(stmt);
     if (!ts.isVariableDeclarationList(stmt.initializer)) {