@scriptc/compiler 0.2.0 → 0.2.2

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

@@ -1,6 +1,9 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import { type IrExpr, type IrFunction, type IrRecordShape, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
+/** Object() and new Object() preserve known object inputs. Primitive
+ * boxing and unproven checked-dynamic values retain their refusal. */
+export declare function lowerObjectConstructor(lowerer: Lowerer, args: readonly ts.Expression[], loc: SrcLoc): IrExpr | null;
 /** Ambient array method calls. `push`/`unshift`/`pop`/`reverse`/
  * `indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
@@ -29,6 +32,12 @@ export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
 export declare function lowerArrayConstructor(lowerer: Lowerer, expr: ts.CallExpression | ts.NewExpression, args: readonly ts.Expression[]): IrExpr;
 /** `Array.of` creates an array of its arguments, including a lone number. */
 export declare function lowerArrayOfCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+/** Mapper-less checked Array.from: acquire once, then step through emitted
+ * property and call dispatch so native class iterators retain their methods. */
+export declare function lowerCheckedArrayFrom(lowerer: Lowerer, source: IrExpr, loc: SrcLoc, mapper?: IrExpr, receiver?: IrExpr, numeric?: boolean, iterable?: IrExpr): Extract<IrExpr, {
+    kind: "seqExpr";
+}>;
+export declare function lowerArrayFromValue(lowerer: Lowerer, loc: SrcLoc): IrExpr;
 /** `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

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

@@ -6,7 +6,7 @@ import { InternalCompilerError } from "../../errors.js";
  * record operations. */
 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 { ARRAY_METHODS, COLLECTION_ITERATOR_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS } from "./surfaces.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
@@ -14,10 +14,25 @@ import { islandPrimitiveExit, lowerDynDispatchMethodCall } from "./lower-calls.j
 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 { dynUndefinedExpr, newFnCtx, 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";
+/** Object() and new Object() preserve known object inputs. Primitive
+ * boxing and unproven checked-dynamic values retain their refusal. */
+export function lowerObjectConstructor(lowerer, args, loc) {
+    if (args.length === 0) {
+        return { kind: "recordLit", fields: [], type: { kind: "record", shapeId: lowerer.shapes.intern([]) }, loc };
+    }
+    if (args.length !== 1 || ts.isSpreadElement(args[0]))
+        return null;
+    const value = lowerer.lowerExpr(args[0]);
+    if (value.kind === "dynObjLit" || value.kind === "dynArrLit")
+        return value;
+    if (["record", "array", "object", "regex", "date", "bytes", "map", "set", "func", "classval"].includes(value.type.kind))
+        return value;
+    return null;
+}
 function primitivePositionType(lowerer, type) {
     if (type.kind === "union") {
         return lowerer.unions.get(type.unionId)?.arms.every((arm) => primitivePositionType(lowerer, arm)) ?? false;
@@ -144,9 +159,6 @@ function lowerArrayJoinSeparator(lowerer, node, loc) {
  * directly from its IR return type. Fence element kinds ScrArr cannot hold
  * before constructing that array type. */
 function fenceProducedArrayElem(lowerer, node, producer, elem) {
-    if (elem.kind === "dyn") {
-        lowerer.unsupported("SC1090", node, `${producer} with a callback returning 'unknown'-typed values (the result array has no static element type — annotate the callback's return)`);
-    }
     if (!isSupportedArrayElem(elem)) {
         lowerer.unsupported("SC1090", node, `${producer} with a callback returning '${lowerer.fmt(elem)}' values (arrays of this element kind have no representation — store the values individually)`);
     }
@@ -545,7 +557,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                     // IsArray says spread; no honest static answer exists.
                     lowerer.unsupported("SC1090", argNode, "concat of a bare inner array onto an array-of-arrays (JS would SPREAD it one level — wrap it: a.concat([inner]))");
                 }
-                const arg = lowerer.lowerExpr(argNode);
+                // Declaration-backed JS methods can return checked values even
+                // when their public signature names a concrete array. Validate
+                // that boundary before spreading the represented elements.
+                let arg = lowerer.lowerExpr(argNode);
+                if (arg.type.kind === "dyn")
+                    arg = lowerer.coerceInto(argNode, arg, argArrayType);
                 if (arg.type.kind !== "array")
                     lowerer.badType(argNode, lowerer.typeOf(argNode));
                 shape.push("a");
@@ -615,6 +632,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         return { kind: "arrIntrinsic", method: "shift", receiver, args: [], type: arrayValueType(lowerer, elem), loc };
     }
     if (name === "join") {
+        if (elem.kind === "dyn") {
+            const receiver = lowerer.coerceToExpected(lowerer.lowerExpr(access.expression), DYN);
+            const args = call.arguments.length ? [lowerer.lowerExprExpecting(call.arguments[0], DYN)] : [];
+            return lowerer.coerceToExpected({ kind: "dynInvoke", recv: receiver, method: "join",
+                calleeName: access.getText(), args, type: DYN, loc }, STRING);
+        }
         // The ambient declares join on every Array<T> (a per-element-type
         // interface split isn't expressible there), so string-convertible
         // elements are enforced here: nested arrays would need JS's recursive
@@ -1686,6 +1709,9 @@ export function lowerTupleReadMethodCall(lowerer, call, access, tupleReceiver) {
     const ret = fnArg.type.ret;
     if (ret.kind === "void" || ret.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
+    if (method === "flatMap" && (ret.kind === "dyn" || ret.kind === "jsval" || (ret.kind === "record" && lowerer.shapes.get(ret.shapeId)?.tuple))) {
+        return { kind: "dynInvoke", recv: { kind: "dynFrom", value: receiver, type: DYN, loc }, method: "flatMap", calleeName: access.getText(), args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }], type: DYN, 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");
     }
@@ -1975,8 +2001,7 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem
    * undefined unit arm (for REF elements that arm is the unit instance, the
    * standard union machinery). The Last pair is the SAME loop walked
    * backwards (`i = n - 1; i >= 0; i--`), exactly the es2023 spec's
-   * descending index walk. All require a bool-returning callback
-   * (JS's ToBoolean of arbitrary predicate results has no lowering). */
+   * descending index walk. Predicate results use JavaScript ToBoolean. */
 function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped = false) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
@@ -1991,7 +2016,7 @@ function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped
     // `packages.some((p) => p.scripts[name])` idiom, whose callback
     // returns the index read's `string | undefined`).
     const fnRet = fnArg.type.ret;
-    const truthyRet = fnRet.kind === "bool" || fnRet.kind === "f64" || fnRet.kind === "string" ||
+    const truthyRet = fnRet.kind === "bool" || fnRet.kind === "f64" || fnRet.kind === "string" || fnRet.kind === "dyn" ||
         (fnRet.kind === "union" &&
             (lowerer.unions.get(fnRet.unionId)?.arms ?? []).every((a) => a.kind !== "dyn" && a.kind !== "caught" && a.kind !== "jsval"));
     if (!truthyRet)
@@ -2044,11 +2069,13 @@ function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
 }
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
-   * ensureBool subset the find-like path admits (bool through; f64/string/
-   * truthy-answerable unions via toBool). */
+   * ensureBool subset the find-like path admits (bool through; checked
+   * values via dynTest; f64/string/truthy-answerable unions via toBool). */
 function predToBool(e) {
     if (e.type.kind === "bool")
         return e;
+    if (e.type.kind === "dyn")
+        return { kind: "dynTest", test: "truthy", value: e, type: BOOL, loc: e.loc };
     return { kind: "toBool", operand: e, type: BOOL, loc: e.loc };
 }
 /** The find loop, from existing IR nodes:
@@ -2250,6 +2277,9 @@ function lowerArrayFlatMapCall(lowerer, call, access, elem) {
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT);
     const fnRet = fnArg.type.ret;
+    if (fnRet.kind === "dyn" || fnRet.kind === "jsval" || (fnRet.kind === "record" && lowerer.shapes.get(fnRet.shapeId)?.tuple)) {
+        return { kind: "dynInvoke", recv: { kind: "dynFrom", value: receiver, liveRef: true, type: DYN, loc }, method: "flatMap", calleeName: access.getText(), args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }], type: DYN, loc };
+    }
     if (fnRet.kind === "union") {
         const def = lowerer.unions.get(fnRet.unionId);
         if (def?.arms.some((a) => a.kind === "array")) {
@@ -2778,6 +2808,14 @@ export function lowerArrayConstructor(lowerer, expr, args) {
         lowerer.noLowering("Array constructor with spread arguments", expr);
     }
     let result = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    // Constructors without a concrete element layout keep their checked
+    // reference. Known element forms retain native arrays, including their
+    // existing sparse storage and indexed property contracts.
+    if (!lowerer.dynamic && isJsSourceFile(expr.getSourceFile()) &&
+        (result?.kind !== "array" || result.elem.kind === "dyn")) {
+        return { kind: "dynCall", callee: { kind: "libCall", fn: "dyn.arrayConstructor", args: [], type: DYN, loc },
+            calleeName: "Array", args: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
+    }
     if (result?.kind !== "array") {
         const contextual = lowerer.checker.getContextualType(expr);
         if (contextual)
@@ -2866,31 +2904,82 @@ export function lowerArrayOfCall(lowerer, call, access) {
 }
 /** 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) {
+export function lowerCheckedArrayFrom(lowerer, source, loc, mapper, receiver, numeric = false, iterable) {
     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 index = mapper ? lowerer.declareHiddenLocal("%fromIndex", F64) : null;
+    if (index)
+        index.mutable = true;
     const get = (value, key) => ({ kind: "dynKeyGet", value, key: strLit(key, loc), type: DYN, loc });
+    const item = get(varRef(step.id, DYN, loc), "value");
+    const mapped = mapper && index ? { kind: "ternary", cond: { kind: "dynTest", test: "undefined", value: mapper, type: BOOL, loc },
+        then: item, else_: { kind: "dynCall", callee: mapper, ...(receiver ? { receiver } : {}), calleeName: "Array.from mapper", args: [item, lowerer.coerceToExpected(varRef(index.id, F64, loc), DYN)], type: DYN, loc }, type: DYN, loc } : item;
+    const element = numeric ? lowerer.coerceToExpected({ kind: "libCall", fn: "dyn.toNumberCoerce", args: [mapped], type: F64, loc }, DYN) : mapped;
+    let append = { kind: "exprStmt", expr: { kind: "dynInvoke", recv: varRef(out.id, DYN, loc), method: "push", calleeName: "Array.from", args: [element], type: DYN, loc }, loc };
+    if (mapper) {
+        const error = lowerer.declareHiddenLocal("%fromError", CAUGHT);
+        const close = lowerer.declareHiddenLocal("%fromReturn", DYN);
+        append = { kind: "tryCatch", tryBody: [append], catchLocalId: error.id, finallyBody: null, loc, catchBody: [
+                { kind: "tryCatch", catchLocalId: null, catchBody: [], finallyBody: null, loc, tryBody: [
+                        { kind: "varDecl", localId: close.id, init: get(varRef(iterator.id, DYN, loc), "return"), loc },
+                        { kind: "if", cond: { kind: "dynTest", test: "function", value: varRef(close.id, DYN, loc), type: BOOL, loc }, then: [
+                                { kind: "exprStmt", expr: { kind: "dynCall", callee: varRef(close.id, DYN, loc), receiver: varRef(iterator.id, DYN, loc), calleeName: "iterator.return", args: [], type: DYN, loc }, loc },
+                            ], else_: null, loc },
+                    ] },
+                { kind: "rethrow", localId: error.id, 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 },
+        ...(mapper ? [{ kind: "if", cond: { kind: "dynTest", test: "undefined", value: mapper, type: BOOL, loc }, then: [], else_: [
+                    { kind: "if", cond: { kind: "dynTest", test: "function", value: mapper, type: BOOL, loc }, then: [], else_: [
+                            { kind: "exprStmt", expr: nodeThrowExpr(1, "", "Array.from mapper is not a function", DYN, loc), loc },
+                        ], loc },
+                ], loc }] : []),
+        { kind: "varDecl", localId: iterator.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "libCall", fn: iterable ? "dyn.iterator" : "dyn.arrayFromIterator", args: iterable ? [source, iterable] : [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 },
+        ...(index ? [{ kind: "varDecl", localId: index.id, init: numLit(0, 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 },
+                        append,
+                        ...(index ? [{ kind: "assign", localId: index.id, value: { kind: "bin", op: "+", left: varRef(index.id, F64, loc), right: numLit(1, loc), type: F64, loc }, loc }] : []),
                     ], else_: null, loc },
             ], loc },
     ];
     return { kind: "seqExpr", stmts, result: varRef(out.id, DYN, loc), type: DYN, loc };
 }
+export function lowerArrayFromValue(lowerer, loc) {
+    const name = "%builtin.Array.from";
+    if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+        const context = newFnCtx(false, null, null, DYN);
+        lowerer.fnStack.push(context);
+        try {
+            const params = ["source", "options"].map((name) => {
+                const local = lowerer.declareHiddenLocal(name, DYN);
+                return { localId: local.id, name, type: DYN };
+            });
+            const [source, options] = params.map((p) => varRef(p.localId, DYN, loc));
+            const argument = (index) => ({ kind: "dynKeyGet", value: options, key: strLit(index, loc), type: DYN, loc });
+            const value = lowerCheckedArrayFrom(lowerer, source, loc, argument("0"), argument("1"));
+            const constructorCheck = { kind: "if", cond: { kind: "dynTest", test: "function", value: { kind: "libCall", fn: "dyn.this", args: [], type: DYN, loc }, type: BOOL, loc },
+                then: [{ kind: "runtimeFence", code: "SC2020", message: "Array.from with a custom constructor receiver is not supported", loc }], else_: null, loc };
+            lowerer.liftedFns.push({ name, params, returnType: DYN, locals: context.locals, body: [constructorCheck, ...value.stmts, { kind: "return", value: value.result, loc }], loc });
+        }
+        finally {
+            lowerer.fnStack.pop();
+        }
+    }
+    return { kind: "dynFrom", value: { kind: "closure", fnName: name, captures: [], type: { kind: "func", params: [DYN], ret: DYN, rest: true }, loc }, fnName: "from", 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
@@ -2914,6 +3003,28 @@ export function lowerArrayFromCall(lowerer, call, access) {
         return null;
     const loc = locOf(call);
     const args = call.arguments;
+    if (isJsSourceFile(call.getSourceFile()) && args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement)) {
+        const name = "%builtin.Array.fromDirect";
+        if (!lowerer.liftedFns.some((fn) => fn.name === name)) {
+            const context = newFnCtx(false, null, null, DYN);
+            lowerer.fnStack.push(context);
+            try {
+                const params = ["source", "mapper", "receiver"].map((name) => {
+                    const local = lowerer.declareHiddenLocal(name, DYN);
+                    return { localId: local.id, name, type: DYN };
+                });
+                const refs = params.map((param) => varRef(param.localId, DYN, loc));
+                const value = lowerCheckedArrayFrom(lowerer, refs[0], loc, refs[1], refs[2]);
+                lowerer.liftedFns.push({ name, params, returnType: DYN, locals: context.locals,
+                    body: [...value.stmts, { kind: "return", value: value.result, loc }], loc });
+            }
+            finally {
+                lowerer.fnStack.pop();
+            }
+        }
+        return { kind: "call", callee: name, args: [0, 1, 2].map((i) => args[i]
+                ? lowerer.lowerExprExpecting(args[i], DYN) : dynUndefinedExpr(loc)), type: DYN, loc };
+    }
     // MAPPER-LESS `Array.from({ length: n })` (usually with an explicit
     // type argument — the pMap results-array idiom): a length-n array of
     // ABSENT slots, filled by index before any read. Union elements with
@@ -3211,7 +3322,7 @@ export function lowerMapMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
-    if (!MAP_METHODS.has(name) && !MAP_ITER_METHODS.has(name))
+    if (!MAP_METHODS.has(name))
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     let probedUntyped = false;
@@ -3225,14 +3336,11 @@ export function lowerMapMethodCall(lowerer, call, access) {
     if (receiverIr?.kind !== "map")
         return null;
     // Collection views can refine has() while retaining its native ABI.
-    if (!lowerer.isStdlibMember(access) && name !== "has")
+    if (!probedUntyped && !lowerer.isStdlibMember(access) && name !== "has")
         return null;
     const loc = locOf(call);
     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.
     if (receiver.type.kind !== "map") {
         lowerer.noLowering("chained Map method calls", access.expression, "the lowered set() produces no value — call each set(k, v) as its own statement");
     }
@@ -3256,7 +3364,12 @@ export function lowerMapMethodCall(lowerer, call, access) {
         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 };
+        const slot = lowerer.declareHiddenLocal("%mapSetReceiver", receiver.type);
+        const ref = varRef(slot.id, receiver.type, loc);
+        return { kind: "seqExpr", stmts: [
+                { kind: "varDecl", localId: slot.id, init: receiver, loc },
+                { kind: "exprStmt", expr: { kind: "mapIntrinsic", method: "set", receiver: ref, args: [k, v], type: VOID, loc }, loc },
+            ], result: ref, type: receiver.type, loc };
     }
     if (name === "has" || name === "delete") {
         const k = lowerer.lowerCollectionKey(call.arguments[0], receiverIr.key);
@@ -3265,31 +3378,39 @@ export function lowerMapMethodCall(lowerer, call, access) {
     if (name === "clear") {
         return { kind: "mapIntrinsic", method: "clear", receiver, args: [], type: VOID, loc };
     }
-    if (MAP_ITER_METHODS.has(name)) {
+    if (COLLECTION_ITERATOR_METHODS.has(name)) {
         return lowerMapIterDrainCall(lowerer, call, receiver, receiverIr, name);
     }
     // forEach
     return lowerMapForEachCall(lowerer, call, receiver, receiverIr, probedUntyped);
 }
-/** The iterator methods the lowering DOES cover — in exactly one context. */
-const MAP_ITER_METHODS = new Set(["keys", "values", "entries"]);
+/** Stored collection iterators retain the native collection by reference. The
+ * checked-value runtime supplies the live cursor without embedding an engine. */
+function lowerCollectionIteratorCall(lowerer, call, receiver, method) {
+    const access = call.expression;
+    if (!ts.isPropertyAccessExpression(access))
+        throw new InternalCompilerError("collection iterator requires a member call");
+    const boxed = lowerer.coerceInto(access.expression, receiver, DYN);
+    const result = lowerDynDispatchMethodCall(lowerer, call, access, boxed, false);
+    if (!result)
+        throw new InternalCompilerError(`missing collection iterator dispatch: ${method}`);
+    return result;
+}
 /** `[...m.keys()]` / `[...m.values()]` / `[...m.entries()]` — the iterator
-   * methods, lowered ONLY as the operand of a spread inside an array
+   * methods use an optimized drain as the operand of a spread inside an array
    * literal, where JS drains the iterator on the spot. The call desugars to
    * a direct call of a synthetic drain function whose loop walks the same
    * iteration primitives as the forEach desugar and pushes each live entry
    * into a fresh array — key, value, or `[K, V]` tuple record per method.
    * No user code runs mid-drain (and nothing here mutates the map), so no
    * compaction can shift indices: the enter/exit bracket is unnecessary and
-   * the snapshot IS what JS's immediate drain observes. Every other context
-   * (storing the iterator, .next(), passing it along) would need a real
-   * iterator value — fenced with the spread spelling as the hint. */
+   * the snapshot IS what JS's immediate drain observes. Other contexts keep
+   * a live iterator through the native checked-value runtime. */
 function lowerMapIterDrainCall(lowerer, call, receiver, mapT, method) {
     const loc = locOf(call);
     const inArraySpread = ts.isSpreadElement(call.parent) && ts.isArrayLiteralExpression(call.parent.parent);
-    if (!inArraySpread) {
-        lowerer.noLowering(`.${method}() outside an immediate array spread`, call, `iterator objects have no lowering — drain it into an array where it is made: [...m.${method}()]`);
-    }
+    if (!inArraySpread)
+        return lowerCollectionIteratorCall(lowerer, call, receiver, method);
     // The pushed element type. For entries the checker's own element type —
     // the [K, V] tuple behind MapIterator<[K, V]> — carries the interned
     // tuple shape the surrounding literal will intern too.
@@ -3612,21 +3733,24 @@ export function lowerSetMethodCall(lowerer, call, access) {
     if (!SET_METHODS.has(name) && !SET_COMBINE_METHODS.has(name))
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let probedUntyped = false;
     // The identity-Set idiom (JS): the CHECKER type is an unmappable
     // Set<union-of-signatures>, but the VALUE lowered as a real Set of
     // identity tokens (the new-Set probe) — the lowered receiver's type
     // is the honest dispatch key.
     if (receiverIr?.kind !== "set" && isJsSourceFile(access.getSourceFile())) {
         const probed = tryLowerExpression(lowerer, access.expression);
-        if (probed?.type.kind === "set")
+        if (probed?.type.kind === "set") {
             receiverIr = probed.type;
+            probedUntyped = true;
+        }
     }
     if (receiverIr?.kind !== "set")
         return null;
     // 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")
+    if (!probedUntyped && !lowerer.isStdlibMember(access) && name !== "has")
         return null;
     const loc = locOf(call);
     const value = lowerer.lowerExpr(access.expression);
@@ -3639,6 +3763,9 @@ export function lowerSetMethodCall(lowerer, call, access) {
     if (name === "forEach" && call.arguments.length !== 1) {
         lowerer.noLowering(`.forEach with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
     }
+    if (COLLECTION_ITERATOR_METHODS.has(name)) {
+        return lowerCollectionIteratorCall(lowerer, call, receiver, name);
+    }
     if (SET_COMBINE_METHODS.has(name)) {
         return lowerSetCombineCall(lowerer, call, name, receiver, receiverIr);
     }
@@ -5067,22 +5194,12 @@ function lowerForOfMapOrSet(lowerer, stmt, iterable, contT, proj) {
                 }
             }
             else {
-                // Identifier heads and the remaining patterns bind through the
-                // checker's own element type — the [K, V] tuple for pair yields,
-                // T otherwise — built/read once into a hidden per-iteration
-                // local, the array for-of's exact desugar.
-                const elemT = lowerer.mapTypeOf(lowerer.checker.getTypeAtLocation(decl.name));
-                if (yieldsPair) {
-                    const shape = elemT?.kind === "record" ? lowerer.shapes.get(elemT.shapeId) : null;
-                    if (elemT?.kind !== "record" || !shape?.tuple || shape.fields.length !== 2 ||
-                        !typeEquals(shape.fields.find((f) => f.name === "0").type, keyT) ||
-                        !typeEquals(shape.fields.find((f) => f.name === "1").type, secondT)) {
-                        lowerer.badType(decl.name, lowerer.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares [K, V]
-                    }
-                }
-                else if (!elemT || !typeEquals(elemT, singleT)) {
-                    lowerer.badType(decl.name, lowerer.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares T
-                }
+                // Derive the yielded layout from the represented container. JS
+                // inference can leave the pattern at any even when the Map's
+                // native key/value types are known after specialization.
+                const elemT = yieldsPair
+                    ? { kind: "record", shapeId: lowerer.shapes.intern([{ name: "0", type: keyT }, { name: "1", type: secondT }], true) }
+                    : singleT;
                 const elemInit = yieldsPair
                     ? {
                         kind: "recordLit",
@@ -5253,8 +5370,8 @@ export function lowerSetSeedNew(lowerer, node, setT) {
         (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 (setT.elem.kind === "dyn" && lowerer.dynConvertible(source.type)) {
+        return { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.nativeSetNew", args: [lowerer.coerceInto(node, source, DYN)], type: DYN, loc }, type: setT, loc };
     }
     if (declared?.kind === "array" && typeEquals(declared.elem, setT.elem)) {
         // Preserve the existing checked scalar-iterable bridge. Reference
@@ -5447,7 +5564,8 @@ function mapFromSeedValue(lowerer, seed, mapT) {
         }
         return { kind: "call", callee: name, args: [seed], type: mapT, loc };
     }
-    if (seed.type.kind === "dyn" || seed.type.kind === "array" && seed.type.elem.kind === "dyn") {
+    if (seed.type.kind === "dyn" || seed.type.kind === "array" &&
+        !(seed.type.elem.kind === "record" && lowerer.shapes.get(seed.type.elem.shapeId)?.tuple)) {
         const key = `checked-seed:${typeKey(mapT)}`;
         let name = lowerer.mapHofHelpers.get(key);
         if (!name) {
@@ -5802,6 +5920,9 @@ function lowerTypedObjectFromEntriesCall(lowerer, call, callee) {
     const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
     if (argIr?.kind !== "array")
         return null;
+    const represented = tryLowerExpression(lowerer, argNode);
+    if (represented && !typeEquals(represented.type, argIr))
+        return null;
     // `Object.fromEntries(rows)` over a `string[][]` VALUE — the env-line
     // idiom (`envArray.map((env) => env.split('='))`). The checker has no
     // tuple to type here (string[] misses the lib's [PropertyKey, T]