@scriptc/compiler 0.0.9 → 0.0.11

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

@@ -170,7 +170,7 @@ export declare function lowerVarStatement(L: Lowerer, stmt: ts.VariableStatement
 export declare function lowerDestructuringDecl(L: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt[];
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
-export declare function lowerBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[]): void;
+export declare function lowerBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string): void;
 /** The STATIC property name of a destructuring key: identifiers spell
    * themselves, string/numeric-literal keys and COMPUTED keys fold through
    * foldedStringKeyOf — pure single-name expressions only (`{ [k]: v }`
@@ -209,10 +209,6 @@ export declare function enginePatternSpec(L: Lowerer, pattern: ts.ArrayBindingPa
    * exit), rest, and transportable defaults all ride. False when the
    * pattern has no engine form (the caller fences). */
 export declare function lowerJsvalBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, isLet: boolean, out: IrStmt[]): boolean;
-/** Binds one destructured name to its value — the identifier tail of
-   * lowerVarDecl (module-global assignment for pre-registered file-scope
-   * names, declareLocal otherwise), or a nested pattern through its own
-   * hidden temp. */
 export declare function bindPatternTarget(L: Lowerer, name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[]): void;
 /** For-loop initializers. let/const stay restricted to ONE declarator (JS
    * per-iteration binding copies for several captured loop variables are

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

@@ -10,17 +10,17 @@ 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 { lowerImportEquals, nsWritableTarget } from "./lower-namespaces.js";
+import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
-import { lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, recordKeysArrayCall } from "./lower-calls.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";
 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";
@@ -1103,14 +1103,59 @@ 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 });
-    L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: init.type, loc }), init.type, isLet, out);
+    // 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";
+    // everything else (property reads, method calls, parameters) gets the
+    // runtime kind wording — exactly V8's CallPrinter behavior. Only the
+    // DYN pattern arm consumes this.
+    const src = decl.initializer;
+    const dynSpell = ts.isIdentifier(src)
+        ? `${src.text} is not iterable`
+        : ts.isCallExpression(src) && ts.isIdentifier(src.expression)
+            ? `${src.expression.text} is not a function or its return value is not iterable`
+            : undefined;
+    L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: init.type, loc }), init.type, isLet, out, dynSpell);
     return out;
 }
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
-export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out) {
+export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dynSpell) {
     if (ts.isArrayBindingPattern(pattern)) {
         // Tuple sources: each position is a field read of the tuple's record
         // shape — the positional twin of object destructuring below.
@@ -1231,6 +1276,68 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out) {
             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]) =>`
+        // 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
+        // undefined (JS's rule); rest elements keep the fence (surplus
+        // packing over the DOM needs a slice the IR does not spell yet).
+        if (srcType.kind === "dyn") {
+            const loc = locOf(pattern);
+            const pack = L.declareHiddenLocal("%dpack", DYN);
+            out.push({
+                kind: "varDecl",
+                localId: pack.id,
+                init: {
+                    kind: "libCall",
+                    fn: "dyn.iterPack",
+                    args: [srcRef(), { kind: "strLit", value: dynSpell ?? "", type: STRING, loc }],
+                    type: DYN,
+                    loc,
+                },
+                loc,
+            });
+            pattern.elements.forEach((el, i) => {
+                if (ts.isOmittedExpression(el) || el.name === undefined)
+                    return; // hole: the position skips
+                const elLoc = locOf(el);
+                if (el.dotDotDotToken) {
+                    L.unsupported("SC1031", el, "rest elements over checked-dynamic sources");
+                }
+                let value = {
+                    kind: "dynKeyGet",
+                    key: { kind: "strLit", value: String(i), type: STRING, loc: elLoc },
+                    value: { kind: "varRef", localId: pack.id, type: DYN, loc: elLoc },
+                    type: 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.
+                    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)`);
+                    }
+                    value = {
+                        kind: "ternary",
+                        cond: { kind: "dynTest", test: "undefined", value: ref(), type: BOOL, loc: elLoc },
+                        then: dflt,
+                        else_: ref(),
+                        type: DYN,
+                        loc: elLoc,
+                    };
+                }
+                L.bindPatternTarget(el.name, value, isLet, out);
+            });
+            return;
+        }
         if (srcType.kind !== "array") {
             L.unsupported("SC1031", pattern, `array destructuring of non-array values (the source is ${srcType.kind}-typed)`);
         }
@@ -1512,6 +1619,29 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out) {
             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
@@ -2376,6 +2506,13 @@ export function lowerJsvalBindingPattern(L, pattern, srcRef, isLet, out) {
    * lowerVarDecl (module-global assignment for pre-registered file-scope
    * names, declareLocal otherwise), or a nested pattern through its own
    * hidden temp. */
+/** An island-world ('any'-flavored) checker spelling: bare jsval or an
+ * array of jsvals (`(string | object)[]` absorbed by its jsval arm) —
+ * the shapes the runtime-world local rule keeps DYN when the value
+ * lowered checked-dynamic. */
+function jsvalFlavoredType(t) {
+    return t.kind === "jsval" || (t.kind === "array" && t.elem.kind === "jsval");
+}
 export function bindPatternTarget(L, name, value, isLet, out) {
     const loc = value.loc;
     if (ts.isIdentifier(name)) {
@@ -2396,7 +2533,21 @@ export function bindPatternTarget(L, name, value, isLet, out) {
             out.push({ kind: "assign", localId: hoisted.id, value: L.coerceInto(name, value, hoisted.type), loc });
             return;
         }
-        const type = L.irTypeOf(name);
+        // The runtime-world local rule, dyn side (383(d)'s dispatch stance):
+        // 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
+        // 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
+        // world is the honest dispatch.
+        const dynStays = value.type.kind === "dyn" &&
+            (() => {
+                const mapped = L.mapTypeOf(L.typeOf(name));
+                return mapped === null || (L.dynamic && jsvalFlavoredType(mapped));
+            })();
+        const type = dynStays ? DYN : L.irTypeOf(name);
         if (type.kind === "void")
             L.badType(name, L.typeOf(name));
         const coerced = L.coerceInto(name, value, type);
@@ -2463,8 +2614,50 @@ export function lowerVarDecl(L, decl, isLet) {
     // put its fences on the build.
     if (provenanceElidedConstDecl(L, decl))
         return null;
+    // A TRAP declaration — the initializer's chain roots at an
+    // ambient-undefined name (`declare function factory...; const make =
+    // factory<T>()`): Node throws the root's ReferenceError while
+    // evaluating the initializer, module init unwinds THERE, and nothing
+    // after — including every reference to this binding — ever runs. The
+    // 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.
+    // 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);
+                if (sym)
+                    L.trapBindings.add(sym);
+            }
+            return {
+                kind: "exprStmt",
+                expr: nsUndefRead(L, root.text, decl.initializer, F64),
+                loc: locOf(decl),
+            };
+        }
+    }
     if (!ts.isIdentifier(decl.name))
         L.unsupported("SC1031", decl.name);
+    // 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
+    // method calls lower to Node's exact TypeError, nullish-to-nullish
+    // flows to nothing), so the declaration emits nothing.
+    if (nullishGenericBindingUnitOf(L, L.checker.getSymbolAtLocation(decl.name) ?? null) !== null) {
+        return null;
+    }
+    // A DEAD unmappable binding (`var xs2: typeof Array;`, the write-only
+    // `var f2: { <T, U>(x: T, y: U): T }`): never read anywhere in the
+    // program, its initializer (if any) a side-effect-free value — Node
+    // materializes the value and drops it, zero observable effect — so
+    // the declaration emits nothing instead of fencing on a type the
+    // program never consumes.
+    if (deadUnmappableBinding(L, L.checker.getSymbolAtLocation(decl.name) ?? null, decl)) {
+        return null;
+    }
     // An initializer-LESS declaration named `module` or `exports` at the
     // top level of an import/export-free TS file shadows the CommonJS
     // wrapper binding: Node hosts such a file as CJS, where
@@ -2496,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
@@ -2686,6 +2890,16 @@ export function lowerVarDecl(L, decl, isLet) {
             // uncheckedOverloadHandleCall.
             (init.type.kind === "jsval" && uncheckedOverloadHandleCall(L, decl.initializer) ? JSVAL : null))
         : null) ??
+        // The runtime-world local rule, dyn side (383(d)'s dispatch stance —
+        // 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
+        // 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
+        // island members).
+        (L.dynamic && init.type.kind === "dyn" && jsvalFlavoredType(L.mapTypeOf(L.typeOf(decl.name)) ?? DYN) ? DYN : null) ??
         (bindingTainted ? null : L.mapTypeOf(L.typeOf(decl.name))) ??
         (init.type.kind === "dyn" ? DYN : null);
     // A JS `let x = {}`: TS's empty-object-literal type admits ANY later
@@ -3437,6 +3651,37 @@ export function lowerExprStatement(L, expr) {
     const stmtNode = expr.parent;
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
+    // Assignment statements over the no-storage binding families:
+    //   - `f1 = f2` where the RHS roots at an ambient-undefined name:
+    //     Node evaluates the RHS first and dies on the root's
+    //     ReferenceError before any binding is touched — the statement IS
+    //     that throw;
+    //   - `a = b` between NULLISH generic bindings: the value is known
+    //     and the target has no storage — nothing happens;
+    //   - a write to a DEAD binding (registration proved every write's
+    //     RHS side-effect-free): Node builds the value and drops it —
+    //     nothing happens.
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(expr.left)) {
+        const rhsRoot = ambientUndefVarRootOf(L, expr.right);
+        if (rhsRoot !== null) {
+            return {
+                kind: "exprStmt",
+                expr: nsUndefRead(L, rhsRoot.text, expr.right, F64),
+                loc: locOf(expr),
+            };
+        }
+        const targetSym = L.resolveValueSymbol(expr.left);
+        if (targetSym !== null) {
+            if (nullishGenericBindingUnitOf(L, targetSym) !== null && nullishExprUnitOf(L, expr.right) !== null) {
+                return { kind: "block", body: [], loc: locOf(expr) };
+            }
+            if (L.deadBindings.has(targetSym)) {
+                return { kind: "block", body: [], loc: locOf(expr) };
+            }
+        }
+    }
     // A bare module-namespace binding in STATEMENT position (`ns;` for
     // `import * as ns from ...` — the corpus's canonical "the import
     // linked" assertion): Node evaluates an initialized binding (namespace
@@ -3471,7 +3716,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
@@ -3594,8 +3844,25 @@ export function lowerExprStatement(L, expr) {
                     // o.x = v on an island receiver: engine property write; the
                     // value marshals in (a static RHS crosses by value/copy).
                     const obj = L.lowerExpr(expr.left.expression);
-                    const value = L.jsvalIn(L.lowerExpr(expr.right), expr.right);
                     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
+                    // write — the routed JSVAL arm lands it on the real engine
+                    // object.
+                    if (obj.type.kind === "dyn") {
+                        const key = { kind: "strLit", value: expr.left.name.text, type: STRING, loc: locOf(expr.left.name) };
+                        const value = L.coerceToExpected(L.lowerExpr(expr.right), DYN);
+                        if (value.type.kind !== "dyn") {
+                            L.unsupported("SC1100", expr.right, `assigning '${L.fmt(value.type)}' values through 'unknown' receivers`);
+                        }
+                        return {
+                            kind: "exprStmt",
+                            expr: { kind: "libCall", fn: "dyn.keySet", args: [obj, key, value], type: VOID, loc },
+                            loc,
+                        };
+                    }
+                    const value = L.jsvalIn(L.lowerExpr(expr.right), expr.right);
                     return {
                         kind: "exprStmt",
                         expr: { kind: "jsOp", op: "setProp", name: expr.left.name.text, args: [obj, value], type: VOID, loc },
@@ -5111,6 +5378,15 @@ export function lowerForOf(L, stmt) {
             if (recv?.kind === "searchParams") {
                 return lowerForOfSearchParams(L, stmt, L.lowerExpr(src.expression.expression), proj);
             }
+            // ARRAY keys()/entries() projections: the live index walk yielding
+            // the index or the [index, element] pair (lower-containers).
+            // `values` falls through to the receiver unwrap below.
+            if (recv?.kind === "array" && (proj === "keys" || proj === "entries")) {
+                const container = L.lowerExpr(src.expression.expression);
+                if (container.type.kind === "array") {
+                    return lowerForOfArrayIter(L, stmt, container, proj);
+                }
+            }
         }
     }
     // `for (const m of s.matchAll(re))` — direct call or a stored-const
@@ -5274,6 +5550,13 @@ 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.
+        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)");
+        }
         if (iterable.type.kind !== "array") {
             L.badType(stmt.expression, L.typeOf(stmt.expression));
         }