@scriptc/compiler 0.1.6 → 0.2.0

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

@@ -1,3 +1,4 @@
+import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Container-surface call lowering: array methods (including the HOF family
  * map/filter/forEach with their synthesized helper functions), Map/Set
@@ -7,13 +8,13 @@ import * as ts from "../ts7/adapter.js";
 import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.js";
 import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS } from "./surfaces.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { islandPrimitiveExit, lowerDynDispatchMethodCall } from "./lower-calls.js";
 import { buildArraySortFn } from "./lower-array-sort.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent } from "./array-values.js";
 import { typeKey } from "../type-mapper.js";
+import { nodeThrowExpr } from "./lowerer.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
 import { defaultAfterUndefined, lowerPositionArgument, lowerStaticallyUndefinedArgument, positionNumber } from "./optional-arguments.js";
 import { lowerArrayCopyWithin, lowerArrayFill } from "./array-indexed-mutation.js";
@@ -79,7 +80,13 @@ function lowerArraySpreadItems(lowerer, nodes, elem, arrType, loc) {
     ];
     for (const node of nodes) {
         if (ts.isSpreadElement(node)) {
-            const source = lowerer.lowerExpr(node.expression);
+            let source = lowerer.lowerExpr(node.expression);
+            if (source.type.kind === "set" && typeEquals(source.type.elem, elem)) {
+                source = { kind: "setIntrinsic", method: "toArray", receiver: source, args: [], type: arrType, loc };
+            }
+            if (source.type.kind === "record" && lowerer.shapes.get(source.type.shapeId)?.tuple) {
+                source = lowerer.widthCoerce(source, arrType) ?? source;
+            }
             if (!typeEquals(source.type, arrType)) {
                 lowerer.noLowering(`Array insertion spread from '${lowerer.fmt(source.type)}'`, node);
             }
@@ -205,6 +212,21 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // static arrIntrinsic over a jsval (the validator ICE).
     {
         const receiver = lowerer.lowerExpr(access.expression);
+        if (receiver.type.kind === "union") {
+            const arms = lowerer.unions.get(receiver.type.unionId)?.arms;
+            const present = arms?.find((arm) => arm.kind === "array");
+            if (present?.kind === "array" && arms?.every((arm) => typeEquals(arm, present) || isUnitType(arm))) {
+                // A predicate can narrow the element type without changing the
+                // original array layout. Extract that stored array before choosing
+                // a helper, then adapt callback arguments at their actual ABI.
+                const array = lowerer.runtimeOptionalPropertyReceiver(access.expression, receiver, present, name) ??
+                    lowerer.coerceInto(access.expression, receiver, present);
+                return lowerer.withExpressionOverride(access.expression, array, () => lowerArrayMethodCall(lowerer, call, access));
+            }
+        }
+        if (receiver.type.kind === "record" && lowerer.shapes.get(receiver.type.shapeId)?.tuple) {
+            return lowerTupleReadMethodCall(lowerer, call, access, receiver);
+        }
         if (receiver.type.kind === "jsval") {
             const loweredArgs = call.arguments.map((a) => lowerer.lowerExpr(a));
             if (name === "filter" && loweredArgs[0]?.type.kind === "func" && loweredArgs[0].type.ret.kind === "void") {
@@ -228,16 +250,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 return dispatched;
             lowerer.noLowering(`.${name} on an array value held in a checked-dynamic binding`, call, "assign it to an array-typed binding first (the validated extraction), then call the method");
         }
-        // An evolving-`any` array binding under --dynamic whose flow type
-        // EVOLVED past `any[]` (`const fns = []; fns.push(() => 1);
-        // fns.map(...)` — the binding lowered array<jsval> at its `any[]`
-        // declaration, while tsc's evolving-array analysis answers the
-        // pushed element type at this site): the VALUE's element type is
-        // the truth — ride the explicit-`any[]` handle-element lowering
-        // (pushes marshal in, HOF callbacks bind the handle, results exit
-        // per the checker type), never a typed intrinsic over a jsval-
-        // element array (the validator ICE).
-        if (receiver.type.kind === "array" && receiver.type.elem.kind === "jsval" && !typeEquals(receiverIr, receiver.type)) {
+        // Flow predicates and evolving-any analysis can refine the checker
+        // element type without changing the array's storage. Helpers and
+        // callback array arguments must retain the original layout and
+        // identity; element conversions happen at the callback boundary.
+        if (receiver.type.kind === "array" && !typeEquals(receiverIr, receiver.type)) {
             receiverIr = receiver.type;
             elem = receiver.type.elem;
         }
@@ -445,6 +462,17 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 loc,
             };
         }
+        if (call.arguments.some(ts.isSpreadElement)) {
+            // Finish argument evaluation before mutating the receiver. Each
+            // spread snapshots its elements immediately, so a later argument
+            // can mutate that source without changing already-collected values.
+            const items = lowerArraySpreadItems(lowerer, call.arguments, elem, receiverIr, loc);
+            return {
+                kind: "arrIntrinsic",
+                method: name === "push" ? "pushSpread" : "unshiftSpread",
+                receiver, args: [items], type: F64, loc,
+            };
+        }
         const valueProbes = call.arguments.map((arg) => tryLowerExpression(lowerer, arg));
         if (valueProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null)) {
             const items = lowerArrayValueItems(lowerer, call.arguments.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc);
@@ -471,12 +499,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         };
     }
     if (name === "pop") {
-        // Like shift(), pop() returns undefined for an empty array. Union
-        // element arrays remain fenced here because their existing boxed
-        // element already carries the result union and a second undefined
-        // wrapper would lose the element identity contract.
+        // Widen a union payload through the normal array-read machinery
+        // before removing it. Reinterpreting the stored union's tag as the
+        // result union would confuse arms when undefined changes their order.
         if (elem.kind === "union" && lowerer.armTag(elem.unionId, UNDEFINED_T) < 0) {
-            lowerer.unsupported("SC1090", call, "'.pop()' on union-element arrays without an undefined arm (read the last element and splice it after narrowing instead)");
+            return lowerUnionArrayRemoval(lowerer, access.expression, elem, false, loc);
         }
         const receiver = lowerer.lowerExpr(access.expression);
         return {
@@ -580,14 +607,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         return { kind: "arrIntrinsic", method: "spliceInsert", receiver, args: [...args, items], type: receiverIr, loc };
     }
     if (name === "shift") {
-        // JS shift exactly: undefined on an empty array, else the first
-        // element with the tail sliding down — the result is the interned
-        // `elem | undefined` union, the env-read convention. Union-element
-        // arrays are fenced: their shift result would collapse arms
-        // (`(string | undefined)[]`'s shift is `string | undefined` too, and
-        // the box can't say which world the undefined came from).
+        // Like pop, a union without undefined needs an explicit tag widening.
         if (elem.kind === "union" && lowerer.armTag(elem.unionId, UNDEFINED_T) < 0) {
-            lowerer.unsupported("SC1090", call, "'.shift()' on union-element arrays without an undefined arm (read [0] and splice(0, 1) with the narrowed value instead)");
+            return lowerUnionArrayRemoval(lowerer, access.expression, elem, true, loc);
         }
         const receiver = lowerer.lowerExpr(access.expression);
         return { kind: "arrIntrinsic", method: "shift", receiver, args: [], type: arrayValueType(lowerer, elem), loc };
@@ -627,6 +649,38 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // reduce / reduceRight
     return lowerArrayReduceCall(lowerer, call, access, name, elem);
 }
+/** Read before splice so removal cannot destroy the result's owned payload.
+ * The source is evaluated once and empty/sparse arrays yield undefined using
+ * the same slot-state checks as an indexed read. */
+function lowerUnionArrayRemoval(lowerer, source, elem, first, loc) {
+    const receiver = lowerer.lowerExpr(source);
+    const arr = lowerer.declareHiddenLocal("%removeArray", receiver.type);
+    const arrRef = varRef(arr.id, arr.type, loc);
+    const index = lowerer.declareHiddenLocal("%removeIndex", F64);
+    const indexRef = varRef(index.id, F64, loc);
+    const value = arrayValueRead(lowerer, arrRef, indexRef, elem, loc);
+    const result = lowerer.declareHiddenLocal("%removedValue", value.type);
+    return {
+        kind: "seqExpr",
+        stmts: [
+            { kind: "varDecl", localId: arr.id, init: receiver, loc },
+            {
+                kind: "varDecl", localId: index.id,
+                init: first ? numLit(0, loc) : {
+                    kind: "bin", op: "-",
+                    left: { kind: "arrIntrinsic", method: "length", receiver: arrRef, args: [], type: F64, loc },
+                    right: numLit(1, loc), type: F64, loc,
+                }, loc,
+            },
+            { kind: "varDecl", localId: result.id, init: value, loc },
+            {
+                kind: "exprStmt",
+                expr: { kind: "arrIntrinsic", method: "splice", receiver: arrRef, args: [indexRef, numLit(1, loc)], type: arr.type, loc }, loc,
+            },
+        ],
+        result: varRef(result.id, result.type, loc), type: result.type, loc,
+    };
+}
 function literalFlatDepth(value) {
     if (value.kind === "numLit")
         return value.value;
@@ -709,10 +763,9 @@ function lowerArrayFlatCall(lowerer, call, access, receiverType) {
 function lowerArraySearchCall(lowerer, call, access, method, elem) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
-    const argNode = call.arguments[0] ?? call;
     if (call.arguments.some(ts.isSpreadElement))
         lowerer.noLowering(`.${method} with spread arguments`, call);
-    let needle = call.arguments[0]
+    const needle = call.arguments[0]
         ? lowerer.lowerExpr(call.arguments[0])
         : { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
     const fromIndex = call.arguments[1]
@@ -720,6 +773,11 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
         : method === "lastIndexOf"
             ? { kind: "bin", op: "/", left: numLit(1, loc), right: numLit(0, loc), type: F64, loc }
             : numLit(0, loc);
+    return lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, fromIndex);
+}
+function lowerArraySearchValues(lowerer, call, method, elem, receiver, needle, fromIndex) {
+    const loc = locOf(call);
+    const argNode = call.arguments[0] ?? call;
     // A derived CLASS VALUE against a base-classval element widens (the same
     // pointer — identity search is exact); the coercion path owns the ABI gate.
     if (needle.type.kind === "classval" && elem.kind === "classval" && !typeEquals(needle.type, elem)) {
@@ -765,14 +823,15 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
         : [needle.type];
     const scalarNeedle = needleArms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" ||
         arm.kind === "bigint" || arm.kind === "symbol" || isUnitType(arm));
-    const valueArms = lowerer.unions.get(valueT.unionId).arms;
+    const valueDef = lowerer.unions.get(valueT.unionId);
+    const valueArms = valueDef.arms;
     if (scalarNeedle && !valueArms.some((arm) => arm.kind === "func" || arm.kind === "set")) {
         const arms = [...valueArms];
         for (const arm of needleArms)
             if (!arms.some((existing) => typeEquals(existing, arm)))
                 arms.push(arm);
         if (arms.length !== valueArms.length)
-            valueT = { kind: "union", unionId: lowerer.unions.intern(arms) };
+            valueT = { kind: "union", unionId: lowerer.unions.transform(valueDef, arms) };
     }
     const directNeedle = method === "lastIndexOf" && elem.kind !== "union" && typeEquals(needle.type, elem);
     const searchNeedle = directNeedle ? needle : lowerer.coerceInto(argNode, needle, valueT);
@@ -791,6 +850,12 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
  * includes, where NaN equals NaN while +0 and -0 remain equal. */
 function arraySearchEquality(lowerer, left, right, sameValueZero, loc) {
     if (left.type.kind !== "union" || right.type.kind !== "union" || left.type.unionId !== right.type.unionId) {
+        if (left.type.kind === "string" && right.type.kind === "string") {
+            return { kind: "strEq", negated: false, left, right, type: BOOL, loc };
+        }
+        if (left.type.kind === "bigint" && right.type.kind === "bigint") {
+            return { kind: "bin", op: "===", left: { kind: "libCall", fn: "bigint.cmp", args: [left, right], type: F64, loc }, right: numLit(0, loc), type: BOOL, loc };
+        }
         return { kind: "bin", op: "===", left, right, type: BOOL, loc };
     }
     const unionId = left.type.unionId;
@@ -1004,7 +1069,7 @@ function arraySearchHelper(lowerer, method, elem, valueT, needleT, directNeedle,
    * loop passes exactly what it declares (JS passes everything; a callback
    * only sees the parameters it names). Returns the lowered callback and
    * its declared arity. */
-function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
+function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false, expectedReturn) {
     const full = [...lead, F64, arrT];
     // A DYN-receiver HOF's callback (`parsed.flatMap((value) => ...)`):
     // the contextual signature types the unannotated param `any` (the
@@ -1039,15 +1104,16 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
             lowerer.jsvalParamOverrides.add(p);
         });
     }
-    // A checker-untyped array expression whose lowered value supplies a
-    // concrete static element type still contextually types an inline HOF
-    // callback with any/unknown. Bind only unannotated parameters to the
-    // exact ABI the synthesized loop passes. The override is temporary:
-    // one callback AST may be lowered under several generic instances.
+    // An untyped or flow-refined array can contextually type an inline
+    // callback differently from the stored element and array layout. Bind
+    // unannotated parameters to the helper's ABI when a boundary adapter
+    // cannot carry it. Include the optional-read prepass's parameter type
+    // in this comparison. The override is temporary because one callback
+    // AST can lower under several generic instances.
     const contextual = [];
     const previousImplicit = lowerer.implicitParamTypes;
     let contextualTs = null;
-    if (bindUntyped && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+    if (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode)) {
         argNode.parameters.forEach((param, i) => {
             const expected = full[i];
             if (expected === undefined || expected.kind === "dyn" || expected.kind === "jsval" ||
@@ -1055,7 +1121,10 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
                 return;
             }
             const checkerType = lowerer.checker.getTypeAtLocation(param.name);
-            if ((checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0)
+            const untyped = (checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
+            const raw = untyped ? null : lowerer.mapTypeOf(checkerType);
+            const mapped = raw ? lowerer.runtimeOptionalBindingType(param.name, raw) : null;
+            if (untyped ? !bindUntyped : mapped === null || lowerer.coercibleValue(expected, mapped))
                 return;
             const symbol = lowerer.checker.getSymbolAtLocation(param.name);
             if (!symbol)
@@ -1076,6 +1145,10 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
     }
     if (contextualTs !== null)
         lowerer.implicitParamTypes = contextualTs;
+    const previousReturn = lowerer.contextualFunctionReturns.get(argNode);
+    if (expectedReturn && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+        lowerer.contextualFunctionReturns.set(argNode, expectedReturn);
+    }
     let fnArg;
     try {
         fnArg = lowerer.lowerExpr(argNode);
@@ -1090,6 +1163,27 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
                 lowerer.runtimeOptionalBindingTypes.set(symbol, previous);
         }
         lowerer.implicitParamTypes = previousImplicit;
+        if (previousReturn === undefined)
+            lowerer.contextualFunctionReturns.delete(argNode);
+        else
+            lowerer.contextualFunctionReturns.set(argNode, previousReturn);
+    }
+    // A callback can accept a wider parameter type than the array supplies
+    // (a reusable predicate over a union is common). Its closure still has
+    // that wider ABI: adapt each actual argument before invoking it, just
+    // as assignment to a narrower function slot does. Require a conversion
+    // plan so this path never manufactures a stranded callback.
+    if (fnArg.type.kind === "dyn") {
+        const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(argNode));
+        const ret = expectedReturn ?? (signatures[0] ? lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(signatures[0])) : null);
+        if (ret && ret.kind !== "void")
+            fnArg = lowerer.coerceToExpected(fnArg, funcOf(full, ret));
+    }
+    if (fnArg.type.kind === "func" && fnArg.type.params.length <= full.length &&
+        fnArg.type.params.every((param, i) => lowerer.coercibleValue(full[i], param))) {
+        const callbackType = funcOf(full.slice(0, fnArg.type.params.length), fnArg.type.ret);
+        if (!typeEquals(fnArg.type, callbackType))
+            fnArg = lowerer.coerceToExpected(fnArg, callbackType);
     }
     // Array storage widens indexed reads with undefined so holes remain
     // observable. The HOF helper guards every callback behind arrayHas,
@@ -1193,12 +1287,10 @@ function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
     const checkerReceiver = access
         ? lowerer.mapTypeOf(lowerer.typeOf(access.expression))
         : null;
-    // Evolving-any arrays of island handles retain their jsval element ABI,
-    // while the checker later describes both the receiver and unchanged
-    // filter result by the evolved callable type. Equal checker elements mean
-    // no predicate narrowing occurred; preserve the runtime element home.
-    if (elem.kind === "jsval" && valueT.kind === "jsval" &&
-        result?.kind === "array" && checkerReceiver?.kind === "array" &&
+    // Equal checker elements mean the filter introduces no new refinement.
+    // Preserve the stored element layout even if an earlier predicate or
+    // evolving-any analysis changed the receiver's flow type.
+    if (result?.kind === "array" && checkerReceiver?.kind === "array" &&
         typeEquals(result.elem, checkerReceiver.elem)) {
         return elem;
     }
@@ -1451,29 +1543,22 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
     });
     return name;
 }
-/** READ-ONLY array methods on TUPLE receivers — `t.slice(...)` and
-   * `t.map(f)`: a tuple is a fixed-shape record, but these methods never
-   * write, so the positions snapshot into a fresh array (the for-of-over-
-   * tuples stance — pure receivers only, since the reads re-emit per
-   * position) and the ordinary array machinery runs over it. The element
-   * type is the one position type, or the positions' interned union with
-   * each read wrapped into its arm (exactly the checker's callback
-   * parameter type). Null when this isn't a tuple slice/map — writers and
-   * the rest of the surface keep their fences. */
-export function lowerTupleReadMethodCall(lowerer, call, access) {
+/** Tuple methods keep the original receiver alive through argument evaluation.
+ * Callback methods read each position only when it is visited, so writes to
+ * later positions through a captured alias are visible. A tuple cannot be
+ * passed as the callback's array parameter without changing its identity;
+ * that parameter retains an explicit representation boundary. */
+export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
     if (lowerer.chainBlocked(access, call))
         return null;
-    const name = access.name.text;
-    if (name !== "slice" && name !== "map")
+    const method = access.name.text;
+    const search = method === "includes" || method === "indexOf" || method === "lastIndexOf";
+    if (method !== "slice" && method !== "map" && method !== "flatMap" && method !== "join" && !search)
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
-    let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    let receiver = null;
-    // A readonly tuple union under Array.isArray is checker-typed as an
-    // unmappable intersection with any[], while maybeNarrow still extracts
-    // its one tuple arm. Dispatch the supported tuple read methods from
-    // that lowered representation, like tuple indexing and `.length`.
+    let receiverIr = tupleReceiver?.type ?? lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let receiver = tupleReceiver ?? null;
     const checkerArray = lowerer.checkerArrayValue(access.expression);
     if (checkerArray?.type.kind === "record") {
         receiverIr = checkerArray.type;
@@ -1485,75 +1570,185 @@ export function lowerTupleReadMethodCall(lowerer, call, access) {
     if (!shape?.tuple)
         return null;
     receiver ??= lowerer.lowerExpr(access.expression);
+    if (method === "join") {
+        // Object.entries can retain its dynamic array representation behind a
+        // checker tuple. Native tuples box as live references, so separator
+        // evaluation can still mutate their elements before join reads them.
+        // An unchecked outer array read must validate its optional payload
+        // before passing the tuple to the runtime.
+        if (receiver.type.kind === "union") {
+            receiver = lowerer.coerceInto(access.expression, receiver, receiverIr);
+        }
+        const converted = lowerer.coerceInto(access.expression, receiver, DYN);
+        const boxed = converted.kind === "dynFrom" && converted.value.type.kind === "record"
+            ? { ...converted, liveRef: true } : converted;
+        const joined = lowerDynDispatchMethodCall(lowerer, call, access, boxed, true);
+        return joined ? lowerer.coerceInto(call, joined, STRING) : null;
+    }
     if (receiver.type.kind !== "record")
         return null;
-    if (!isSafeToRepeat(receiver)) {
-        lowerer.noLowering(`${lowerer.checker.typeToString(lowerer.typeOf(access.expression))}.${name}`, call, "tuple receivers snapshot per position, so only effect-free receivers lower — bind the tuple to a const first");
-    }
+    const fields = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+    const arms = [];
+    for (const field of fields) {
+        const types = field.type.kind === "union" ? lowerer.unions.get(field.type.unionId).arms : [field.type];
+        for (const type of types)
+            if (!arms.some(arm => typeEquals(arm, type)))
+                arms.push(type);
+    }
+    if (arms.length === 0)
+        return null;
+    const elem = arms.length === 1 ? arms[0] : { kind: "union", unionId: lowerer.unions.intern(arms) };
     const loc = locOf(call);
-    const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
-    let elemT = null;
-    {
-        const arms = [];
-        for (const f of byIndex) {
-            if (f.type.kind === "union") {
-                elemT = null;
-                break;
-            }
-            if (!arms.some((a) => typeEquals(a, f.type)))
-                arms.push(f.type);
-            elemT = arms.length === 1 ? arms[0] : { kind: "union", unionId: lowerer.unions.intern(arms) };
+    const tuple = varRef("a.0", receiver.type, loc);
+    const read = (field) => lowerer.coerceInto(access.expression, {
+        kind: "recordGet", obj: tuple, shapeId: receiverIr.shapeId, field: field.name, type: field.type, loc,
+    }, elem);
+    if (search) {
+        if (call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+            return lowerer.noLowering(`tuple .${method} with spread or extra arguments`, call);
         }
+        const arg = call.arguments[0];
+        const undefinedArg = arg ? lowerStaticallyUndefinedArgument(lowerer, arg) : null;
+        let needle = arg ? undefinedArg ?? lowerer.lowerExpr(arg) : null;
+        if (!needle || isUnitType(needle.type) || needle.type.kind === "void") {
+            const optional = arrayValueType(lowerer, elem);
+            const wrapped = needle?.type.kind === "nullT"
+                ? lowerer.coerceInto(arg ?? call, needle, optional) : lowerer.wrappedUndefined(optional, loc);
+            if (!wrapped)
+                return lowerer.noLowering(`tuple .${method} missing search value`, call);
+            needle = needle ? defaultAfterUndefined(needle, wrapped) : wrapped;
+        }
+        const from = call.arguments[1]
+            ? lowerPositionArgument(lowerer, call.arguments[1], numLit(0, loc))
+            : numLit(method === "lastIndexOf" ? Infinity : 0, loc);
+        const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(needle.type)}:${typeKey(from.type)}:${call.arguments.length}`;
+        let helper = lowerer.arrHofHelpers.get(key);
+        const resultType = method === "includes" ? BOOL : F64;
+        if (!helper) {
+            helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`;
+            lowerer.arrHofHelpers.set(key, helper);
+            const params = [
+                { localId: "a.0", name: "a", type: receiver.type },
+                { localId: "needle.0", name: "needle", type: needle.type },
+                { localId: "from.0", name: "from", type: from.type },
+            ];
+            const result = lowerArraySearchValues(lowerer, call, method, elem, { kind: "arrayLit", elems: fields.map(read), type: arrayOf(elem), loc }, varRef("needle.0", needle.type, loc), varRef("position.0", F64, loc));
+            lowerer.liftedFns.push({
+                name: helper, params, returnType: resultType,
+                locals: [
+                    ...params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false })),
+                    { id: "position.0", name: "position", type: F64, mutable: false },
+                ],
+                body: [
+                    { kind: "varDecl", localId: "position.0", init: positionNumber(lowerer, varRef("from.0", from.type, loc), numLit(0, loc), call.arguments[1] ?? call, "tuple search position"), loc },
+                    { kind: "return", value: result, loc },
+                ], loc,
+            });
+        }
+        return { kind: "call", callee: helper, args: [receiver, needle, from], type: resultType, loc };
     }
-    if (elemT === null || byIndex.length === 0)
-        return null; // empty/union-position tuples keep the fence
-    const snapshotElem = elemT;
-    const snapshot = {
-        kind: "arrayLit",
-        elems: byIndex.map((f) => {
-            const read = {
-                kind: "recordGet",
-                obj: receiver,
-                shapeId: receiverIr.shapeId,
-                field: f.name,
-                type: f.type,
-                loc,
-            };
-            return typeEquals(f.type, snapshotElem) ? read : lowerer.coerceInto(access.expression, read, snapshotElem);
-        }),
-        type: arrayOf(snapshotElem),
-        loc,
-    };
-    if (name === "slice") {
-        if (call.arguments.length > 2) {
+    if (method === "slice") {
+        if (call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
             lowerer.noLowering(`.slice with ${call.arguments.length} arguments`, call);
         }
-        const args = call.arguments.map((a) => lowerer.lowerExpr(a));
-        for (let i = 0; i < args.length; i++) {
-            if (args[i].type.kind !== "f64")
-                lowerer.badType(call.arguments[i], lowerer.typeOf(call.arguments[i]));
+        const args = call.arguments.map(arg => lowerer.lowerExpr(arg));
+        args.forEach((arg, i) => { if (arg.type.kind !== "f64")
+            lowerer.badType(call.arguments[i], lowerer.typeOf(call.arguments[i])); });
+        const resultType = arrayOf(elem);
+        const key = `tuple.slice:${typeKey(receiver.type)}:${args.length}`;
+        let helper = lowerer.arrHofHelpers.get(key);
+        if (!helper) {
+            helper = `%tuple.slice.${lowerer.arrHofHelpers.size}`;
+            lowerer.arrHofHelpers.set(key, helper);
+            const params = [receiver, ...args].map((arg, i) => ({ localId: i === 0 ? "a.0" : `arg.${i}`, name: `arg${i}`, type: arg.type }));
+            lowerer.liftedFns.push({
+                name: helper, params, returnType: resultType,
+                locals: params.map(param => ({ id: param.localId, name: param.name, type: param.type, mutable: false })),
+                body: [{ kind: "return", value: {
+                            kind: "arrIntrinsic", method: "slice",
+                            receiver: { kind: "arrayLit", elems: fields.map(read), type: resultType, loc },
+                            args: args.map((arg, i) => varRef(`arg.${i + 1}`, arg.type, loc)), type: resultType, loc,
+                        }, loc }], loc,
+            });
         }
-        return { kind: "arrIntrinsic", method: "slice", receiver: snapshot, args, type: arrayOf(snapshotElem), loc };
+        return { kind: "call", callee: helper, args: [receiver, ...args], type: resultType, loc };
     }
-    // map
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering(`.map with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
+    if (call.arguments.length !== 1 || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`.${method} with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
     }
-    const argNode = call.arguments[0];
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, snapshotElem)], arrayOf(snapshotElem));
-    const fnRet = fnArg.type.ret;
-    if (fnRet.kind === "void" || fnRet.kind === "func")
+    const callback = call.arguments[0];
+    // Check before the array HOF adapter can create a tuple-to-array copy.
+    const signatures = lowerer.checker.getCallSignatures(lowerer.typeOf(callback));
+    if (signatures.some(signature => signature.getParameters().length > 2)) {
+        lowerer.noLowering(`tuple .${method} callback array parameter`, callback, "capture the original tuple explicitly to preserve its identity");
+    }
+    const { fnArg, arity } = hofCallbackArg(lowerer, callback, [elem], receiver.type);
+    const ret = fnArg.type.ret;
+    if (ret.kind === "void" || ret.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
-    fenceProducedArrayElem(lowerer, call, "'.map()'", fnRet);
-    const outElem = callbackArrayElem(lowerer, call, fnRet);
-    const helper = arrayHofHelper(lowerer, "map", snapshotElem, fnRet, arity, loc, outElem);
-    return { kind: "call", callee: helper, args: [snapshot, fnArg], type: arrayOf(outElem), loc };
+    if (method === "flatMap" && ret.kind === "union" && lowerer.unions.get(ret.unionId).arms.some(arm => arm.kind === "array")) {
+        lowerer.noLowering("tuple .flatMap callback mixing array and scalar results", callback, "return an array from every path");
+    }
+    const flatten = method === "flatMap" && ret.kind === "array";
+    const outElem = flatten ? ret.elem : callbackArrayElem(lowerer, call, ret);
+    fenceProducedArrayElem(lowerer, call, `'.${method}()'`, outElem);
+    const outType = arrayOf(outElem);
+    const key = `tuple.${method}:${typeKey(receiver.type)}:${typeKey(fnArg.type)}:${typeKey(outElem)}`;
+    let helper = lowerer.arrHofHelpers.get(key);
+    if (!helper) {
+        helper = `%tuple.${method}.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, helper);
+        const out = varRef("out.0", outType, loc);
+        const result = varRef("r.0", ret, loc);
+        const outputLength = { kind: "arrIntrinsic", method: "length", receiver: out, args: [], type: F64, loc };
+        const body = [{ kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outType, loc }, loc }];
+        for (const field of fields) {
+            const invocation = {
+                kind: "callValue", callee: varRef("f.0", fnArg.type, loc),
+                args: [read(field), numLit(Number(field.name), loc)].slice(0, arity), type: ret, loc,
+            };
+            body.push(field === fields[0]
+                ? { kind: "varDecl", localId: "r.0", init: invocation, loc }
+                : { kind: "assign", localId: "r.0", value: invocation, loc });
+            if (flatten) {
+                const index = varRef("i.0", F64, loc);
+                body.push(countedFor(loc, { kind: "arrIntrinsic", method: "length", receiver: result, args: [], type: F64, loc }, () => [{
+                        kind: "if", cond: arrayIndexPresent(result, index, loc), then: [
+                            { kind: "varDecl", localId: "inner.0", init: arrayValueRead(lowerer, result, index, outElem, loc), loc },
+                            arrayValueStore(lowerer, out, outputLength, varRef("inner.0", arrayValueType(lowerer, outElem), loc), outElem, loc),
+                        ], else_: null, loc,
+                    }]));
+            }
+            else {
+                body.push(arrayValueStore(lowerer, out, outputLength, result, outElem, loc));
+            }
+        }
+        body.push({ kind: "return", value: out, loc });
+        lowerer.liftedFns.push({
+            name: helper,
+            params: [{ localId: "a.0", name: "a", type: receiver.type }, { localId: "f.0", name: "f", type: fnArg.type }],
+            returnType: outType,
+            locals: [
+                { id: "a.0", name: "a", type: receiver.type, mutable: false },
+                { id: "f.0", name: "f", type: fnArg.type, mutable: false },
+                { id: "out.0", name: "out", type: outType, mutable: false },
+                { id: "r.0", name: "r", type: ret, mutable: true },
+                ...(flatten ? [
+                    { id: "i.0", name: "i", type: F64, mutable: true },
+                    { id: "inner.0", name: "inner", type: arrayValueType(lowerer, outElem), mutable: false },
+                ] : []),
+            ], body, loc,
+        });
+    }
+    return { kind: "call", callee: helper, args: [receiver, fnArg], type: outType, loc };
 }
 /** An ordinary indexed read: values retain their element type, while
  * holes, missing properties, and present undefined yield undefined. */
 export function lowerSafeIndexRead(lowerer, arr, index, loc) {
+    if (arr.type.kind !== "array")
+        throw new InternalCompilerError("indexed read requires an array");
     const elem = arr.type.elem;
-    if (elem.kind === "void" || elem.kind === "dyn")
+    if (elem.kind === "void")
         return null;
     const resultT = arrayValueType(lowerer, elem);
     const key = `idxOr:${typeKey(elem)}`;
@@ -1814,18 +2009,38 @@ function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped
             loc,
         };
     }
-    // find: the result is the checker's `T | undefined` union. When the
-    // element type IS that union already (it carries an undefined arm), the
-    // found element passes through untouched; otherwise it wraps into its
-    // arm. A union element whose result union differs would need the
-    // union-into-union re-tag that doesn't exist — fenced.
-    const resultT = bindUntyped ? arrayValueType(lowerer, elem) : lowerer.irTypeOf(call);
+    // find visits holes as undefined and can infer a predicate that selects
+    // a subset of the element union. A result matching the receiver's flow
+    // element inherits that earlier refinement. Otherwise only an inline,
+    // inferred predicate proves a new narrowing; explicit assertions keep
+    // the same refusal boundary as filter.
+    const valueT = arrayValueType(lowerer, elem);
+    const checkerReceiver = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const checkerResult = lowerer.irTypeOf(call);
+    const unchangedElement = checkerReceiver?.kind === "array" &&
+        typeEquals(checkerResult, arrayValueType(lowerer, checkerReceiver.elem));
+    const resultT = bindUntyped ? valueT : checkerResult;
     if (resultT.kind !== "union")
         lowerer.badType(call, lowerer.typeOf(call)); // defensive: T | undefined always maps to a union
     const undefTag = lowerer.armTag(resultT.unionId, UNDEFINED_T);
     if (undefTag < 0)
         lowerer.badType(call, lowerer.typeOf(call));
-    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc);
+    let retag = null;
+    if (!lowerer.coercibleValue(valueT, resultT)) {
+        const inline = ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode);
+        if (!unchangedElement && (!inline || argNode.type !== undefined)) {
+            lowerer.unsupported("SC1090", argNode, `narrowing '.${method}' requires an inline callback with an inferred predicate (annotate the return ': boolean' to keep the receiver's element type)`);
+        }
+        const signature = inline ? lowerer.checker.getSignatureFromDeclaration(argNode) : undefined;
+        const predicate = signature ? lowerer.checker.getTypePredicateOfSignature(signature) : undefined;
+        if ((!unchangedElement && (!predicate || predicate.parameterIndex !== 0)) || valueT.kind !== "union") {
+            lowerer.unsupported("SC1090", call, `'.${method}' result narrowing without a predicate over its element`);
+        }
+        retag = lowerer.narrowedRetagHelper(call, valueT.unionId, resultT.unionId, loc);
+        if (retag === null)
+            lowerer.unsupported("SC1090", call, `'.${method}' narrowing to an incompatible result layout`);
+    }
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag);
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
 }
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
@@ -1842,7 +2057,7 @@ function predToBool(e) {
    *   for (i = 0; i < n; i++) { v = a[i]; if (f(v)) return <v as result arm>; }
    *   return <undefined arm>;
    */
-function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag) {
     const method = last ? "findLast" : "find";
     const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}`;
     const existing = lowerer.arrHofHelpers.get(key);
@@ -1854,7 +2069,8 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc) {
     const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const valueT = arrayValueType(lowerer, elem);
     const v = varRef("v.0", valueT, loc);
-    const found = lowerer.coerceToExpected(v, resultT);
+    const found = retag === null ? lowerer.coerceToExpected(v, resultT) :
+        { kind: "call", callee: retag, args: [v], type: resultT, loc };
     const miss = {
         kind: "unionWrap",
         unionId: resultT.unionId,
@@ -2170,7 +2386,7 @@ function lowerArrayReduceCall(lowerer, call, access, method, elem) {
         (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
     if (accT.kind === "void" || accT.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT);
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
     const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc);
     const args = [receiver, fnArg];
     if (hasInit)
@@ -2311,7 +2527,18 @@ function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     }
     const receiver = lowerer.lowerExpr(access.expression);
     const argNode = call.arguments[0];
-    const fnArg = lowerer.lowerExpr(argNode);
+    let fnArg = lowerer.lowerExpr(argNode);
+    // Reusable JS comparators often accept checked values. Adapt the array's
+    // element ABI just as other array callbacks do before sorting.
+    if (fnArg.type.kind === "func" && fnArg.type.params.length <= 2 &&
+        fnArg.type.params.every((param) => lowerer.coercibleValue(elem, param))) {
+        // Arithmetic on inferred JS values retains a checked result because
+        // it can produce BigInt. The sort callback still requires a number.
+        const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(argNode.getSourceFile()) ? F64 : fnArg.type.ret;
+        const expected = funcOf(fnArg.type.params.map(() => elem), result);
+        if (!typeEquals(fnArg.type, expected))
+            fnArg = lowerer.coerceToExpected(fnArg, expected);
+    }
     // The comparator receives exactly (a, b); declaring a prefix is
     // ordinary TS. Its result must be number (the spec coerces arbitrary
     // results — no lowering for that).
@@ -2556,10 +2783,25 @@ export function lowerArrayConstructor(lowerer, expr, args) {
         if (contextual)
             result = lowerer.mapTypeOf(contextual);
     }
+    if (isJsSourceFile(expr.getSourceFile()) && (result === null || result.kind === "dyn"))
+        result = arrayOf(DYN);
     if (result?.kind !== "array" || !isSupportedArrayElem(result.elem)) {
         lowerer.badType(expr, lowerer.typeOf(expr));
     }
     const argType = args.length === 1 ? lowerer.mapTypeOf(lowerer.typeOf(args[0])) : null;
+    if (args.length === 1 && result.elem.kind === "dyn" && (argType === null || argType.kind === "dyn")) {
+        const input = lowerer.declareHiddenLocal("%arrayCtorValue", DYN);
+        const value = varRef(input.id, DYN, loc);
+        const local = lowerer.declareHiddenLocal("%arrayCtor", result);
+        const array = varRef(local.id, result, loc);
+        return { kind: "seqExpr", stmts: [
+                { kind: "varDecl", localId: input.id, init: lowerer.lowerExprExpecting(args[0], DYN), loc },
+                { kind: "varDecl", localId: local.id, init: { kind: "arrayLit", elems: [], type: result, loc }, loc },
+                { kind: "if", cond: { kind: "dynTest", test: "number", value, type: BOOL, loc },
+                    then: [{ kind: "arraySetLength", arr: array, length: { kind: "dynCheck", value, type: F64, loc }, loc }],
+                    else_: [arrayValueStore(lowerer, array, numLit(0, loc), value, DYN, loc)], loc },
+            ], result: array, type: result, loc };
+    }
     if (argType?.kind === "dyn" || argType?.kind === "jsval") {
         lowerer.noLowering("Array constructor with a dynamically typed sole argument", args[0]);
     }
@@ -2622,6 +2864,33 @@ export function lowerArrayOfCall(lowerer, call, access) {
         loc: locOf(call),
     };
 }
+/** Mapper-less checked Array.from: acquire once, then step through emitted
+ * property and call dispatch so native class iterators retain their methods. */
+function lowerCheckedArrayFrom(lowerer, source, loc) {
+    const iterator = lowerer.declareHiddenLocal("%fromIterator", DYN);
+    const next = lowerer.declareHiddenLocal("%fromNext", DYN);
+    const step = lowerer.declareHiddenLocal("%fromStep", DYN);
+    const out = lowerer.declareHiddenLocal("%fromArray", DYN);
+    const done = lowerer.declareHiddenLocal("%fromDone", BOOL);
+    done.mutable = true;
+    const get = (value, key) => ({ kind: "dynKeyGet", value, key: strLit(key, loc), type: DYN, loc });
+    const stmts = [
+        { kind: "varDecl", localId: iterator.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "libCall", fn: "dyn.arrayFromIterator", args: [source], type: DYN, loc }], type: DYN, loc }, loc },
+        { kind: "varDecl", localId: next.id, init: get(varRef(iterator.id, DYN, loc), "next"), loc },
+        { kind: "varDecl", localId: out.id, init: { kind: "dynArrLit", elems: [], type: DYN, loc }, loc },
+        { kind: "varDecl", localId: done.id, init: boolLit(false, loc), loc },
+        { kind: "while", cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc }, body: [
+                { kind: "varDecl", localId: step.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{
+                                kind: "dynCall", callee: varRef(next.id, DYN, loc), receiver: varRef(iterator.id, DYN, loc), calleeName: "iterator.next", args: [], type: DYN, loc,
+                            }], type: DYN, loc }, loc },
+                { kind: "assign", localId: done.id, value: { kind: "dynTest", test: "truthy", value: get(varRef(step.id, DYN, loc), "done"), type: BOOL, loc }, loc },
+                { kind: "if", cond: { kind: "unary", op: "!", operand: varRef(done.id, BOOL, loc), type: BOOL, loc }, then: [
+                        { kind: "exprStmt", expr: { kind: "dynInvoke", recv: varRef(out.id, DYN, loc), method: "push", calleeName: "Array.from", args: [get(varRef(step.id, DYN, loc), "value")], type: DYN, loc }, loc },
+                    ], else_: null, loc },
+            ], loc },
+    ];
+    return { kind: "seqExpr", stmts, result: varRef(out.id, DYN, loc), type: DYN, loc };
+}
 /** `Array.from({ length: n }, mapfn)` — the counted-generation idiom — on
    * THE stdlib Array global. The source must be an OBJECT LITERAL whose
    * single property is `length` (the shape the idiom always spells; the
@@ -2719,6 +2988,9 @@ export function lowerArrayFromCall(lowerer, call, access) {
             }
             return { kind: "call", callee: helper, args: [src, fnArg], type: arrayOf(outElem), loc };
         }
+        if (src.type.kind === "bytes" && args.length === 1) {
+            return { kind: "bytesIntrinsic", method: "toArray", receiver: src, args: [], type: arrayOf(F64), loc };
+        }
         if (src.type.kind === "set" && args.length === 1) {
             return { kind: "setIntrinsic", method: "toArray", receiver: src, args: [], type: arrayOf(src.type.elem), loc };
         }
@@ -2726,6 +2998,9 @@ export function lowerArrayFromCall(lowerer, call, access) {
         // `[...s]` and both Array.from(s) forms.
         if (src.type.kind === "string" && args.length === 1)
             return strCharsCall(lowerer, src, loc);
+        if (src.type.kind === "dyn" && args.length === 1) {
+            return lowerCheckedArrayFrom(lowerer, src, loc);
+        }
         lowerer.noLowering("Array.from with this argument shape", call, "Array.from(array), Array.from(array, mapper), Array.from(aString), Array.from(aString, mapper), and Array.from({ length: n }, mapper) are the lowered forms");
     }
     const n = args.length === 2 && ts.isObjectLiteralExpression(args[0]) && args[0].properties.length === 1
@@ -2949,10 +3224,12 @@ export function lowerMapMethodCall(lowerer, call, access) {
     }
     if (receiverIr?.kind !== "map")
         return null;
-    if (!lowerer.isStdlibMember(access))
+    // Collection views can refine has() while retaining its native ABI.
+    if (!lowerer.isStdlibMember(access) && name !== "has")
         return null;
     const loc = locOf(call);
-    const receiver = lowerer.lowerExpr(access.expression);
+    const value = lowerer.lowerExpr(access.expression);
+    const receiver = lowerer.runtimeOptionalPropertyReceiver(access.expression, value, receiverIr, name) ?? value;
     // The lib's `set` returns the Map (chaining typechecks); the lowered
     // set is a void statement, so a chained receiver has no value — fence
     // it instead of emitting a void receiver.
@@ -2964,23 +3241,25 @@ export function lowerMapMethodCall(lowerer, call, access) {
         lowerer.noLowering(`.forEach with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
     }
     if (name === "get") {
-        const k = lowerer.lowerExprExpecting(call.arguments[0], receiverIr.key);
+        const k = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.key);
         // The checker types the call `V | undefined`, which interns the
         // result union. `undefined` sorts LAST among all possible arm
         // typeKeys, so when V is itself a union its arms keep their tags in
         // the result union — the backend leans on that (docs/ir.md).
-        const type = lowerer.irTypeOf(call);
-        if (type.kind !== "union")
+        const type = receiverIr.value.kind === "dyn" ? DYN : lowerer.irTypeOf(call);
+        if (type.kind !== "union" && type.kind !== "dyn")
             lowerer.badType(call, lowerer.typeOf(call));
         return { kind: "mapIntrinsic", method: "get", receiver, args: [k], type, loc };
     }
     if (name === "set") {
-        const k = lowerer.lowerExprExpecting(call.arguments[0], receiverIr.key);
-        const v = lowerer.lowerExprExpecting(call.arguments[1], receiverIr.value);
+        const k = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.key);
+        const v = receiverIr.value.kind === "dyn"
+            ? lowerer.lowerCollectionKey(call.arguments[1], receiverIr.value)
+            : lowerer.lowerExprExpecting(call.arguments[1], receiverIr.value);
         return { kind: "mapIntrinsic", method: "set", receiver, args: [k, v], type: VOID, loc };
     }
     if (name === "has" || name === "delete") {
-        const k = lowerer.lowerExprExpecting(call.arguments[0], receiverIr.key);
+        const k = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.key);
         return { kind: "mapIntrinsic", method: name, receiver, args: [k], type: BOOL, loc };
     }
     if (name === "clear") {
@@ -3100,6 +3379,65 @@ function buildMapIterDrainFn(name, mapT, method, elemT, tupleT, loc) {
         loc,
     };
 }
+/** An immediate Map spread observes the same entry order as entries().
+ * Each pair is new; its key and value retain their original identities. */
+export function mapEntriesArray(lowerer, receiver) {
+    const mapT = receiver.type;
+    if (mapT.kind !== "map")
+        throw new InternalCompilerError("Map entries require a map");
+    const tupleT = {
+        kind: "record", shapeId: lowerer.shapes.intern([
+            { name: "0", type: mapT.key }, { name: "1", type: mapT.value },
+        ], true),
+    };
+    const key = `entries:${typeKey(mapT.key)}:${typeKey(mapT.value)}`;
+    let helper = lowerer.mapHofHelpers.get(key);
+    if (!helper) {
+        helper = `%map.entries.${lowerer.mapHofHelpers.size}`;
+        lowerer.mapHofHelpers.set(key, helper);
+        lowerer.liftedFns.push(buildMapIterDrainFn(helper, mapT, "entries", tupleT, tupleT, receiver.loc));
+    }
+    return { kind: "call", callee: helper, args: [receiver], type: arrayOf(tupleT), loc: receiver.loc };
+}
+/** Snapshot a collection for immediate iteration. Array reads and callback
+ * parameters may retain an undefined arm even when the checker spells a
+ * bare collection. Observe that arm before touching native storage. */
+export function lowerCollectionSpread(lowerer, source, node) {
+    if (source.type.kind === "map")
+        return mapEntriesArray(lowerer, source);
+    if (source.type.kind === "set")
+        return {
+            kind: "setIntrinsic", method: "toArray", receiver: source, args: [], type: arrayOf(source.type.elem), loc: source.loc,
+        };
+    if (source.type.kind !== "union")
+        return null;
+    const arms = lowerer.unions.get(source.type.unionId)?.arms;
+    const tag = arms?.findIndex((arm) => arm.kind === "map" || arm.kind === "set") ?? -1;
+    const collection = arms?.[tag];
+    if ((collection?.kind !== "map" && collection?.kind !== "set") ||
+        !arms?.every((arm, index) => index === tag || isUnitType(arm)))
+        return null;
+    const loc = locOf(node);
+    const slot = lowerer.declareHiddenLocal("%collectionSpread", source.type);
+    const value = varRef(slot.id, source.type, loc);
+    const narrowed = {
+        kind: "unionNarrow", unionId: source.type.unionId, tag, value, type: collection, loc,
+    };
+    const entries = collection.kind === "map"
+        ? mapEntriesArray(lowerer, narrowed)
+        : { kind: "setIntrinsic", method: "toArray", receiver: narrowed, args: [], type: arrayOf(collection.elem), loc };
+    return {
+        kind: "seqExpr", stmts: [{ kind: "varDecl", localId: slot.id, init: source, loc }],
+        result: {
+            kind: "ternary",
+            cond: { kind: "unionIsTag", unionId: source.type.unionId, tag, value, negated: false, type: BOOL, loc },
+            then: entries,
+            else_: nodeThrowExpr(1, "", `${node.getText()} is not iterable`, entries.type, loc),
+            type: entries.type, loc,
+        },
+        type: entries.type, loc,
+    };
+}
 /** `m.forEach(fn)` desugars to a direct call of a synthetic module
    * function — one per key/value type + callback arity, interned — whose
    * body is an index loop over the map's ITERATION PRIMITIVES: read
@@ -3285,10 +3623,14 @@ export function lowerSetMethodCall(lowerer, call, access) {
     }
     if (receiverIr?.kind !== "set")
         return null;
-    if (!lowerer.isStdlibMember(access))
+    // A collection interface may refine has() into a type predicate.
+    // Type mapping checked that view's native ABI; the value check below
+    // still rejects structural mocks and assertions over other objects.
+    if (!lowerer.isStdlibMember(access) && name !== "has")
         return null;
     const loc = locOf(call);
-    const receiver = lowerer.lowerExpr(access.expression);
+    const value = lowerer.lowerExpr(access.expression);
+    const receiver = lowerer.runtimeOptionalPropertyReceiver(access.expression, value, receiverIr, name) ?? value;
     // The lib's `add` returns the Set (chaining typechecks); the lowered
     // add is a void statement — fence chained receivers like Map's set.
     if (receiver.type.kind !== "set") {
@@ -3301,11 +3643,11 @@ export function lowerSetMethodCall(lowerer, call, access) {
         return lowerSetCombineCall(lowerer, call, name, receiver, receiverIr);
     }
     if (name === "add") {
-        const v = lowerer.lowerExprExpecting(call.arguments[0], receiverIr.elem);
+        const v = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.elem);
         return { kind: "setIntrinsic", method: "add", receiver, args: [v], type: VOID, loc };
     }
     if (name === "has" || name === "delete") {
-        const v = lowerer.lowerExprExpecting(call.arguments[0], receiverIr.elem);
+        const v = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.elem);
         return { kind: "setIntrinsic", method: name, receiver, args: [v], type: BOOL, loc };
     }
     if (name === "clear") {
@@ -3771,7 +4113,11 @@ export function lowerIteratorHelperCall(lowerer, call, access) {
     if (terminal !== "forEach" && (checkerT === null || !typeEquals(checkerT, resultT))) {
         lowerer.noLowering(`.${terminal} at this result type`, call, "the chain's element and result types must be representable — annotate the callbacks' types");
     }
-    const stageKeys = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.kind : `${s.kind}:${typeKey(s.fn.type)}`));
+    const stageKeys = stageIrs.map((s) => {
+        if (!s)
+            throw new InternalCompilerError("missing iterator stage");
+        return "budget" in s ? s.kind : `${s.kind}:${typeKey(s.fn.type)}`;
+    });
     const key = `iter:${srcProj}:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {
@@ -3779,7 +4125,11 @@ export function lowerIteratorHelperCall(lowerer, call, access) {
         lowerer.arrHofHelpers.set(key, helper);
         lowerer.liftedFns.push(buildIterChainFn(lowerer, helper, items.type, srcProj, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
     }
-    const budgetOrFn = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.budget : s.fn));
+    const budgetOrFn = stageIrs.map((s) => {
+        if (!s)
+            throw new InternalCompilerError("missing iterator stage");
+        return "budget" in s ? s.budget : s.fn;
+    });
     return { kind: "call", callee: helper, args: [items, ...budgetOrFn, ...termArgs], type: resultT, loc };
 }
 const ITER_STAGES = new Set(["map", "filter", "take", "drop", "flatMap"]);
@@ -4457,6 +4807,8 @@ export function lowerForOfSearchParams(lowerer, stmt, iterable, proj) {
 export function lowerForOfArrayIter(lowerer, stmt, iterable, proj) {
     const loc = locOf(stmt);
     const arrT = iterable.type;
+    if (arrT.kind !== "array" && arrT.kind !== "bytes")
+        throw new InternalCompilerError("array iterator requires indexed storage");
     const elemT = arrT.kind === "array" ? arrayValueType(lowerer, arrT.elem) : F64;
     const yieldsPair = proj === "entries";
     if (!ts.isVariableDeclarationList(stmt.initializer)) {
@@ -4835,7 +5187,11 @@ function exitBeforeReturns(stmts, make) {
             case "block":
                 return [{ ...s, body: walk(s.body) }];
             case "switch":
-                return [{ ...s, cases: s.cases.map((c) => ({ ...c, body: walk(c.body) })) }];
+                return [{ ...s, cases: s.cases.map((c) => {
+                            if (!c)
+                                throw new InternalCompilerError("missing switch clause");
+                            return { ...c, body: walk(c.body) };
+                        }) }];
             case "tryCatch":
                 return [
                     {
@@ -4851,18 +5207,290 @@ function exitBeforeReturns(stmts, make) {
     });
     return walk(stmts);
 }
-/** `new Map(entries)` from a tuple-array VALUE — any `[K, V][]`-typed
-   * expression (a variable, a .map() result, a sorted entries spread), not
-   * just the pair-literal form lower-classes handles inline. Desugars to a
-   * direct call of a synthetic function that constructs the empty map and
-   * set()s each pair in array order — JS-exact: pairs are visited in
-   * insertion order and a later duplicate key overwrites while keeping the
-   * first occurrence's position (set()'s own contract). Null when the
-   * argument isn't a matching tuple array (the caller keeps its fence). */
-export function lowerMapSeedArrayNew(lowerer, argNode, mapT) {
+/** Consume a Set seed immediately, including optional inherited sets used
+ * by compiler tables. Nullish seeds construct empty sets; a lazy fallback
+ * consumes its evaluated branch even when it reassigns the source binding. */
+export function lowerSetSeedNew(lowerer, node, setT) {
+    if (ts.isSpreadElement(node))
+        return null;
+    while (ts.isParenthesizedExpression(node))
+        node = node.expression;
+    const loc = locOf(node);
+    const undefinedSeed = lowerStaticallyUndefinedArgument(lowerer, node);
+    if (undefinedSeed)
+        return defaultAfterUndefined(undefinedSeed, { kind: "setNew", type: setT, loc });
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const undefinedLeft = lowerStaticallyUndefinedArgument(lowerer, node.left);
+        const fallback = node.right;
+        if (undefinedLeft) {
+            const selected = lowerSetSeedNew(lowerer, fallback, setT);
+            return selected ? defaultAfterUndefined(undefinedLeft, selected) : null;
+        }
+        const source = lowerer.lowerExpr(node.left);
+        if (isUnitType(source.type)) {
+            const selected = lowerSetSeedNew(lowerer, fallback, setT);
+            return selected ? defaultAfterUndefined(source, selected) : null;
+        }
+        return setFromSeedValue(lowerer, source, setT, () => lowerSetSeedNew(lowerer, fallback, setT));
+    }
+    if (ts.isConditionalExpression(node)) {
+        const yes = lowerSetSeedNew(lowerer, node.whenTrue, setT);
+        const no = lowerSetSeedNew(lowerer, node.whenFalse, setT);
+        return yes && no ? { kind: "ternary", cond: lowerer.lowerCondition(node.condition), then: yes, else_: no, type: setT, loc } : null;
+    }
+    // Constructor contextual types include Iterable<T>, which has no value
+    // representation. Build a literal at the actual Set element ABI instead.
+    if (ts.isArrayLiteralExpression(node) && !node.elements.some(ts.isSpreadElement)) {
+        const elems = node.elements.map((element) => lowerer.lowerCollectionKey(element, setT.elem));
+        return { kind: "setNew", seed: { kind: "arrayLit", elems, type: arrayOf(setT.elem), loc }, type: setT, loc };
+    }
+    const declared = lowerer.mapTypeOf(lowerer.typeOf(node));
+    const scalar = setT.elem.kind === "f64" || setT.elem.kind === "string";
+    let source = !scalar && (declared?.kind === "array" || declared?.kind === "record")
+        ? lowerer.lowerCollectionKey(node, declared)
+        : lowerer.lowerExpr(node);
+    if (declared?.kind === "string" && setT.elem.kind === "string" &&
+        (source.type.kind === "dyn" || source.type.kind === "jsval")) {
+        source = lowerer.coerceInto(node, source, STRING);
+    }
+    if (source.type.kind === "dyn" && setT.elem.kind === "dyn") {
+        return { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.nativeSetNew", args: [source], type: DYN, loc }, type: setT, loc };
+    }
+    if (declared?.kind === "array" && typeEquals(declared.elem, setT.elem)) {
+        // Preserve the existing checked scalar-iterable bridge. Reference
+        // elements must retain identity and cannot enter via a copying exit.
+        if (source.type.kind === "jsval" && lowerer.boundaryExitSafe(arrayOf(setT.elem))) {
+            source = { kind: "jsExit", value: source, type: arrayOf(setT.elem), loc };
+        }
+        if (source.type.kind === "dyn" && scalar) {
+            source = lowerer.coerceInto(node, {
+                kind: "libCall", fn: "dyn.iterPack", args: [source, strLit(node.getText(), loc)], type: DYN, loc,
+            }, arrayOf(setT.elem));
+        }
+    }
+    return setFromSeedValue(lowerer, source, setT, () => ({ kind: "setNew", type: setT, loc }));
+}
+function setFromSeedValue(lowerer, source, setT, missing) {
+    const loc = source.loc;
+    if (isUnitType(source.type)) {
+        const empty = missing();
+        return empty ? defaultAfterUndefined(source, empty) : null;
+    }
+    if (source.type.kind === "union") {
+        const unionId = source.type.unionId;
+        const arms = lowerer.unions.get(unionId)?.arms;
+        if (!arms)
+            return null;
+        const slot = lowerer.declareHiddenLocal("%setSeed", source.type);
+        const ref = varRef(slot.id, source.type, loc);
+        let result = null;
+        for (let tag = arms.length - 1; tag >= 0; tag--) {
+            const arm = arms[tag];
+            const branch = isUnitType(arm) ? missing() : setFromSeedValue(lowerer, {
+                kind: "unionNarrow", unionId, tag, value: ref, type: arm, loc,
+            }, setT, missing);
+            if (!branch)
+                return null;
+            result = result === null ? branch : {
+                kind: "ternary", cond: { kind: "unionIsTag", unionId, tag, value: ref, negated: false, type: BOOL, loc },
+                then: branch, else_: result, type: setT, loc,
+            };
+        }
+        return result ? {
+            kind: "seqExpr", stmts: [{ kind: "varDecl", localId: slot.id, init: source, loc }], result, type: setT, loc,
+        } : null;
+    }
+    let seed;
+    if (source.type.kind === "set" && typeEquals(source.type, setT)) {
+        seed = { kind: "setIntrinsic", method: "toArray", receiver: source, args: [], type: arrayOf(setT.elem), loc };
+    }
+    else if (source.type.kind === "string" && setT.elem.kind === "string") {
+        seed = strCharsCall(lowerer, source, loc);
+    }
+    else if (source.type.kind === "array" && typeEquals(source.type.elem, setT.elem)) {
+        seed = source;
+    }
+    else if (source.type.kind === "record") {
+        const shape = lowerer.shapes.get(source.type.shapeId);
+        if (!shape?.tuple || !shape.fields.every((field) => typeEquals(field.type, setT.elem)))
+            return null;
+        const arrayT = { kind: "array", elem: setT.elem };
+        const helper = lowerer.tupleArrayWidthHelper(source.type.shapeId, arrayT, loc);
+        if (!helper)
+            return null;
+        seed = { kind: "call", callee: helper, args: [source], type: arrayT, loc };
+    }
+    else
+        return null;
+    return { kind: "setNew", seed, type: setT, loc };
+}
+/** Consume supported Map seeds: matching Maps and tuple arrays, plus
+ * nullish values that construct an empty Map. Conditional/nullish seeds
+ * select one lazy branch without representing a first-class iterable.
+ * Copy loops preserve entry order and stored reference identities. */
+export function lowerMapSeedNew(lowerer, argNode, mapT) {
     if (ts.isSpreadElement(argNode))
         return null;
+    const empty = lowerer.emptyCollectionFor(argNode, mapT);
+    if (empty)
+        return empty;
+    while (ts.isParenthesizedExpression(argNode))
+        argNode = argNode.expression;
+    // A constructor consumes either iterable branch immediately. It does
+    // not need a first-class Map|array representation for `cached ?? []`.
+    // Snapshot the left before the lazy fallback can mutate its binding.
+    if (ts.isBinaryExpression(argNode) && argNode.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const source = lowerer.lowerExpr(argNode.left);
+        if (isUnitType(source.type)) {
+            const fallback = lowerMapSeedNew(lowerer, argNode.right, mapT);
+            return fallback ? defaultAfterUndefined(source, fallback) : null;
+        }
+        if (source.type.kind !== "union")
+            return mapFromSeedValue(lowerer, source, mapT);
+        const arms = lowerer.unions.get(source.type.unionId)?.arms;
+        if (!arms)
+            return null;
+        const loc = locOf(argNode);
+        const saved = lowerer.declareHiddenLocal("%mapSeed", source.type);
+        const ref = varRef(saved.id, source.type, loc);
+        let result = null;
+        for (let tag = arms.length - 1; tag >= 0; tag--) {
+            const arm = arms[tag];
+            const branch = isUnitType(arm)
+                ? lowerMapSeedNew(lowerer, argNode.right, mapT)
+                : mapFromSeedValue(lowerer, { kind: "unionNarrow", unionId: source.type.unionId, tag, value: ref, type: arm, loc }, mapT);
+            if (!branch)
+                return null;
+            result = result === null ? branch : {
+                kind: "ternary",
+                cond: { kind: "unionIsTag", unionId: source.type.unionId, tag, value: ref, negated: false, type: BOOL, loc },
+                then: branch, else_: result, type: mapT, loc,
+            };
+        }
+        return result ? { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: source, loc }], result, type: mapT, loc } : null;
+    }
+    if (ts.isConditionalExpression(argNode)) {
+        const yes = lowerMapSeedNew(lowerer, argNode.whenTrue, mapT);
+        const no = lowerMapSeedNew(lowerer, argNode.whenFalse, mapT);
+        return yes && no ? { kind: "ternary", cond: lowerer.lowerCondition(argNode.condition), then: yes, else_: no, type: mapT, loc: locOf(argNode) } : null;
+    }
+    if (ts.isArrayLiteralExpression(argNode)) {
+        if (isJsSourceFile(argNode.getSourceFile()) && argNode.elements.some((entry) => !ts.isArrayLiteralExpression(entry))) {
+            return mapFromSeedValue(lowerer, lowerer.lowerExprExpecting(argNode, DYN), mapT);
+        }
+        const tuple = { kind: "record", shapeId: lowerer.shapes.intern([
+                { name: "0", type: mapT.key }, { name: "1", type: mapT.value },
+            ], true) };
+        return mapFromSeedValue(lowerer, lowerer.lowerArrayLiteral(argNode, { kind: "array", elem: tuple }), mapT);
+    }
     const seed = lowerer.lowerExpr(argNode);
+    return mapFromSeedValue(lowerer, seed, mapT);
+}
+function mapFromSeedValue(lowerer, seed, mapT) {
+    const loc = seed.loc;
+    if (isUnitType(seed.type)) {
+        return defaultAfterUndefined(seed, { kind: "mapNew", type: mapT, loc });
+    }
+    if (seed.type.kind === "union") {
+        const arms = lowerer.unions.get(seed.type.unionId)?.arms;
+        if (!arms)
+            return null;
+        const saved = lowerer.declareHiddenLocal("%mapSeed", seed.type);
+        const ref = varRef(saved.id, seed.type, loc);
+        let result = null;
+        for (let tag = arms.length - 1; tag >= 0; tag--) {
+            const arm = arms[tag];
+            const branch = isUnitType(arm) ? { kind: "mapNew", type: mapT, loc }
+                : mapFromSeedValue(lowerer, { kind: "unionNarrow", unionId: seed.type.unionId, tag, value: ref, type: arm, loc }, mapT);
+            if (!branch)
+                return null;
+            result = result === null ? branch : {
+                kind: "ternary",
+                cond: { kind: "unionIsTag", unionId: seed.type.unionId, tag, value: ref, negated: false, type: BOOL, loc },
+                then: branch, else_: result, type: mapT, loc,
+            };
+        }
+        return result ? { kind: "seqExpr", stmts: [{ kind: "varDecl", localId: saved.id, init: seed, loc }], result, type: mapT, loc } : null;
+    }
+    if (seed.type.kind === "map") {
+        if (!typeEquals(seed.type, mapT))
+            return null;
+        const key = `copy:${typeKey(mapT)}`;
+        let name = lowerer.mapHofHelpers.get(key);
+        if (!name) {
+            name = `%map.copy.${lowerer.mapHofHelpers.size}`;
+            lowerer.mapHofHelpers.set(key, name);
+            const source = varRef("source.0", mapT, loc);
+            const target = varRef("target.0", mapT, loc);
+            const index = varRef("i.0", F64, loc);
+            const read = (method, type) => ({
+                kind: "mapIntrinsic", method, receiver: source, args: method === "iterCount" ? [] : [index], type, loc,
+            });
+            lowerer.liftedFns.push({
+                name, params: [{ localId: "source.0", name: "source", type: mapT }], returnType: mapT,
+                locals: [
+                    { id: "source.0", name: "source", type: mapT, mutable: false },
+                    { id: "target.0", name: "target", type: mapT, mutable: false },
+                    { id: "i.0", name: "i", type: F64, mutable: true },
+                ],
+                body: [
+                    { kind: "varDecl", localId: "target.0", init: { kind: "mapNew", type: mapT, loc }, loc },
+                    countedFor(loc, read("iterCount", F64), () => [{
+                            kind: "if", cond: read("iterLive", BOOL), then: [{ kind: "exprStmt", expr: {
+                                        kind: "mapIntrinsic", method: "set", receiver: target,
+                                        args: [read("iterKey", mapT.key), read("iterValue", mapT.value)], type: VOID, loc,
+                                    }, loc }], else_: null, loc,
+                        }]),
+                    { kind: "return", value: target, loc },
+                ], loc,
+            });
+        }
+        return { kind: "call", callee: name, args: [seed], type: mapT, loc };
+    }
+    if (seed.type.kind === "dyn" || seed.type.kind === "array" && seed.type.elem.kind === "dyn") {
+        const key = `checked-seed:${typeKey(mapT)}`;
+        let name = lowerer.mapHofHelpers.get(key);
+        if (!name) {
+            name = `%map.checkedSeed.${lowerer.mapHofHelpers.size}`;
+            lowerer.mapHofHelpers.set(key, name);
+            const source = varRef("source.0", DYN, loc);
+            const entries = varRef("entries.0", DYN, loc);
+            const entry = varRef("entry.0", DYN, loc);
+            const target = varRef("target.0", mapT, loc);
+            const keyValue = varRef("key.0", DYN, loc);
+            const itemValue = varRef("value.0", DYN, loc);
+            const checked = (value, type) => type.kind === "dyn" ? value
+                : { kind: "dynCheck", value, type, loc };
+            lowerer.liftedFns.push({
+                name, params: [{ localId: "source.0", name: "source", type: DYN }], returnType: mapT,
+                locals: [
+                    { id: "source.0", name: "source", type: DYN, mutable: false },
+                    { id: "entries.0", name: "entries", type: DYN, mutable: false },
+                    { id: "entry.0", name: "entry", type: DYN, mutable: false },
+                    { id: "key.0", name: "key", type: DYN, mutable: false },
+                    { id: "value.0", name: "value", type: DYN, mutable: false },
+                    { id: "target.0", name: "target", type: mapT, mutable: false },
+                    { id: "i.0", name: "i", type: F64, mutable: true },
+                ],
+                body: [
+                    { kind: "varDecl", localId: "target.0", init: { kind: "mapNew", type: mapT, loc }, loc },
+                    { kind: "varDecl", localId: "entries.0", init: { kind: "libCall", fn: "dyn.mapSeedEntries", args: [source], type: DYN, loc }, loc },
+                    countedFor(loc, { kind: "libCall", fn: "dyn.arrLen", args: [entries], type: F64, loc }, () => [
+                        { kind: "varDecl", localId: "entry.0", init: { kind: "libCall", fn: "dyn.mapSeedEntry", args: [
+                                    { kind: "libCall", fn: "dyn.arrAt", args: [entries, varRef("i.0", F64, loc)], type: DYN, loc },
+                                ], type: DYN, loc }, loc },
+                        { kind: "varDecl", localId: "key.0", init: { kind: "dynKeyGet", value: entry, key: strLit("0", loc), type: DYN, loc }, loc },
+                        { kind: "varDecl", localId: "value.0", init: { kind: "dynKeyGet", value: entry, key: strLit("1", loc), type: DYN, loc }, loc },
+                        { kind: "exprStmt", expr: { kind: "mapIntrinsic", method: "set", receiver: target,
+                                args: [checked(keyValue, mapT.key), checked(itemValue, mapT.value)], type: VOID, loc }, loc },
+                    ]),
+                    { kind: "return", value: target, loc },
+                ], loc,
+            });
+        }
+        const source = seed.type.kind === "dyn" ? seed : { kind: "dynFrom", value: seed, type: DYN, loc };
+        return { kind: "call", callee: name, args: [source], type: mapT, loc };
+    }
     if (seed.type.kind !== "array" || seed.type.elem.kind !== "record")
         return null;
     const elem = seed.type.elem;
@@ -4873,7 +5501,6 @@ export function lowerMapSeedArrayNew(lowerer, argNode, mapT) {
     const vT = shape.fields.find((f) => f.name === "1").type;
     if (!typeEquals(kT, mapT.key) || !typeEquals(vT, mapT.value))
         return null;
-    const loc = locOf(argNode);
     const key = `seed:${typeKey(mapT.key)}:${typeKey(mapT.value)}:${elem.shapeId}`;
     let helper = lowerer.mapHofHelpers.get(key);
     if (!helper) {
@@ -4946,7 +5573,7 @@ export function lowerObjectIterOverIndexShape(lowerer, call, member, argIr, shap
     const resultT = lowerer.irTypeOf(call);
     if (resultT.kind !== "array")
         lowerer.badType(call, lowerer.typeOf(call)); // defensive
-    return objectIterOverIndexShape(lowerer, call, member, argIr, shape, lowerer.lowerExpr(call.arguments[0]), resultT, locOf(call));
+    return objectIterOverIndexShape(lowerer, call, member, argIr, shape, objectEnumerationReceiver(lowerer, lowerer.lowerExpr(call.arguments[0]), argIr, locOf(call)), resultT, locOf(call));
 }
 /** The construction core, receiver/result pre-resolved — `node` anchors
  * the fences. for-in reuses the "keys" arm directly (it iterates exactly
@@ -5146,6 +5773,21 @@ export function objectIterOverIndexShape(lowerer, node, member, argIr, shape, re
    * (lowerRecordOvfCaptureHelper). Null when the argument or result shape
    * is outside this (Maps, richer iterables → the SC2020 fence). */
 export function lowerObjectFromEntriesCall(lowerer, call, callee) {
+    const typed = lowerTypedObjectFromEntriesCall(lowerer, call, callee);
+    if (typed)
+        return typed;
+    if (!ts.isPropertyAccessExpression(callee) || call.questionDotToken || callee.questionDotToken ||
+        !lowerer.isStdlibGlobal(callee.expression, "Object") || callee.name.text !== "fromEntries" ||
+        call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0]))
+        return null;
+    if (lowerer.dynamic)
+        return null;
+    return {
+        kind: "libCall", fn: "dyn.fromEntries", type: DYN, loc: locOf(call),
+        args: [lowerer.lowerExprExpecting(call.arguments[0], DYN)],
+    };
+}
+function lowerTypedObjectFromEntriesCall(lowerer, call, callee) {
     if (!ts.isPropertyAccessExpression(callee))
         return null;
     if (call.questionDotToken || callee.questionDotToken)
@@ -5202,7 +5844,10 @@ export function lowerObjectFromEntriesCall(lowerer, call, callee) {
     if (!convertible) {
         lowerer.unsupported("SC1090", call, `Object.fromEntries over '${lowerer.fmt(argIr)}' (the tuple's '${lowerer.fmt(valT)}' value cannot flow into the '${lowerer.fmt(iv)}' signature slot)`);
     }
-    const receiver = lowerer.lowerExpr(argNode);
+    // Enumeration/filtering may keep the array in checked-dynamic storage.
+    // Validate its tuple layout before calling a helper with a native-array
+    // ABI; opaque tuple values themselves retain their original references.
+    const receiver = lowerer.lowerExprExpecting(argNode, argIr);
     const key = `obj.fromEntries:${argIr.elem.shapeId}:${resultT.shapeId}`;
     let helper = lowerer.arrHofHelpers.get(key);
     if (!helper) {