@scriptc/compiler 0.0.36 → 0.1.2

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

@@ -1,97 +1,46 @@
 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
- * methods with Node-exact forEach desugaring, and the string and regex
- * method surfaces. */
+ * methods with Node-exact forEach desugaring, iterator helpers, and indexed
+ * record operations. */
 import * as ts from "../ts7/adapter.js";
-import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.js";
-import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHODS } from "./surfaces.js";
-import { droppableStatic, isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.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 { dynUndefinedExpr, own } from "./lowerer.js";
 import { boolLit, countedFor, numLit, varRef } from "../../ir/build.js";
-/** Lower an expression whose checker type is statically `undefined`/`void`.
- * Optional builtin arguments use this before their ordinary expected-type
- * coercion so every equivalent spelling (`undefined`, `void 0`, a typed
- * binding, or an effectful call returning undefined) selects the default.
- * An effectful `void e` is exact in this context: evaluate e, then produce
- * undefined, instead of hitting value-position void's general fence. */
-function lowerStaticallyUndefinedArg(lowerer, node) {
-    const peelErasableWrappers = (value) => {
-        let expr = value;
-        while (ts.isParenthesizedExpression(expr) ||
-            ts.isAsExpression(expr) ||
-            ts.isTypeAssertion(expr) ||
-            ts.isSatisfiesExpression(expr)) {
-            expr = expr.expression;
-        }
-        return expr;
-    };
-    let expr = node;
-    while (ts.isParenthesizedExpression(expr))
-        expr = expr.expression;
-    if ((lowerer.typeOf(expr).flags &
-        (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) ===
-        0) {
-        return null;
-    }
-    // TypeScript erases `as`, angle-bracket assertions, and `satisfies`.
-    // Peel them only for the void recognition: a non-void assertion still
-    // lowers through the ordinary path below, preserving the checked-dynamic
-    // cast discipline. Nested voids add no effects of their own, so the one
-    // innermost operand carries the complete runtime evaluation.
-    expr = peelErasableWrappers(expr);
-    let sawVoid = false;
-    while (ts.isVoidExpression(expr)) {
-        sawVoid = true;
-        expr = peelErasableWrappers(expr.expression);
-    }
-    if (sawVoid) {
-        // The caller discards this token before producing the parameter
-        // default, so the operand itself carries exactly the required effects;
-        // no bare undefined value needs to enter the IR.
-        return lowerer.lowerExpr(expr);
-    }
-    return lowerer.lowerExpr(node);
-}
-/** Preserve a statically-undefined argument's effects, then answer the
- * optional parameter's already-lowered default value. */
-function defaultAfterUndefined(value, defaultValue) {
-    if (droppableStatic(value))
-        return defaultValue;
-    return {
-        kind: "seqExpr",
-        stmts: [{ kind: "exprStmt", expr: value, loc: value.loc }],
-        result: defaultValue,
-        type: defaultValue.type,
-        loc: value.loc,
-    };
-}
-function lowerOptionalDefaultArg(lowerer, node, expected, defaultValue) {
-    const undefinedArg = lowerStaticallyUndefinedArg(lowerer, node);
-    if (undefinedArg)
-        return defaultAfterUndefined(undefinedArg, defaultValue);
-    const value = lowerer.lowerExpr(node);
-    if (value.type.kind === "union") {
-        const def = lowerer.unions.get(value.type.unionId);
-        if (def?.arms.length === 2 &&
-            def.arms.some((arm) => arm.kind === "undefinedT") &&
-            def.arms.some((arm) => typeEquals(arm, expected))) {
-            // A runtime optional argument uses its API default only on the
-            // undefined arm. The exact two-arm gate deliberately excludes null:
-            // optional parameters do not admit it, and an asserted null must keep
-            // the ordinary checked-narrow failure instead of defaulting.
-            return { kind: "nullish", left: value, right: defaultValue, type: expected, loc: value.loc };
-        }
+import { lowerOptionalArgument } from "./optional-arguments.js";
+/** Build the argument array for a mutating/copying operation while keeping
+ * the receiver's scalar payload ABI. A missing read is represented as the
+ * present UNDEFINED state in this temporary, so push/unshift and toSpliced
+ * materialize it through their ordinary indexed/iterator copies. */
+function lowerArrayValueItems(lowerer, values, elem, arrType, loc) {
+    const out = lowerer.declareHiddenLocal("%arrayItems", arrType);
+    const outRef = varRef(out.id, arrType, loc);
+    const length = () => ({
+        kind: "arrIntrinsic",
+        method: "length",
+        receiver: outRef,
+        args: [],
+        type: F64,
+        loc,
+    });
+    const body = [
+        { kind: "varDecl", localId: out.id, init: { kind: "arrayLit", elems: [], type: arrType, loc }, loc },
+    ];
+    for (const value of values) {
+        const stored = lowerer.runtimeOptionalWidening(value.type, elem) !== null
+            ? value
+            : lowerer.coerceToExpected(value, elem);
+        body.push(arrayValueStore(lowerer, outRef, length(), stored, elem, loc));
     }
-    return lowerer.coerceInto(node, value, expected);
-}
-function lowerSplitLimitArg(lowerer, node, loc) {
-    const defaultValue = { kind: "numLit", value: 4294967295, type: F64, loc };
-    return node ? lowerOptionalDefaultArg(lowerer, node, F64, defaultValue) : defaultValue;
+    return { kind: "seqExpr", stmts: body, result: outRef, type: arrType, loc };
 }
 /** Callback-driven array producers bypass mapType's ordinary T[] mapping:
  * the callback is lowered first, then the helper's result array is built
@@ -119,6 +68,9 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     if (!ARRAY_METHODS.has(name) && name !== "sort" && name !== "shift" && name !== "splice")
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    const checkerReceiver = lowerer.checker.getTypeAtLocation(access.expression);
+    const implicitArrayReceiver = receiverIr?.kind === "array" &&
+        (checkerReceiver.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || lowerer.checkerAnyArrayType(checkerReceiver));
     // A checker-`any[]` receiver (the readonly-array Array.isArray quirk)
     // whose VALUE lowers to a real static array (maybeNarrow's isArray
     // bridge): ride the ordinary tables on the lowered element type — the
@@ -127,7 +79,10 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // the isStdlibMember gate is skipped for probed receivers (nothing
     // user-declared can shadow a method on a value the checker calls any).
     let probedUntyped = false;
-    if (!receiverIr &&
+    if (implicitArrayReceiver)
+        probedUntyped = true;
+    if ((receiverIr === null || receiverIr.kind === "dyn" ||
+        (receiverIr.kind === "array" && receiverIr.elem.kind === "dyn")) &&
         (lowerer.checkerAnyArray(access.expression) ||
             // A checker-`any` CHAIN whose value lowers to a real static array
             // (`context.stack.split('\n').slice(2)` — the dyn-receiver string
@@ -227,12 +182,62 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         }
         const receiver = lowerer.lowerExpr(access.expression);
         const index = lowerer.lowerExprExpecting(call.arguments[0], F64);
-        const value = lowerer.coerceInto(call.arguments[1], lowerer.lowerExpr(call.arguments[1]), elem);
+        const value = lowerer.lowerExpr(call.arguments[1]);
+        if (value.type.kind === "union" && lowerer.runtimeOptionalWidening(value.type, elem) !== null) {
+            // `.with()` validates its index and returns a fresh copy. Stabilize
+            // all three operands, then select the scalar replacement or the
+            // present-undefined copy without evaluating a read twice.
+            const receiverLocal = lowerer.declareHiddenLocal("%withRecv", receiverIr);
+            const indexLocal = lowerer.declareHiddenLocal("%withIndex", F64);
+            const valueLocal = lowerer.declareHiddenLocal("%withValue", value.type);
+            const unionId = value.type.unionId;
+            const receiverRef = varRef(receiverLocal.id, receiverIr, loc);
+            const indexRef = varRef(indexLocal.id, F64, loc);
+            const valueRef = varRef(valueLocal.id, value.type, loc);
+            const undefTag = lowerer.armTag(unionId, UNDEFINED_T);
+            const condition = {
+                kind: "unionIsTag",
+                unionId,
+                tag: undefTag,
+                negated: false,
+                value: valueRef,
+                type: BOOL,
+                loc,
+            };
+            const missing = {
+                kind: "arrIntrinsic",
+                method: "withUndefined",
+                receiver: receiverRef,
+                args: [indexRef],
+                type: receiverIr,
+                loc,
+            };
+            const present = {
+                kind: "arrIntrinsic",
+                method: "with",
+                receiver: receiverRef,
+                args: [indexRef, lowerer.coerceToExpected(valueRef, elem)],
+                type: receiverIr,
+                loc,
+            };
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: receiverLocal.id, init: receiver, loc },
+                    { kind: "varDecl", localId: indexLocal.id, init: index, loc },
+                    { kind: "varDecl", localId: valueLocal.id, init: value, loc },
+                ],
+                result: { kind: "ternary", cond: condition, then: missing, else_: present, type: receiverIr, loc },
+                type: receiverIr,
+                loc,
+            };
+        }
+        const coercedValue = lowerer.coerceInto(call.arguments[1], value, elem);
         return {
             kind: "arrIntrinsic",
             method: "with",
             receiver,
-            args: [index, value],
+            args: [index, coercedValue],
             type: receiverIr,
             loc,
         };
@@ -254,14 +259,19 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         const deleteCount = call.arguments.length === 0
             ? { kind: "numLit", value: 0, type: F64, loc }
             : call.arguments[1]
-                ? lowerOptionalDefaultArg(lowerer, call.arguments[1], F64, deleteCountDefault)
+                ? lowerOptionalArgument(lowerer, call.arguments[1], F64, deleteCountDefault)
                 : { kind: "numLit", value: Infinity, type: F64, loc };
-        const items = {
-            kind: "arrayLit",
-            elems: call.arguments.slice(2).map((arg) => lowerer.coerceInto(arg, lowerer.lowerExpr(arg), elem)),
-            type: receiverIr,
-            loc,
-        };
+        const itemNodes = call.arguments.slice(2);
+        const itemProbes = itemNodes.map((arg) => tryLowerExpression(lowerer, arg));
+        const statefulItems = itemProbes.some((probe) => probe !== null && lowerer.runtimeOptionalWidening(probe.type, elem) !== null);
+        const items = statefulItems
+            ? lowerArrayValueItems(lowerer, itemNodes.map((arg) => lowerer.lowerExpr(arg)), elem, receiverIr, loc)
+            : {
+                kind: "arrayLit",
+                elems: itemNodes.map((arg) => lowerer.coerceInto(arg, lowerer.lowerExpr(arg), elem)),
+                type: receiverIr,
+                loc,
+            };
         return {
             kind: "arrIntrinsic",
             method: "toSpliced",
@@ -299,8 +309,17 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                         : undefined;
         lowerer.noLowering(`.${name} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"}`, call, hint);
     }
-    if (name === "push" || name === "unshift" || name === "pop") {
-        const receiver = lowerer.lowerExpr(access.expression);
+    if (name === "push" || name === "unshift") {
+        let receiver = lowerer.lowerExpr(access.expression);
+        if (receiver.type.kind === "union" && lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0) {
+            const present = lowerer.stripUndefinedArm(receiver.type);
+            const helper = present.kind === "array"
+                ? lowerer.narrowedArmHelper(receiver.type.unionId, present, loc)
+                : null;
+            receiver = helper
+                ? { kind: "call", callee: helper, args: [receiver], type: present, loc }
+                : lowerer.maybeNarrow(receiver, access.expression);
+        }
         // `a.push(...src)` / `a.unshift(...src)`: copy src's elements in
         // order (count snapshotted first, so the self-spread forms duplicate
         // like JS) and return the new length.
@@ -326,6 +345,18 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 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);
+            return {
+                kind: "arrIntrinsic",
+                method: name === "push" ? "pushSpread" : "unshiftSpread",
+                receiver,
+                args: [items],
+                type: F64,
+                loc,
+            };
+        }
         // Inserted values flow into the element slot like an assignment would:
         // union-element arrays wrap plain arm values (coerceInto is inert
         // when the types already agree).
@@ -335,39 +366,31 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             method: name,
             receiver,
             args,
-            type: name === "push" || name === "unshift" ? F64 : elem,
+            type: F64,
             loc,
         };
     }
-    if (name === "indexOf" || name === "includes") {
-        // Union elements are fenced: the runtime compares ref elements by
-        // POINTER identity (JS-exact for records/objects/arrays), but a
-        // union BOX is a compiler artifact — two boxes of the same arm value
-        // are distinct pointers where JS would say ===. Honest answer: none.
-        if (elem.kind === "union") {
-            lowerer.unsupported("SC1090", call, `'.${name}()' on union-element arrays (union values have no stable identity — ` +
-                "loop and compare the narrowed values instead)");
+    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.
+        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)");
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        let needle = lowerer.lowerExpr(call.arguments[0]);
-        // A derived CLASS VALUE against a base-classval element widens (the
-        // same pointer — identity search is exact); the coercion path owns
-        // the ABI gate and its pointed fences.
-        if (needle.type.kind === "classval" && elem.kind === "classval" && !typeEquals(needle.type, elem)) {
-            needle = lowerer.coerceInto(call.arguments[0], needle, elem);
-        }
-        if (!typeEquals(needle.type, elem)) {
-            lowerer.badType(call.arguments[0], lowerer.typeOf(call.arguments[0]));
-        }
         return {
             kind: "arrIntrinsic",
-            method: name,
+            method: "pop",
             receiver,
-            args: [needle],
-            type: name === "indexOf" ? F64 : BOOL,
+            args: [],
+            type: arrayValueType(lowerer, elem),
             loc,
         };
     }
+    if (name === "indexOf" || name === "includes") {
+        return lowerArraySearchCall(lowerer, call, access, name, elem);
+    }
     if (name === "concat") {
         // `a.concat(x, ys, ...)` — a fresh array of a's elements followed by
         // each argument in order: JS spreads array arguments one level
@@ -385,8 +408,12 @@ export function lowerArrayMethodCall(lowerer, call, access) {
                 lowerer.unsupported("SC1090", argNode, "spread arguments to concat (pass the array itself — concat already spreads array arguments)");
             }
             const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-            if (argIr !== null && argIr.kind === "array" && typeEquals(argIr.elem, elem)) {
-                if (elem.kind === "array" && typeEquals(argIr, elem)) {
+            const probedArg = probedUntyped ? tryLowerExpression(lowerer, argNode) : null;
+            const argArrayType = probedArg?.type.kind === "array"
+                ? probedArg.type
+                : argIr?.kind === "array" ? argIr : null;
+            if (argArrayType !== null && typeEquals(argArrayType.elem, elem)) {
+                if (elem.kind === "array" && typeEquals(argArrayType, elem)) {
                     // number[][].concat(inner: number[]) — TS says element, JS's
                     // 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]))");
@@ -455,11 +482,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         // 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).
-        if (elem.kind === "union") {
-            lowerer.unsupported("SC1090", call, "'.shift()' on union-element arrays (read [0] and splice(0, 1) with the narrowed value instead)");
+        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)");
         }
         const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "arrIntrinsic", method: "shift", receiver, args: [], type: lowerer.withUndefinedArm(elem), loc };
+        return { kind: "arrIntrinsic", method: "shift", receiver, args: [], type: arrayValueType(lowerer, elem), loc };
     }
     if (name === "join") {
         // The ambient declares join on every Array<T> (a per-element-type
@@ -487,7 +514,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     }
     if (name === "find" || name === "findIndex" || name === "findLast" ||
         name === "findLastIndex" || name === "some" || name === "every") {
-        return lowerArrayFindLikeCall(lowerer, call, access, name, elem);
+        return lowerArrayFindLikeCall(lowerer, call, access, name, elem, probedUntyped);
     }
     if (name === "at")
         return lowerArrayAtCall(lowerer, call, access, elem);
@@ -496,6 +523,217 @@ export function lowerArrayMethodCall(lowerer, call, access) {
     // reduce / reduceRight
     return lowerArrayReduceCall(lowerer, call, access, name, elem);
 }
+/** `indexOf` and `includes` normally use the runtime's typed search helpers,
+ * but an indexed array read is a `T | undefined` value. Keep that union
+ * through a small lowered loop so the needle's missing state is observable:
+ * indexOf skips holes, while includes treats holes as undefined. The same
+ * loop also gives union-element arrays their value equality rather than
+ * comparing the compiler's union boxes by pointer. */
+function lowerArraySearchCall(lowerer, call, access, method, elem) {
+    const loc = locOf(call);
+    const receiver = lowerer.lowerExpr(access.expression);
+    const argNode = call.arguments[0];
+    let needle = lowerer.lowerExpr(argNode);
+    // 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)) {
+        needle = lowerer.coerceInto(argNode, needle, elem);
+    }
+    // Preserve the existing fast path for an ordinary, non-union needle. Its
+    // runtime implementation already has exact primitive/reference equality.
+    if (elem.kind !== "union" && typeEquals(needle.type, elem)) {
+        return {
+            kind: "arrIntrinsic",
+            method,
+            receiver,
+            args: [needle],
+            type: method === "indexOf" ? F64 : BOOL,
+            loc,
+        };
+    }
+    const valueT = arrayValueType(lowerer, elem);
+    // jsval/dyn arrays have a single engine value representation rather than a
+    // static undefined arm. Keep their existing runtime path and its explicit
+    // type fence; typed static arrays take the state-aware helper below.
+    if (valueT.kind !== "union") {
+        if (!typeEquals(needle.type, elem))
+            lowerer.badType(argNode, lowerer.typeOf(argNode));
+        return {
+            kind: "arrIntrinsic",
+            method,
+            receiver,
+            args: [needle],
+            type: method === "indexOf" ? F64 : BOOL,
+            loc,
+        };
+    }
+    const searchNeedle = lowerer.coerceInto(argNode, needle, valueT);
+    if (!typeEquals(searchNeedle.type, valueT))
+        lowerer.badType(argNode, lowerer.typeOf(argNode));
+    const helper = arraySearchHelper(lowerer, method, elem, valueT, loc);
+    return { kind: "call", callee: helper, args: [receiver, searchNeedle], type: method === "indexOf" ? F64 : BOOL, loc };
+}
+/** SameValueZero over a static value union. `unionEq` supplies strict
+ * equality for every arm; the extra f64-arm test is the only difference for
+ * 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) {
+        return { kind: "bin", op: "===", left, right, type: BOOL, loc };
+    }
+    const unionId = left.type.unionId;
+    const strict = { kind: "unionEq", unionId, negated: false, sameValue: false, left, right, type: BOOL, loc };
+    if (!sameValueZero)
+        return strict;
+    const numberTag = lowerer.unions.get(unionId)?.arms.findIndex((arm) => arm.kind === "f64") ?? -1;
+    if (numberTag < 0)
+        return strict;
+    const leftIsNumber = { kind: "unionIsTag", unionId, tag: numberTag, negated: false, value: left, type: BOOL, loc };
+    const rightIsNumber = { kind: "unionIsTag", unionId, tag: numberTag, negated: false, value: right, type: BOOL, loc };
+    const leftNumber = { kind: "unionNarrow", unionId, tag: numberTag, value: left, type: F64, loc };
+    const rightNumber = { kind: "unionNarrow", unionId, tag: numberTag, value: right, type: F64, loc };
+    const bothNaN = {
+        kind: "logical",
+        op: "&&",
+        left: {
+            kind: "logical",
+            op: "&&",
+            left: leftIsNumber,
+            right: rightIsNumber,
+            type: BOOL,
+            loc,
+        },
+        right: {
+            kind: "logical",
+            op: "&&",
+            left: { kind: "libCall", fn: "num.isNaN", args: [leftNumber], type: BOOL, loc },
+            right: { kind: "libCall", fn: "num.isNaN", args: [rightNumber], type: BOOL, loc },
+            type: BOOL,
+            loc,
+        },
+        type: BOOL,
+        loc,
+    };
+    return { kind: "logical", op: "||", left: strict, right: bothNaN, type: BOOL, loc };
+}
+function arraySearchHelper(lowerer, method, elem, valueT, loc) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(valueT)}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, name);
+    const arrT = arrayOf(elem);
+    const resultT = method === "indexOf" ? F64 : BOOL;
+    const arrRef = varRef("a.0", arrT, loc);
+    const indexRef = varRef("i.0", F64, loc);
+    const needleRef = varRef("needle.0", valueT, loc);
+    const stateRef = varRef("state.0", F64, loc);
+    const nextRef = varRef("next.0", F64, loc);
+    const rawRead = { kind: "arrayGet", arr: arrRef, index: indexRef, type: elem, loc };
+    const missing = lowerer.wrappedUndefined(valueT, loc);
+    if (!missing)
+        throw new InternalCompilerError("array search helper needs an undefined arm");
+    const value = {
+        kind: "ternary",
+        cond: { kind: "bin", op: "===", left: stateRef, right: numLit(1, loc), type: BOOL, loc },
+        then: typeEquals(elem, valueT) ? rawRead : lowerer.coerceToExpected(rawRead, valueT),
+        else_: missing,
+        type: valueT,
+        loc,
+    };
+    const equal = arraySearchEquality(lowerer, varRef("value.0", valueT, loc), needleRef, method === "includes", loc);
+    const match = method === "indexOf"
+        ? {
+            kind: "logical",
+            op: "&&",
+            left: { kind: "bin", op: "!==", left: stateRef, right: numLit(0, loc), type: BOOL, loc },
+            right: equal,
+            type: BOOL,
+            loc,
+        }
+        : equal;
+    const undefinedTag = lowerer.armTag(valueT.unionId, UNDEFINED_T);
+    if (undefinedTag < 0)
+        throw new InternalCompilerError("array search helper needs an undefined tag");
+    const needleIsUndefined = {
+        kind: "unionIsTag",
+        unionId: valueT.unionId,
+        tag: undefinedTag,
+        negated: false,
+        value: needleRef,
+        type: BOOL,
+        loc,
+    };
+    const advance = {
+        kind: "assign",
+        localId: "i.0",
+        value: { kind: "bin", op: "+", left: indexRef, right: numLit(1, loc), type: F64, loc },
+        loc,
+    };
+    const visitPresent = [
+        { kind: "varDecl", localId: "value.0", init: value, loc },
+        {
+            kind: "if",
+            cond: match,
+            then: [{ kind: "return", value: method === "indexOf" ? indexRef : boolLit(true, loc), loc }],
+            else_: null,
+            loc,
+        },
+        advance,
+    ];
+    const skipHole = [
+        {
+            kind: "varDecl",
+            localId: "next.0",
+            init: { kind: "arrIntrinsic", method: "nextPresent", receiver: arrRef, args: [indexRef], type: F64, loc },
+            loc,
+        },
+        ...(method === "includes"
+            ? [{ kind: "if", cond: needleIsUndefined, then: [{ kind: "return", value: boolLit(true, loc), loc }], else_: null, loc }]
+            : []),
+        { kind: "assign", localId: "i.0", value: nextRef, loc },
+    ];
+    const loopBody = [
+        { kind: "varDecl", localId: "state.0", init: { kind: "arrayState", arr: arrRef, index: indexRef, type: F64, loc }, loc },
+        {
+            kind: "if",
+            cond: { kind: "bin", op: "===", left: stateRef, right: numLit(0, loc), type: BOOL, loc },
+            then: skipHole,
+            else_: visitPresent,
+            loc,
+        },
+    ];
+    lowerer.liftedFns.push({
+        name,
+        params: [
+            { localId: "a.0", name: "a", type: arrT },
+            { localId: "needle.0", name: "needle", type: valueT },
+        ],
+        returnType: resultT,
+        locals: [
+            { id: "a.0", name: "a", type: arrT, mutable: true },
+            { id: "needle.0", name: "needle", type: valueT, mutable: true },
+            { id: "n.0", name: "n", type: F64, mutable: false },
+            { id: "i.0", name: "i", type: F64, mutable: true },
+            { id: "state.0", name: "state", type: F64, mutable: false },
+            { id: "next.0", name: "next", type: F64, mutable: false },
+            { id: "value.0", name: "value", type: valueT, mutable: false },
+        ],
+        body: [
+            readLenStmt(arrT, loc),
+            { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
+            {
+                kind: "while",
+                cond: { kind: "bin", op: "<", left: indexRef, right: varRef("n.0", F64, loc), type: BOOL, loc },
+                body: loopBody,
+                loc,
+            },
+            { kind: "return", value: method === "indexOf" ? numLit(-1, loc) : boolLit(false, loc), loc },
+        ],
+        loc,
+    });
+    return name;
+}
 /** Lowers and validates a HOF callback argument. The lib declares optional
    * trailing (index, array) parameters after `lead` (the element for the
    * map family, accumulator + element for reduce); a callback may declare
@@ -503,7 +741,8 @@ export function lowerArrayMethodCall(lowerer, call, access) {
    * 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) {
+function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
+    const full = [...lead, F64, arrT];
     // A DYN-receiver HOF's callback (`parsed.flatMap((value) => ...)`):
     // the contextual signature types the unannotated param `any` (the
     // receiver is checker-`any[]`), while the VALUE each call receives is
@@ -537,6 +776,43 @@ function hofCallbackArg(lowerer, argNode, lead, arrT) {
             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.
+    const contextual = [];
+    const previousImplicit = lowerer.implicitParamTypes;
+    let contextualTs = null;
+    if (bindUntyped && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+        argNode.parameters.forEach((param, i) => {
+            const expected = full[i];
+            if (expected === undefined || expected.kind === "dyn" || expected.kind === "jsval" ||
+                !ts.isIdentifier(param.name) || param.type || param.initializer || param.dotDotDotToken) {
+                return;
+            }
+            const checkerType = lowerer.checker.getTypeAtLocation(param.name);
+            if ((checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0)
+                return;
+            const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+            if (!symbol)
+                return;
+            contextual.push({ symbol, previous: lowerer.runtimeOptionalBindingTypes.get(symbol) });
+            lowerer.runtimeOptionalBindingTypes.set(symbol, expected);
+            const bodyExpected = expected.kind === "union" && lowerer.armTag(expected.unionId, UNDEFINED_T) >= 0
+                ? lowerer.stripUndefinedArm(expected)
+                : expected;
+            const expectedTs = bodyExpected.kind === "string" ? lowerer.checker.getStringType() :
+                bodyExpected.kind === "f64" ? lowerer.checker.getNumberType() :
+                    bodyExpected.kind === "bool" ? lowerer.checker.getBooleanType() : null;
+            if (expectedTs !== null) {
+                contextualTs ??= new Map(previousImplicit ?? []);
+                contextualTs.set(symbol, expectedTs);
+            }
+        });
+    }
+    if (contextualTs !== null)
+        lowerer.implicitParamTypes = contextualTs;
     let fnArg;
     try {
         fnArg = lowerer.lowerExpr(argNode);
@@ -544,8 +820,14 @@ function hofCallbackArg(lowerer, argNode, lead, arrT) {
     finally {
         for (const n of overridden)
             lowerer.chainNarrowedType.delete(n);
+        for (const { symbol, previous } of contextual) {
+            if (previous === undefined)
+                lowerer.runtimeOptionalBindingTypes.delete(symbol);
+            else
+                lowerer.runtimeOptionalBindingTypes.set(symbol, previous);
+        }
+        lowerer.implicitParamTypes = previousImplicit;
     }
-    const full = [...lead, F64, arrT];
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > full.length ||
         !fnArg.type.params.every((p, i) => typeEquals(p, full[i]))) {
@@ -572,7 +854,22 @@ function lowerArrayHofCall(lowerer, call, access, method, elem) {
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [elem], arrayOf(elem));
+    const booleanFilter = method === "filter" &&
+        ts.isIdentifier(argNode) &&
+        argNode.text === "Boolean" &&
+        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined);
+    const valueT = arrayValueType(lowerer, elem);
+    if (booleanFilter) {
+        if (valueT.kind === "union")
+            lowerer.requireTruthyUnion(valueT.unionId, argNode);
+        if (valueT.kind === "dyn" || valueT.kind === "jsval" || valueT.kind === "void" || isUnitType(valueT)) {
+            lowerer.badType(argNode, lowerer.typeOf(argNode));
+        }
+    }
+    const callback = booleanFilter
+        ? { fnArg: truthyFilterCallback(lowerer, valueT, loc), arity: 1 }
+        : hofCallbackArg(lowerer, argNode, [valueT], arrayOf(elem));
+    const { fnArg, arity } = callback;
     const fnRet = fnArg.type.ret;
     if (method === "map" && (fnRet.kind === "void" || fnRet.kind === "func")) {
         // The result array U[] is unrepresentable here (no void elements;
@@ -595,10 +892,98 @@ function lowerArrayHofCall(lowerer, call, access, method, elem) {
         }
         lowerer.badType(argNode, lowerer.typeOf(argNode));
     }
-    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc);
-    const resultType = method === "map" ? arrayOf(fnRet) : method === "filter" ? arrayOf(elem) : VOID;
+    const outElem = method === "filter"
+        ? filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter)
+        : callbackArrayElem(lowerer, call, fnRet);
+    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem);
+    const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultType, loc };
 }
+/** Preserve the checker-selected payload ABI when a callback's runtime
+ * return gained only undefined. The array state byte carries that value. */
+function callbackArrayElem(lowerer, call, fnRet) {
+    const result = lowerer.mapTypeOf(lowerer.typeOf(call));
+    return result?.kind === "array" && lowerer.runtimeOptionalWidening(fnRet, result.elem)
+        ? result.elem : fnRet;
+}
+/** The checker-selected element of a filter result, with the same trust
+ * boundary as the historical narrowing filter: an inferred inline type
+ * predicate may prove one source arm; a written predicate annotation may
+ * not. Boolean is safe when every discarded arm is a nullish unit. */
+function filterResultElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
+    const callT = lowerer.typeOf(call);
+    const result = lowerer.mapTypeOf(callT);
+    let outElem = result?.kind === "array" ? result.elem : elem;
+    const access = ts.isPropertyAccessExpression(call.expression) ? call.expression : null;
+    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" &&
+        typeEquals(result.elem, checkerReceiver.elem)) {
+        return elem;
+    }
+    if (!typeEquals(outElem, elem)) {
+        const contextual = lowerer.mapTypeOf(lowerer.checker.getContextualType(call) ?? callT);
+        if (contextual?.kind === "array" && typeEquals(contextual.elem, elem))
+            outElem = elem;
+    }
+    if (typeEquals(outElem, elem))
+        return elem;
+    const annotateEscape = "keep the receiver's element type instead — annotate the callback's return ': boolean' " +
+        "(the checker then skips the predicate) or annotate the result with the receiver's own " +
+        "element type — and narrow the elements after";
+    if (!booleanFilter) {
+        if (!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) {
+            lowerer.unsupported("SC1090", argNode, `narrowing '.filter' through a callback VALUE (only an inline callback whose predicate ` +
+                `the checker inferred can re-tag — ${annotateEscape})`);
+        }
+        if (argNode.type) {
+            lowerer.unsupported("SC1090", argNode, `narrowing '.filter' with a hand-written type predicate (a written 'x is T' is an ` +
+                `unchecked assertion nothing validates at runtime — ${annotateEscape})`);
+        }
+    }
+    if (valueT.kind !== "union" || lowerer.armTag(valueT.unionId, outElem) < 0) {
+        const multiArm = outElem.kind === "union";
+        lowerer.unsupported("SC1090", call, `'.filter' narrowing '${lowerer.fmt(elem)}' elements to ` +
+            `${multiArm ? `the multi-arm '${lowerer.fmt(outElem)}'` : `'${lowerer.fmt(outElem)}'`} ` +
+            `(${multiArm ? "only a SINGLE arm re-tags" : "only a single runtime arm re-tags"} — ${annotateEscape})`);
+    }
+    if (booleanFilter) {
+        const arms = lowerer.unions.get(valueT.unionId)?.arms ?? [];
+        if (arms.some((arm) => !typeEquals(arm, outElem) && !isUnitType(arm))) {
+            lowerer.unsupported("SC1090", call, `'.filter(Boolean)' narrowing '${lowerer.fmt(elem)}' to '${lowerer.fmt(outElem)}' ` +
+                "when another truthy arm could survive");
+        }
+    }
+    return outElem;
+}
+/** A native closure for the ambient Boolean callback. Reifying the
+ * JavaScript constructor itself is unnecessary; Array#filter only observes
+ * its one-argument ToBoolean result. */
+function truthyFilterCallback(lowerer, valueT, loc) {
+    const fnT = { kind: "func", params: [valueT], ret: BOOL };
+    const key = `filterBoolean:${typeKey(valueT)}`;
+    let name = lowerer.arrHofHelpers.get(key);
+    if (!name) {
+        name = `%arr.filterBoolean.${lowerer.arrHofHelpers.size}`;
+        lowerer.arrHofHelpers.set(key, name);
+        const value = varRef("v.0", valueT, loc);
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "v.0", name: "v", type: valueT }],
+            returnType: BOOL,
+            locals: [{ id: "v.0", name: "v", type: valueT, mutable: false }],
+            body: [{ kind: "return", value: { kind: "toBool", operand: value, type: BOOL, loc }, loc }],
+            loc,
+        });
+    }
+    return { kind: "closure", fnName: name, captures: [], type: fnT, loc };
+}
 /** The predicate result kinds `.filter()` accepts. JS applies ToBoolean to
  * whatever the callback answers, so a bool is not required: the scalars and
  * the reference kinds have constant or by-value answers, and a union is fine
@@ -644,14 +1029,14 @@ function filterCond(call, fnRet, loc) {
    * combo. Named `%arr.<method>.<n>` ('%' keeps it out of the user
    * namespace); rides `liftedFns` into the module like a lifted lambda (it
    * is a plain function — no captures). */
-function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}`;
+function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
-    lowerer.liftedFns.push(buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc));
+    lowerer.liftedFns.push(buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem));
     return name;
 }
 /** READ-ONLY array methods on TUPLE receivers — `t.slice(...)` and
@@ -690,7 +1075,7 @@ export function lowerTupleReadMethodCall(lowerer, call, access) {
     receiver ??= lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "record")
         return null;
-    if (!pureReemittable(receiver)) {
+    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 loc = locOf(call);
@@ -743,13 +1128,14 @@ export function lowerTupleReadMethodCall(lowerer, call, access) {
         lowerer.noLowering(`.map 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, [snapshotElem], arrayOf(snapshotElem));
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, snapshotElem)], arrayOf(snapshotElem));
     const fnRet = fnArg.type.ret;
     if (fnRet.kind === "void" || fnRet.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
     fenceProducedArrayElem(lowerer, call, "'.map()'", fnRet);
-    const helper = arrayHofHelper(lowerer, "map", snapshotElem, fnRet, arity, loc);
-    return { kind: "call", callee: helper, args: [snapshot, fnArg], type: arrayOf(fnRet), loc };
+    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 };
 }
 /** An OOB-SAFE indexed read: `xs[i]`
    * answers the interned `elem | undefined` union — the element when `i`
@@ -764,54 +1150,13 @@ export function lowerSafeIndexRead(lowerer, arr, index, loc) {
     const elem = arr.type.elem;
     if (elem.kind === "void" || elem.kind === "dyn")
         return null;
-    const resultT = elem.kind === "union" ? lowerer.withUndefinedArmOf(elem) : lowerer.withUndefinedArm(elem);
-    if (!resultT || resultT.kind !== "union")
-        return null;
-    const undefTag = lowerer.armTag(resultT.unionId, UNDEFINED_T);
-    const foundTag = elem.kind === "union" ? -1 : lowerer.armTag(resultT.unionId, elem);
-    if (undefTag < 0 || (elem.kind !== "union" && foundTag < 0))
-        return null;
-    const arrT = arr.type;
+    const resultT = arrayValueType(lowerer, elem);
     const key = `idxOr:${typeKey(elem)}`;
     let name = lowerer.arrHofHelpers.get(key);
     if (!name) {
         name = `%arr.idxOr.${lowerer.arrHofHelpers.size}`;
         lowerer.arrHofHelpers.set(key, name);
-        const i = varRef("i.0", F64, loc);
-        const n = varRef("n.0", F64, loc);
-        const v = varRef("v.0", elem, loc);
-        const lt = (l, r) => ({ kind: "bin", op: "<", left: l, right: r, type: BOOL, loc });
-        const miss = {
-            kind: "unionWrap",
-            unionId: resultT.unionId,
-            tag: undefTag,
-            value: { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc },
-            type: resultT,
-            loc,
-        };
-        const body = [
-            readLenStmt(arrT, loc),
-            { kind: "if", cond: { kind: "bin", op: "!==", left: i, right: i, type: BOOL, loc }, then: [{ kind: "return", value: miss, loc }], else_: null, loc },
-            { kind: "if", cond: lt(i, numLit(0, loc)), then: [{ kind: "return", value: miss, loc }], else_: null, loc },
-            { kind: "if", cond: { kind: "bin", op: ">=", left: i, right: n, type: BOOL, loc }, then: [{ kind: "return", value: miss, loc }], else_: null, loc },
-            // A fractional index is a property miss too (floor(i) < i exactly
-            // when i has a fraction; negatives already returned above).
-            {
-                kind: "if",
-                cond: lt({ kind: "libCall", fn: "math.floor", args: [i], type: F64, loc }, i),
-                then: [{ kind: "return", value: miss, loc }],
-                else_: null,
-                loc,
-            },
-            { kind: "varDecl", localId: "v.0", init: { kind: "arrayGet", arr: varRef("a.0", arrT, loc), index: i, type: elem, loc }, loc },
-            {
-                kind: "return",
-                value: elem.kind === "union"
-                    ? lowerer.coerceToExpected(v, resultT)
-                    : { kind: "unionWrap", unionId: resultT.unionId, tag: foundTag, value: v, type: resultT, loc },
-                loc,
-            },
-        ];
+        const arrT = arr.type;
         lowerer.liftedFns.push({
             name,
             params: [
@@ -820,12 +1165,10 @@ export function lowerSafeIndexRead(lowerer, arr, index, loc) {
             ],
             returnType: resultT,
             locals: [
-                { id: "a.0", name: "a", type: arrT, mutable: true },
-                { id: "i.0", name: "i", type: F64, mutable: true },
-                { id: "n.0", name: "n", type: F64, mutable: false },
-                { id: "v.0", name: "v", type: elem, mutable: false },
+                { id: "a.0", name: "a", type: arrT, mutable: false },
+                { id: "i.0", name: "i", type: F64, mutable: false },
             ],
-            body,
+            body: [{ kind: "return", value: arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), loc }],
             loc,
         });
     }
@@ -859,7 +1202,7 @@ function arrayConcatHelper(lowerer, elem, shape, loc) {
         kind: "exprStmt",
         expr: {
             kind: "arrIntrinsic",
-            method: s === "a" ? "pushSpread" : "push",
+            method: s === "a" ? "concatSpread" : "push",
             receiver: varRef("out.0", arrT, loc),
             args: [src],
             type: F64,
@@ -887,9 +1230,10 @@ function arrayConcatHelper(lowerer, elem, shape, loc) {
    * `arity` is the callback's declared parameter count (1–3): the loop
    * passes the index and the receiver itself after the element when the
    * callback names them, exactly the arguments JS supplies. */
-function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem) {
     const arrT = arrayOf(elem);
-    const fnT = funcOf([elem, F64, arrT].slice(0, arity), fnRet);
+    const valueT = arrayValueType(lowerer, elem);
+    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const locals = [
         { id: "a.0", name: "a", type: arrT, mutable: true },
         { id: "f.0", name: "f", type: fnT, mutable: true },
@@ -907,25 +1251,14 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc) {
         type: fnRet,
         loc,
     });
-    const getElem = {
-        kind: "arrayGet",
+    const getElem = arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc);
+    const hasElem = {
+        kind: "arrayHas",
         arr: varRef("a.0", arrT, loc),
         index: varRef("i.0", F64, loc),
-        type: elem,
+        type: BOOL,
         loc,
     };
-    const push = (outT, value) => ({
-        kind: "exprStmt",
-        expr: {
-            kind: "arrIntrinsic",
-            method: "push",
-            receiver: varRef("out.0", outT, loc),
-            args: [value],
-            type: F64,
-            loc,
-        },
-        loc,
-    });
     const readLen = {
         kind: "varDecl",
         localId: "n.0",
@@ -935,41 +1268,85 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc) {
     const forLoop = (body) => countedFor(loc, varRef("n.0", F64, loc), () => body);
     let returnType;
     let body;
-    if (method === "map") {
-        const outT = arrayOf(fnRet);
-        locals.push({ id: "out.0", name: "out", type: outT, mutable: false });
+    if (method === "map" || method === "flatMap") {
+        const outT = arrayOf(outElem);
+        locals.push({ id: "out.0", name: "out", type: outT, mutable: false }, { id: "mapped.0", name: "mapped", type: fnRet, mutable: false });
         returnType = outT;
         body = [
             { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outT, loc }, loc },
             readLen,
-            forLoop([push(outT, callF(getElem))]),
+            ...(method === "map" ? [{ kind: "arraySetLength", arr: varRef("out.0", outT, loc), length: varRef("n.0", F64, loc), loc }] : []),
+            forLoop([
+                {
+                    kind: "if",
+                    cond: hasElem,
+                    then: [
+                        { kind: "varDecl", localId: "mapped.0", init: callF(getElem), loc },
+                        arrayValueStore(lowerer, varRef("out.0", outT, loc), method === "map" ? varRef("i.0", F64, loc) : { kind: "arrIntrinsic", method: "length", receiver: varRef("out.0", outT, loc), args: [], type: F64, loc }, varRef("mapped.0", fnRet, loc), outElem, loc),
+                    ],
+                    else_: null,
+                    loc,
+                },
+            ]),
             { kind: "return", value: varRef("out.0", outT, loc), loc },
         ];
     }
     else if (method === "filter") {
-        locals.push({ id: "out.0", name: "out", type: arrT, mutable: false }, { id: "v.0", name: "v", type: elem, mutable: false });
-        returnType = arrT;
+        const outT = arrayOf(outElem);
+        locals.push({ id: "out.0", name: "out", type: outT, mutable: false }, { id: "v.0", name: "v", type: valueT, mutable: false });
+        returnType = outT;
+        const retained = typeEquals(outElem, elem)
+            ? varRef("v.0", valueT, loc)
+            : valueT.kind === "union"
+                ? {
+                    kind: "unionNarrow",
+                    unionId: valueT.unionId,
+                    tag: lowerer.armTag(valueT.unionId, outElem),
+                    value: varRef("v.0", valueT, loc),
+                    type: outElem,
+                    loc,
+                }
+                : varRef("v.0", valueT, loc);
         body = [
-            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: arrT, loc }, loc },
+            { kind: "varDecl", localId: "out.0", init: { kind: "arrayLit", elems: [], type: outT, loc }, loc },
             readLen,
             forLoop([
-                { kind: "varDecl", localId: "v.0", init: getElem, loc },
                 {
                     kind: "if",
-                    // ToBoolean over the predicate's answer — inert when it already
-                    // returned bool, the per-union helper when it returned a union.
-                    cond: filterCond(callF(varRef("v.0", elem, loc)), fnRet, loc),
-                    then: [push(arrT, varRef("v.0", elem, loc))],
+                    cond: hasElem,
+                    then: [
+                        { kind: "varDecl", localId: "v.0", init: getElem, loc },
+                        {
+                            kind: "if",
+                            // ToBoolean over the predicate's answer — inert when it already
+                            // returned bool, the per-union helper when it returned a union.
+                            cond: filterCond(callF(varRef("v.0", valueT, loc)), fnRet, loc),
+                            then: [arrayValueStore(lowerer, varRef("out.0", outT, loc), { kind: "arrIntrinsic", method: "length", receiver: varRef("out.0", outT, loc), args: [], type: F64, loc }, retained, outElem, loc)],
+                            else_: null,
+                            loc,
+                        },
+                    ],
                     else_: null,
                     loc,
                 },
             ]),
-            { kind: "return", value: varRef("out.0", arrT, loc), loc },
+            { kind: "return", value: varRef("out.0", outT, loc), loc },
         ];
     }
     else {
         returnType = VOID;
-        body = [readLen, forLoop([{ kind: "exprStmt", expr: callF(getElem), loc }])];
+        body = [
+            readLen,
+            forLoop([
+                {
+                    kind: "if",
+                    cond: hasElem,
+                    then: [{ kind: "exprStmt", expr: callF(getElem), loc }],
+                    else_: null,
+                    loc,
+                },
+            ]),
+        ];
     }
     return { name, params, returnType, locals, body, loc };
 }
@@ -985,14 +1362,14 @@ function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc) {
    * 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). */
-function lowerArrayFindLikeCall(lowerer, call, access, method, elem) {
+function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bindUntyped = false) {
     const loc = locOf(call);
     const receiver = lowerer.lowerExpr(access.expression);
     const arrT = arrayOf(elem);
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [elem], arrT);
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT, bindUntyped);
     // JS takes the ToBoolean of the predicate's result — allowed wherever
     // that ToBoolean has a static answer (bool passes through; f64/string
     // by value; a truthy-answerable union by its arm — the
@@ -1022,21 +1399,13 @@ function lowerArrayFindLikeCall(lowerer, call, access, method, elem) {
     // 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 = lowerer.irTypeOf(call);
+    const resultT = bindUntyped ? arrayValueType(lowerer, elem) : lowerer.irTypeOf(call);
     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));
-    let foundTag = null;
-    if (!typeEquals(resultT, elem)) {
-        foundTag = lowerer.armTag(resultT.unionId, elem);
-        if (foundTag < 0) {
-            lowerer.unsupported("SC1090", call, `'.${method}' on '${lowerer.fmt(elem)}'-element arrays (the found element would need a union ` +
-                "re-tag that is not supported yet — loop and test instead)");
-        }
-    }
-    const helper = findHelper(lowerer, elem, resultT, foundTag, undefTag, fnRet, arity, last, loc);
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc);
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
 }
 /** ToBoolean of a predicate result inside a synthesized HOF helper — the
@@ -1053,7 +1422,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, foundTag, undefTag, fnRet, arity, last, loc) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc) {
     const method = last ? "findLast" : "find";
     const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}`;
     const existing = lowerer.arrHofHelpers.get(key);
@@ -1062,11 +1431,10 @@ function findHelper(lowerer, elem, resultT, foundTag, undefTag, fnRet, arity, la
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([elem, F64, arrT].slice(0, arity), fnRet);
-    const v = varRef("v.0", elem, loc);
-    const found = foundTag === null
-        ? v
-        : { kind: "unionWrap", unionId: resultT.unionId, tag: foundTag, value: v, type: resultT, 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 miss = {
         kind: "unionWrap",
         unionId: resultT.unionId,
@@ -1075,8 +1443,8 @@ function findHelper(lowerer, elem, resultT, foundTag, undefTag, fnRet, arity, la
         type: resultT,
         loc,
     };
-    const visit = [
-        { kind: "varDecl", localId: "v.0", init: getElemExpr(arrT, elem, loc), loc },
+    const visitBody = [
+        { kind: "varDecl", localId: "v.0", init: arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), loc },
         {
             kind: "if",
             cond: predToBool({
@@ -1091,6 +1459,7 @@ function findHelper(lowerer, elem, resultT, foundTag, undefTag, fnRet, arity, la
             loc,
         },
     ];
+    const visit = visitBody;
     const loop = last
         ? reverseCountedForLoop(loc, visit)
         : countedFor(loc, varRef("n.0", F64, loc), () => visit);
@@ -1111,7 +1480,7 @@ function findHelper(lowerer, elem, resultT, foundTag, undefTag, fnRet, arity, la
             { id: "f.0", name: "f", type: fnT, mutable: true },
             { id: "n.0", name: "n", type: F64, mutable: false },
             { id: "i.0", name: "i", type: F64, mutable: true },
-            { id: "v.0", name: "v", type: elem, mutable: false },
+            { id: "v.0", name: "v", type: valueT, mutable: false },
         ],
         body,
         loc,
@@ -1132,13 +1501,13 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc) {
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([elem, F64, arrT].slice(0, arity), fnRet);
+    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const visit = [{
             kind: "if",
             cond: predToBool({
                 kind: "callValue",
                 callee: varRef("f.0", fnT, loc),
-                args: [getElemExpr(arrT, elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
+                args: [arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
                 type: fnRet,
                 loc,
             }),
@@ -1185,11 +1554,11 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc) {
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([elem, F64, arrT].slice(0, arity), fnRet);
+    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const callF = predToBool({
         kind: "callValue",
         callee: varRef("f.0", fnT, loc),
-        args: [getElemExpr(arrT, elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
+        args: [arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
         type: fnRet,
         loc,
     });
@@ -1198,8 +1567,14 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc) {
         countedFor(loc, varRef("n.0", F64, loc), () => [
             {
                 kind: "if",
-                cond: method === "some" ? callF : { kind: "unary", op: "!", operand: callF, type: BOOL, loc },
-                then: [{ kind: "return", value: boolLit(method === "some", loc), loc }],
+                cond: currentArrayIndexPresent(arrT, loc),
+                then: [{
+                        kind: "if",
+                        cond: method === "some" ? callF : { kind: "unary", op: "!", operand: callF, type: BOOL, loc },
+                        then: [{ kind: "return", value: boolLit(method === "some", loc), loc }],
+                        else_: null,
+                        loc,
+                    }],
                 else_: null,
                 loc,
             },
@@ -1237,7 +1612,7 @@ function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [elem], arrT);
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [arrayValueType(lowerer, elem)], arrT);
     const fnRet = fnArg.type.ret;
     if (fnRet.kind === "union") {
         const def = lowerer.unions.get(fnRet.unionId);
@@ -1247,12 +1622,13 @@ function lowerArrayFlatMapCall(lowerer, call, access, elem) {
         }
     }
     if (fnRet.kind !== "array") {
-        // No flatten happens: exactly map's loop, map's helper.
+        // Scalar results append densely; source holes do not produce output slots.
         if (fnRet.kind === "void" || fnRet.kind === "func")
             lowerer.badType(call, lowerer.typeOf(call));
         fenceProducedArrayElem(lowerer, call, "'.flatMap()'", fnRet);
-        const helper = arrayHofHelper(lowerer, "map", elem, fnRet, arity, loc);
-        return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrayOf(fnRet), loc };
+        const outElem = callbackArrayElem(lowerer, call, fnRet);
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem);
+        return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrayOf(outElem), loc };
     }
     const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc);
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: fnRet, loc };
@@ -1275,7 +1651,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
     const inner = fnRet.elem;
-    const fnT = funcOf([elem, F64, arrT].slice(0, arity), fnRet);
+    const fnT = funcOf([arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const innerLoop = {
         kind: "for",
         init: { kind: "varDecl", localId: "j.0", init: numLit(0, loc), loc },
@@ -1288,15 +1664,13 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         },
         body: [
             {
-                kind: "exprStmt",
-                expr: {
-                    kind: "arrIntrinsic",
-                    method: "push",
-                    receiver: varRef("out.0", fnRet, loc),
-                    args: [{ kind: "arrayGet", arr: varRef("r.0", fnRet, loc), index: varRef("j.0", F64, loc), type: inner, loc }],
-                    type: F64,
-                    loc,
-                },
+                kind: "if",
+                cond: arrayIndexPresent(varRef("r.0", fnRet, loc), varRef("j.0", F64, loc), loc),
+                then: [
+                    { kind: "varDecl", localId: "inner.0", init: arrayValueRead(lowerer, varRef("r.0", fnRet, loc), varRef("j.0", F64, loc), inner, loc), loc },
+                    arrayValueStore(lowerer, varRef("out.0", fnRet, loc), { kind: "arrIntrinsic", method: "length", receiver: varRef("out.0", fnRet, loc), args: [], type: F64, loc }, varRef("inner.0", arrayValueType(lowerer, inner), loc), inner, loc),
+                ],
+                else_: null,
                 loc,
             },
         ],
@@ -1307,24 +1681,32 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
         readLenStmt(arrT, loc),
         countedFor(loc, varRef("n.0", F64, loc), () => [
             {
-                kind: "varDecl",
-                localId: "r.0",
-                init: {
-                    kind: "callValue",
-                    callee: varRef("f.0", fnT, loc),
-                    args: [getElemExpr(arrT, elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
-                    type: fnRet,
-                    loc,
-                },
-                loc,
-            },
-            {
-                kind: "varDecl",
-                localId: "m.0",
-                init: { kind: "arrIntrinsic", method: "length", receiver: varRef("r.0", fnRet, loc), args: [], type: F64, loc },
+                kind: "if",
+                cond: currentArrayIndexPresent(arrT, loc),
+                then: [
+                    {
+                        kind: "varDecl",
+                        localId: "r.0",
+                        init: {
+                            kind: "callValue",
+                            callee: varRef("f.0", fnT, loc),
+                            args: [arrayValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, loc), varRef("i.0", F64, loc), varRef("a.0", arrT, loc)].slice(0, arity),
+                            type: fnRet,
+                            loc,
+                        },
+                        loc,
+                    },
+                    {
+                        kind: "varDecl",
+                        localId: "m.0",
+                        init: { kind: "arrIntrinsic", method: "length", receiver: varRef("r.0", fnRet, loc), args: [], type: F64, loc },
+                        loc,
+                    },
+                    innerLoop,
+                ],
+                else_: null,
                 loc,
             },
-            innerLoop,
         ]),
         { kind: "return", value: varRef("out.0", fnRet, loc), loc },
     ];
@@ -1344,6 +1726,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc) {
             { id: "r.0", name: "r", type: fnRet, mutable: false },
             { id: "m.0", name: "m", type: F64, mutable: false },
             { id: "j.0", name: "j", type: F64, mutable: true },
+            { id: "inner.0", name: "inner", type: arrayValueType(lowerer, inner), mutable: false },
         ],
         body,
         loc,
@@ -1363,13 +1746,12 @@ function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const hasInit = call.arguments.length === 2;
-    const accT = hasInit ? lowerer.irTypeOf(call) : elem;
+    const accT = lowerer.runtimeOptionalReduceTypes.get(call) ??
+        (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, elem], arrT);
-    if (!typeEquals(fnArg.type.ret, accT))
-        lowerer.badType(argNode, lowerer.typeOf(argNode));
-    const helper = reduceHelper(lowerer, method, elem, accT, arity, hasInit, loc);
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT);
+    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc);
     const args = [receiver, fnArg];
     if (hasInit)
         args.push(lowerer.lowerExprExpecting(call.arguments[1], accT));
@@ -1385,19 +1767,19 @@ function lowerArrayReduceCall(lowerer, call, access, method, elem) {
    * reduce walks 0→n-1, reduceRight n-1→0; the seed without an initial
    * value is a[0] / a[n-1] and the loop starts one past it. The empty-array
    * TypeError message is Node's, byte for byte. */
-function reduceHelper(lowerer, method, elem, accT, arity, hasInit, loc) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${arity}:${hasInit ? "init" : "seed"}`;
+function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = `%arr.${method}.${lowerer.arrHofHelpers.size}`;
     lowerer.arrHofHelpers.set(key, name);
     const arrT = arrayOf(elem);
-    const fnT = funcOf([accT, elem, F64, arrT].slice(0, arity), accT);
+    const fnT = funcOf([accT, arrayValueType(lowerer, elem), F64, arrT].slice(0, arity), fnRet);
     const n = varRef("n.0", F64, loc);
     const i = varRef("i.0", F64, loc);
     const right = method === "reduceRight";
-    const at = (index) => ({ kind: "arrayGet", arr: varRef("a.0", arrT, loc), index, type: elem, loc });
+    const at = (index) => arrayValueRead(lowerer, varRef("a.0", arrT, loc), index, elem, loc);
     const locals = [
         { id: "a.0", name: "a", type: arrT, mutable: true },
         { id: "f.0", name: "f", type: fnT, mutable: true },
@@ -1411,50 +1793,27 @@ function reduceHelper(lowerer, method, elem, accT, arity, hasInit, loc) {
         { localId: "f.0", name: "f", type: fnT },
         ...(hasInit ? [{ localId: "z.0", name: "z", type: accT }] : []),
     ];
-    const seedStmts = hasInit
-        ? [{ kind: "varDecl", localId: "acc.0", init: varRef("z.0", accT, loc), loc }]
-        : [
-            {
-                kind: "if",
-                cond: { kind: "bin", op: "===", left: n, right: numLit(0, loc), type: BOOL, loc },
-                then: [
-                    {
-                        kind: "throw",
-                        value: {
-                            kind: "libCall",
-                            fn: "error.new",
-                            args: [
-                                {
-                                    kind: "strLit",
-                                    value: "Reduce of empty array with no initial value",
-                                    type: STRING,
-                                    loc,
-                                },
-                            ],
-                            type: { kind: "object", className: "%TypeError" },
-                            loc,
-                        },
-                        loc,
-                    },
-                ],
-                else_: null,
-                loc,
-            },
-            {
-                kind: "varDecl",
-                localId: "acc.0",
-                init: at(right ? { kind: "bin", op: "-", left: n, right: numLit(1, loc), type: F64, loc } : numLit(0, loc)),
-                loc,
-            },
-        ];
-    // Loop bounds: with init the walk covers every index; the seeded form
-    // starts one past the seed. reduce ascends, reduceRight descends.
     const start = right
-        ? { kind: "bin", op: "-", left: n, right: numLit(hasInit ? 1 : 2, loc), type: F64, loc }
-        : numLit(hasInit ? 0 : 1, loc);
+        ? { kind: "bin", op: "-", left: n, right: numLit(1, loc), type: F64, loc }
+        : numLit(0, loc);
+    const inRange = right
+        ? { kind: "bin", op: ">=", left: i, right: numLit(0, loc), type: BOOL, loc }
+        : { kind: "bin", op: "<", left: i, right: n, type: BOOL, loc };
+    const advance = { kind: "assign", localId: "i.0", value: { kind: "bin", op: right ? "-" : "+", left: i, right: numLit(1, loc), type: F64, loc }, loc };
+    const seedStmts = [
+        { kind: "varDecl", localId: "i.0", init: start, loc },
+        ...(hasInit
+            ? [{ kind: "varDecl", localId: "acc.0", init: varRef("z.0", accT, loc), loc }]
+            : [
+                { kind: "while", cond: { kind: "ternary", cond: inRange, then: { kind: "unary", op: "!", operand: currentArrayIndexPresent(arrT, loc), type: BOOL, loc }, else_: boolLit(false, loc), type: BOOL, loc }, body: [advance], loc },
+                { kind: "if", cond: { kind: "unary", op: "!", operand: inRange, type: BOOL, loc }, then: [{ kind: "throw", value: { kind: "libCall", fn: "error.new", args: [{ kind: "strLit", value: "Reduce of empty array with no initial value", type: STRING, loc }], type: { kind: "object", className: "%TypeError" }, loc }, loc }], else_: null, loc },
+                { kind: "varDecl", localId: "acc.0", init: lowerer.coerceToExpected(at(i), accT), loc },
+                advance,
+            ]),
+    ];
     const loop = {
         kind: "for",
-        init: { kind: "varDecl", localId: "i.0", init: start, loc },
+        init: null,
         cond: right
             ? { kind: "bin", op: ">=", left: i, right: numLit(0, loc), type: BOOL, loc }
             : { kind: "bin", op: "<", left: i, right: n, type: BOOL, loc },
@@ -1464,20 +1823,20 @@ function reduceHelper(lowerer, method, elem, accT, arity, hasInit, loc) {
             value: { kind: "bin", op: right ? "-" : "+", left: i, right: numLit(1, loc), type: F64, loc },
             loc,
         },
-        body: [
-            {
-                kind: "assign",
-                localId: "acc.0",
-                value: {
-                    kind: "callValue",
-                    callee: varRef("f.0", fnT, loc),
-                    args: [varRef("acc.0", accT, loc), at(i), i, varRef("a.0", arrT, loc)].slice(0, arity),
-                    type: accT,
-                    loc,
-                },
-                loc,
-            },
-        ],
+        body: [{ kind: "if", cond: currentArrayIndexPresent(arrT, loc), then: [
+                    {
+                        kind: "assign",
+                        localId: "acc.0",
+                        value: lowerer.coerceToExpected({
+                            kind: "callValue",
+                            callee: varRef("f.0", fnT, loc),
+                            args: [varRef("acc.0", accT, loc), at(i), i, varRef("a.0", arrT, loc)].slice(0, arity),
+                            type: fnRet,
+                            loc,
+                        }, accT),
+                        loc,
+                    },
+                ], else_: null, loc }],
         loc,
     };
     const body = [
@@ -1493,19 +1852,20 @@ function reduceHelper(lowerer, method, elem, accT, arity, hasInit, loc) {
    * function like the other array HOFs. sort mutates and returns the receiver;
    * toSorted takes its shallow snapshot INSIDE the helper, after the receiver
    * and comparator expressions have both been evaluated, then sorts and
-   * returns that copy without touching the receiver. The loop is a
-   * binary-free INSERTION sort: stable (equal-comparing elements keep their
-   * source order, which is what Node's stable TimSort produces for any
-   * consistent comparator) and JS-faithful on the comparator contract — an
-   * element moves left only while cmp(left, v) > 0, so a NaN or 0 result holds
-   * position exactly like the spec's "treat as equal". The SEQUENCE of
-   * comparator calls differs from V8's TimSort (SEMANTICS.md); results are
-   * identical for consistent comparators. The comparator-less form lowers for
-   * STRING elements only — JS's default converts every element to string and
-   * compares UTF-16 units, so the interned synthesized comparator selects the
-   * runtime's code-unit ordering rather than scriptc's documented code-point
-   * relational operators. For numbers that default is the notorious string
-   * sort ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
+   * returns that copy without touching the receiver. The helper uses a stable
+   * bottom-up merge sort with an ordered-boundary check: ordered inputs use a
+   * linear number of comparator calls, but buffer movement remains O(n log n)
+   * even when every boundary is already ordered. During a merge, an element
+   * moves right only while cmp(left, right) > 0, so a NaN or 0 result keeps
+   * the left element first. Undefined values sink without reaching the user
+   * comparator. The callback sequence differs from V8's TimSort, so exact
+   * order and count parity are not claimed; results agree for consistent
+   * comparators. The comparator-less form lowers for STRING elements only —
+   * JS's default converts every element to string and compares UTF-16 units,
+   * so the interned synthesized comparator selects the runtime's code-unit
+   * ordering rather than scriptc's documented code-point relational
+   * operators. For numbers that default is the notorious string sort
+   * ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
    * comparator. */
 function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     const loc = locOf(call);
@@ -1599,441 +1959,6 @@ function defaultStringCmpHelper(lowerer, loc) {
     });
     return name;
 }
-/** The insertion-sort loop, from existing IR nodes:
-   *
-   *   n = a.length;
-    *   for (i = 1; i < n; i++) {
-    *     v = a[i]; j = i - 1;
-    *     while (j >= 0) {
-    *       if (CompareArrayElements(a[j], v, f) > 0) {
-    *         a[j + 1] = a[j]; j = j - 1;
-    *       } else break;
-   *     }
-   *     a[j + 1] = v;
-   *   }
-   *   return a;
-   */
-function buildArraySortFn(name, elem, arity, copyFirst, undefinedTag, loc) {
-    const arrT = arrayOf(elem);
-    const fnT = funcOf([elem, elem].slice(0, arity), F64);
-    const j = varRef("j.0", F64, loc);
-    const at = (index) => ({ kind: "arrayGet", arr: varRef("a.0", arrT, loc), index, type: elem, loc });
-    const jPlus1 = { kind: "bin", op: "+", left: j, right: numLit(1, loc), type: F64, loc };
-    const isUndefined = (value) => {
-        if (elem.kind === "union" && undefinedTag !== null) {
-            return {
-                kind: "unionIsTag",
-                unionId: elem.unionId,
-                tag: undefinedTag,
-                negated: false,
-                value,
-                type: BOOL,
-                loc,
-            };
-        }
-        if (elem.kind === "jsval") {
-            return {
-                kind: "jsOp",
-                op: "eq",
-                args: [
-                    value,
-                    { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc },
-                ],
-                type: BOOL,
-                loc,
-            };
-        }
-        return null;
-    };
-    const compareGreater = {
-        kind: "bin",
-        op: ">",
-        left: {
-            kind: "callValue",
-            callee: varRef("f.0", fnT, loc),
-            args: [at(j), varRef("v.0", elem, loc)].slice(0, arity),
-            type: F64,
-            loc,
-        },
-        right: numLit(0, loc),
-        type: BOOL,
-        loc,
-    };
-    const leftUndefined = isUndefined(at(j));
-    const valueUndefined = isUndefined(varRef("v.0", elem, loc));
-    // CompareArrayElements: undefined always sinks and never reaches the
-    // user comparator. Ternaries preserve that callback suppression.
-    const shouldShift = leftUndefined !== null && valueUndefined !== null
-        ? {
-            kind: "ternary",
-            cond: leftUndefined,
-            then: {
-                kind: "unary",
-                op: "!",
-                operand: valueUndefined,
-                type: BOOL,
-                loc,
-            },
-            else_: {
-                kind: "ternary",
-                cond: valueUndefined,
-                then: { kind: "boolLit", value: false, type: BOOL, loc },
-                else_: compareGreater,
-                type: BOOL,
-                loc,
-            },
-            type: BOOL,
-            loc,
-        }
-        : compareGreater;
-    const shiftLoop = {
-        kind: "while",
-        cond: { kind: "bin", op: ">=", left: j, right: numLit(0, loc), type: BOOL, loc },
-        body: [
-            {
-                kind: "if",
-                cond: shouldShift,
-                then: [
-                    { kind: "arraySet", arr: varRef("a.0", arrT, loc), index: jPlus1, value: at(j), loc },
-                    { kind: "assign", localId: "j.0", value: { kind: "bin", op: "-", left: j, right: numLit(1, loc), type: F64, loc }, loc },
-                ],
-                else_: [{ kind: "break", loc }],
-                loc,
-            },
-        ],
-        loc,
-    };
-    const body = [
-        ...(copyFirst
-            ? [{
-                    kind: "assign",
-                    localId: "a.0",
-                    value: {
-                        kind: "arrIntrinsic",
-                        method: "slice",
-                        receiver: varRef("a.0", arrT, loc),
-                        args: [],
-                        type: arrT,
-                        loc,
-                    },
-                    loc,
-                }]
-            : []),
-        readLenStmt(arrT, loc),
-        countedFor(loc, { kind: "bin", op: "-", left: varRef("n.0", F64, loc), right: numLit(1, loc), type: F64, loc }, (index) => [
-            {
-                kind: "varDecl",
-                localId: "v.0",
-                init: {
-                    kind: "arrayGet",
-                    arr: varRef("a.0", arrT, loc),
-                    index: { kind: "bin", op: "+", left: index, right: numLit(1, loc), type: F64, loc },
-                    type: elem,
-                    loc,
-                },
-                loc,
-            },
-            { kind: "varDecl", localId: "j.0", init: index, loc },
-            shiftLoop,
-            { kind: "arraySet", arr: varRef("a.0", arrT, loc), index: jPlus1, value: varRef("v.0", elem, loc), loc },
-        ]),
-        { kind: "return", value: varRef("a.0", arrT, loc), loc },
-    ];
-    return {
-        name,
-        params: [
-            { localId: "a.0", name: "a", type: arrT },
-            { localId: "f.0", name: "f", type: fnT },
-        ],
-        returnType: arrT,
-        locals: [
-            { id: "a.0", name: "a", type: arrT, mutable: true },
-            { id: "f.0", name: "f", type: fnT, mutable: true },
-            { id: "n.0", name: "n", type: F64, mutable: false },
-            { id: "i.0", name: "i", type: F64, mutable: true },
-            { id: "v.0", name: "v", type: elem, mutable: false },
-            { id: "j.0", name: "j", type: F64, mutable: true },
-        ],
-        body,
-        loc,
-    };
-}
-/** Uint8Array.prototype.toSorted. The receiver/comparator expressions are
- * evaluated before entering the helper; the helper snapshots with
- * TypedArray.prototype.slice before its first comparison, then performs
- * the same stable insertion walk as Array.toSorted. Uint8Array's default
- * comparator is numeric ascending, so its comparator-less form needs no
- * string-conversion machinery. */
-function lowerBytesToSortedCall(lowerer, call, access, bytesT) {
-    const loc = locOf(call);
-    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`.toSorted with ${call.arguments.length} arguments on Uint8Array`, call);
-    }
-    const receiver = lowerer.lowerExpr(access.expression);
-    const undefinedArg = call.arguments[0]
-        ? lowerStaticallyUndefinedArg(lowerer, call.arguments[0])
-        : null;
-    if (call.arguments.length === 0 || undefinedArg) {
-        const key = "bytes.toSorted:u8:default";
-        let helper = lowerer.arrHofHelpers.get(key);
-        if (!helper) {
-            helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
-            lowerer.arrHofHelpers.set(key, helper);
-            lowerer.liftedFns.push(buildBytesSortFn(helper, 0, false, loc));
-        }
-        if (!undefinedArg || droppableStatic(undefinedArg)) {
-            return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
-        }
-        // The default helper takes no comparator argument. Snapshot the
-        // receiver into a hidden local so the discarded undefined argument
-        // still evaluates after the receiver and before the helper call.
-        const saved = lowerer.declareHiddenLocal("%bytesSortRecv", bytesT);
-        const savedRef = {
-            kind: "varRef",
-            localId: saved.id,
-            type: bytesT,
-            loc,
-        };
-        return {
-            kind: "seqExpr",
-            stmts: [
-                { kind: "varDecl", localId: saved.id, init: receiver, loc },
-                { kind: "exprStmt", expr: undefinedArg, loc: undefinedArg.loc },
-            ],
-            result: {
-                kind: "call",
-                callee: helper,
-                args: [savedRef],
-                type: bytesT,
-                loc,
-            },
-            type: bytesT,
-            loc,
-        };
-    }
-    const argNode = call.arguments[0];
-    const fnArg = lowerer.lowerExpr(argNode);
-    if (fnArg.type.kind !== "func" ||
-        fnArg.type.params.length > 2 ||
-        !fnArg.type.params.every((p) => p.kind === "f64") ||
-        fnArg.type.ret.kind !== "f64") {
-        lowerer.badType(argNode, lowerer.typeOf(argNode));
-    }
-    const arity = fnArg.type.params.length;
-    const key = `bytes.toSorted:u8:${arity}`;
-    let helper = lowerer.arrHofHelpers.get(key);
-    if (!helper) {
-        helper = `%bytes.toSorted.${lowerer.arrHofHelpers.size}`;
-        lowerer.arrHofHelpers.set(key, helper);
-        lowerer.liftedFns.push(buildBytesSortFn(helper, arity, true, loc));
-    }
-    return {
-        kind: "call",
-        callee: helper,
-        args: [receiver, fnArg],
-        type: bytesT,
-        loc,
-    };
-}
-function buildBytesSortFn(name, arity, hasComparator, loc) {
-    const bytesT = BYTES_U8;
-    const fnT = funcOf([F64, F64].slice(0, arity), F64);
-    const j = varRef("j.0", F64, loc);
-    const at = (index) => ({
-        kind: "bytesIntrinsic",
-        method: "get",
-        receiver: varRef("a.0", bytesT, loc),
-        args: [index],
-        type: F64,
-        loc,
-    });
-    const jPlus1 = {
-        kind: "bin",
-        op: "+",
-        left: j,
-        right: numLit(1, loc),
-        type: F64,
-        loc,
-    };
-    const compare = hasComparator
-        ? {
-            kind: "callValue",
-            callee: varRef("f.0", fnT, loc),
-            args: [at(j), varRef("v.0", F64, loc)].slice(0, arity),
-            type: F64,
-            loc,
-        }
-        : {
-            kind: "bin",
-            op: "-",
-            left: at(j),
-            right: varRef("v.0", F64, loc),
-            type: F64,
-            loc,
-        };
-    const shiftLoop = {
-        kind: "while",
-        cond: {
-            kind: "bin",
-            op: ">=",
-            left: j,
-            right: numLit(0, loc),
-            type: BOOL,
-            loc,
-        },
-        body: [
-            {
-                kind: "if",
-                cond: {
-                    kind: "bin",
-                    op: ">",
-                    left: compare,
-                    right: numLit(0, loc),
-                    type: BOOL,
-                    loc,
-                },
-                then: [
-                    {
-                        kind: "bytesSet",
-                        arr: varRef("a.0", bytesT, loc),
-                        index: jPlus1,
-                        value: at(j),
-                        loc,
-                    },
-                    {
-                        kind: "assign",
-                        localId: "j.0",
-                        value: {
-                            kind: "bin",
-                            op: "-",
-                            left: j,
-                            right: numLit(1, loc),
-                            type: F64,
-                            loc,
-                        },
-                        loc,
-                    },
-                ],
-                else_: [{ kind: "break", loc }],
-                loc,
-            },
-        ],
-        loc,
-    };
-    const params = [
-        { localId: "a.0", name: "a", type: bytesT },
-        ...(hasComparator
-            ? [{ localId: "f.0", name: "f", type: fnT }]
-            : []),
-    ];
-    const locals = [
-        { id: "a.0", name: "a", type: bytesT, mutable: true },
-        ...(hasComparator
-            ? [{ id: "f.0", name: "f", type: fnT, mutable: true }]
-            : []),
-        { id: "n.0", name: "n", type: F64, mutable: false },
-        { id: "i.0", name: "i", type: F64, mutable: true },
-        { id: "v.0", name: "v", type: F64, mutable: false },
-        { id: "j.0", name: "j", type: F64, mutable: true },
-    ];
-    const body = [
-        {
-            kind: "assign",
-            localId: "a.0",
-            value: {
-                kind: "bytesIntrinsic",
-                method: "slice",
-                receiver: varRef("a.0", bytesT, loc),
-                args: [],
-                type: bytesT,
-                loc,
-            },
-            loc,
-        },
-        {
-            kind: "varDecl",
-            localId: "n.0",
-            init: {
-                kind: "bytesIntrinsic",
-                method: "length",
-                receiver: varRef("a.0", bytesT, loc),
-                args: [],
-                type: F64,
-                loc,
-            },
-            loc,
-        },
-        {
-            kind: "for",
-            init: {
-                kind: "varDecl",
-                localId: "i.0",
-                init: numLit(1, loc),
-                loc,
-            },
-            cond: {
-                kind: "bin",
-                op: "<",
-                left: varRef("i.0", F64, loc),
-                right: varRef("n.0", F64, loc),
-                type: BOOL,
-                loc,
-            },
-            update: {
-                kind: "assign",
-                localId: "i.0",
-                value: {
-                    kind: "bin",
-                    op: "+",
-                    left: varRef("i.0", F64, loc),
-                    right: numLit(1, loc),
-                    type: F64,
-                    loc,
-                },
-                loc,
-            },
-            body: [
-                {
-                    kind: "varDecl",
-                    localId: "v.0",
-                    init: at(varRef("i.0", F64, loc)),
-                    loc,
-                },
-                {
-                    kind: "varDecl",
-                    localId: "j.0",
-                    init: {
-                        kind: "bin",
-                        op: "-",
-                        left: varRef("i.0", F64, loc),
-                        right: numLit(1, loc),
-                        type: F64,
-                        loc,
-                    },
-                    loc,
-                },
-                shiftLoop,
-                {
-                    kind: "bytesSet",
-                    arr: varRef("a.0", bytesT, loc),
-                    index: jPlus1,
-                    value: varRef("v.0", F64, loc),
-                    loc,
-                },
-            ],
-            loc,
-        },
-        { kind: "return", value: varRef("a.0", bytesT, loc), loc },
-    ];
-    return {
-        name,
-        params,
-        returnType: bytesT,
-        locals,
-        body,
-        loc,
-    };
-}
 /** `n = a.length` — the once-up-front length read every array HOF loop
    * starts with (locals a.0/n.0 by convention). */
 function readLenStmt(arrT, loc) {
@@ -2111,14 +2036,6 @@ function lowerArrayAtCall(lowerer, call, access, elem) {
     const undefTag = lowerer.armTag(resultT.unionId, UNDEFINED_T);
     if (undefTag < 0)
         lowerer.badType(call, lowerer.typeOf(call));
-    let foundTag = null;
-    if (!typeEquals(resultT, elem)) {
-        foundTag = lowerer.armTag(resultT.unionId, elem);
-        if (foundTag < 0) {
-            lowerer.unsupported("SC1090", call, `'.at' on '${lowerer.fmt(elem)}'-element arrays (the element would need a union ` +
-                "re-tag that is not supported yet — index and test instead)");
-        }
-    }
     const key = `at:${typeKey(elem)}:${typeKey(resultT)}`;
     let name = lowerer.arrHofHelpers.get(key);
     if (!name) {
@@ -2128,10 +2045,7 @@ function lowerArrayAtCall(lowerer, call, access, elem) {
         const t = varRef("t.0", F64, loc);
         const i = varRef("i.0", F64, loc);
         const n = varRef("n.0", F64, loc);
-        const v = varRef("v.0", elem, loc);
-        const found = foundTag === null
-            ? v
-            : { kind: "unionWrap", unionId: resultT.unionId, tag: foundTag, value: v, type: resultT, loc };
+        const found = lowerer.coerceToExpected(arrayValueRead(lowerer, varRef("a.0", arrT, loc), t, elem, loc), resultT);
         const miss = {
             kind: "unionWrap",
             unionId: resultT.unionId,
@@ -2183,12 +2097,6 @@ function lowerArrayAtCall(lowerer, call, access, elem) {
                 else_: null,
                 loc,
             },
-            {
-                kind: "varDecl",
-                localId: "v.0",
-                init: { kind: "arrayGet", arr: varRef("a.0", arrT, loc), index: t, type: elem, loc },
-                loc,
-            },
             { kind: "return", value: found, loc },
         ];
         lowerer.liftedFns.push({
@@ -2203,7 +2111,6 @@ function lowerArrayAtCall(lowerer, call, access, elem) {
                 { id: "i.0", name: "i", type: F64, mutable: true },
                 { id: "n.0", name: "n", type: F64, mutable: false },
                 { id: "t.0", name: "t", type: F64, mutable: true },
-                { id: "v.0", name: "v", type: elem, mutable: false },
             ],
             body,
             loc,
@@ -2435,7 +2342,15 @@ export function lowerMapMethodCall(lowerer, call, access) {
     const name = access.name.text;
     if (!MAP_METHODS.has(name) && !MAP_ITER_METHODS.has(name))
         return null;
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
+    let probedUntyped = false;
+    if (receiverIr?.kind !== "map" && isJsSourceFile(access.getSourceFile())) {
+        const probed = tryLowerExpression(lowerer, access.expression);
+        if (probed?.type.kind === "map") {
+            receiverIr = probed.type;
+            probedUntyped = true;
+        }
+    }
     if (receiverIr?.kind !== "map")
         return null;
     if (!lowerer.isStdlibMember(access))
@@ -2479,7 +2394,7 @@ export function lowerMapMethodCall(lowerer, call, access) {
         return lowerMapIterDrainCall(lowerer, call, receiver, receiverIr, name);
     }
     // forEach
-    return lowerer.lowerMapForEachCall(call, receiver, receiverIr);
+    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"]);
@@ -2599,12 +2514,52 @@ function buildMapIterDrainFn(name, mapT, method, elemT, tupleT, loc) {
    * callback throws. That is JS's live-iteration contract, Node-verified
    * (SEMANTICS.md). The callback receives (value, key) like JS; declaring
    * fewer parameters — (value) or () — is ordinary TS and supported. */
-export function lowerMapForEachCall(lowerer, call, receiver, mapT) {
+export function lowerMapForEachCall(lowerer, call, receiver, mapT, bindUntyped = false) {
     const loc = locOf(call);
     const argNode = call.arguments[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
-    const fnArg = lowerer.lowerExpr(argNode);
+    const previousRuntime = [];
+    const previousImplicit = lowerer.implicitParamTypes;
+    let contextualTs = null;
+    if (bindUntyped && (ts.isArrowFunction(argNode) || ts.isFunctionExpression(argNode))) {
+        const expected = [mapT.value, mapT.key];
+        argNode.parameters.slice(0, 2).forEach((param, i) => {
+            const type = expected[i];
+            if (type === undefined || !ts.isIdentifier(param.name) || param.type || param.initializer || param.dotDotDotToken)
+                return;
+            const checkerType = lowerer.checker.getTypeAtLocation(param.name);
+            if ((checkerType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) === 0)
+                return;
+            const symbol = lowerer.checker.getSymbolAtLocation(param.name);
+            if (!symbol)
+                return;
+            previousRuntime.push({ symbol, type: lowerer.runtimeOptionalBindingTypes.get(symbol) });
+            lowerer.runtimeOptionalBindingTypes.set(symbol, type);
+            const primitive = type.kind === "string" ? lowerer.checker.getStringType() :
+                type.kind === "f64" ? lowerer.checker.getNumberType() :
+                    type.kind === "bool" ? lowerer.checker.getBooleanType() : null;
+            if (primitive !== null) {
+                contextualTs ??= new Map(previousImplicit ?? []);
+                contextualTs.set(symbol, primitive);
+            }
+        });
+    }
+    if (contextualTs !== null)
+        lowerer.implicitParamTypes = contextualTs;
+    let fnArg;
+    try {
+        fnArg = lowerer.lowerExpr(argNode);
+    }
+    finally {
+        lowerer.implicitParamTypes = previousImplicit;
+        for (const { symbol, type } of previousRuntime) {
+            if (type === undefined)
+                lowerer.runtimeOptionalBindingTypes.delete(symbol);
+            else
+                lowerer.runtimeOptionalBindingTypes.set(symbol, type);
+        }
+    }
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > 2 ||
         (fnArg.type.params.length >= 1 && !typeEquals(fnArg.type.params[0], mapT.value)) ||
@@ -2727,8 +2682,8 @@ export function lowerSetMethodCall(lowerer, call, access) {
     // 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 === null && isJsSourceFile(access.getSourceFile())) {
-        const probed = probeLower(lowerer, access.expression);
+    if (receiverIr?.kind !== "set" && isJsSourceFile(access.getSourceFile())) {
+        const probed = tryLowerExpression(lowerer, access.expression);
         if (probed?.type.kind === "set")
             receiverIr = probed.type;
     }
@@ -3906,7 +3861,7 @@ export function lowerForOfSearchParams(lowerer, stmt, iterable, proj) {
 export function lowerForOfArrayIter(lowerer, stmt, iterable, proj) {
     const loc = locOf(stmt);
     const arrT = iterable.type;
-    const elemT = arrT.kind === "array" ? arrT.elem : F64;
+    const elemT = arrT.kind === "array" ? arrayValueType(lowerer, arrT.elem) : F64;
     const yieldsPair = proj === "entries";
     if (!ts.isVariableDeclarationList(stmt.initializer)) {
         lowerer.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
@@ -3925,13 +3880,7 @@ export function lowerForOfArrayIter(lowerer, stmt, iterable, proj) {
         i.mutable = true;
         const keyRead = () => varRef(i.id, F64, loc);
         const valRead = () => arrT.kind === "array"
-            ? {
-                kind: "arrayGet",
-                arr: varRef(arr.id, arrT, loc),
-                index: varRef(i.id, F64, loc),
-                type: elemT,
-                loc,
-            }
+            ? arrayValueRead(lowerer, varRef(arr.id, arrT, loc), varRef(i.id, F64, loc), arrT.elem, loc)
             : {
                 kind: "bytesIntrinsic",
                 method: "get",
@@ -3954,6 +3903,11 @@ export function lowerForOfArrayIter(lowerer, stmt, iterable, proj) {
             binds.push({ kind: "varDecl", localId: kLocal.id, init: keyRead(), loc });
             if (els[1]) {
                 const vLocal = lowerer.declareLocal(els[1].name, els[1].name.text, elemT, isLet);
+                if (arrT.kind === "array" && !typeEquals(elemT, arrT.elem)) {
+                    const root = lowerer.runtimeOptionalRootOf(vLocal);
+                    lowerer.runtimeOptionalLocals.add(root);
+                    lowerer.runtimeOptionalStorageLocals.add(root);
+                }
                 binds.push({ kind: "varDecl", localId: vLocal.id, init: valRead(), loc });
             }
         }
@@ -3964,6 +3918,13 @@ export function lowerForOfArrayIter(lowerer, stmt, iterable, proj) {
             const declT = lowerer.mapTypeOf(lowerer.checker.getTypeAtLocation(decl.name));
             if (yieldsPair) {
                 const shape = declT?.kind === "record" ? lowerer.shapes.get(declT.shapeId) : null;
+                if (declT?.kind === "record" && shape?.tuple && arrT.kind === "array") {
+                    const valueField = shape.fields.find((field) => field.name === "1");
+                    if (valueField && typeEquals(valueField.type, arrT.elem) && !typeEquals(elemT, arrT.elem)) {
+                        valueField.type = elemT;
+                        lowerer.runtimeOptionalFields.add(lowerer.runtimeOptionalFieldKey(declT.shapeId, "1"));
+                    }
+                }
                 if (declT?.kind !== "record" || !shape?.tuple || shape.fields.length !== 2 ||
                     shape.fields.find((f) => f.name === "0")?.type.kind !== "f64" ||
                     !typeEquals(shape.fields.find((f) => f.name === "1")?.type ?? F64, elemT)) {
@@ -4373,1226 +4334,6 @@ function buildMapSeedFn(mapT, name, arrT, tupleT, kT, vT, loc) {
         loc,
     };
 }
-/** Regex method calls, both directions: `re.test(s)` on a regex receiver,
-   * and `s.replace(re, tpl)` / `s.replaceAll(re, tpl)` / `s.split(re)` on a
-   * string receiver whose FIRST ARGUMENT is a regex (the string-pattern
-   * overloads keep their island lowering — the argument's mapped type is
-   * what routes here, before lowerIslandMethodCall can claim the name).
-   * Null when neither shape matches. */
-export function lowerRegexMethodCall(lowerer, call, access, dynReceiver) {
-    // chainBlocked, not a raw token test: an optional-chain re-dispatch
-    // (`rawName?.match(re)` — the receiver reads back chain-narrowed)
-    // rides the same lowering as the plain spelling.
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    // A validated dyn receiver (lowerStringMethodCall's story) is a STRING
-    // by construction — the symbol gate doesn't apply to `any` receivers.
-    if (dynReceiver === undefined && !lowerer.isStdlibMember(access))
-        return null;
-    const name = access.name.text;
-    const receiverKind = dynReceiver ? "string" : lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
-    const lowerReceiver = () => (dynReceiver ? dynReceiver() : lowerer.lowerExpr(access.expression));
-    const loc = locOf(call);
-    if (receiverKind === "regex" && name === "test") {
-        // The statefulness fence, at compile time where the flags are
-        // visible: a literal receiver (possibly parenthesized). Values that
-        // flow through variables hit the same fence at runtime.
-        let recv = access.expression;
-        while (ts.isParenthesizedExpression(recv))
-            recv = recv.expression;
-        if (ts.isRegularExpressionLiteral(recv)) {
-            const flags = recv.text.slice(recv.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1121", call);
-            }
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = call.arguments.map((a) => lowerer.lowerExpr(a));
-        return { kind: "regexIntrinsic", method: "test", receiver, args, type: BOOL, loc };
-    }
-    // `re.exec(s)` for non-g/y regexes: spec-identical to `s.match(re)`
-    // (Symbol.match delegates to exec when lastIndex is out of play), so
-    // it lowers to the SAME match intrinsic with the operands swapped —
-    // the honest `string[] | null` slice, nonparticipating captures ""
-    // (match's documented rule). The g/y statefulness fence applies at
-    // compile time on literal receivers, exactly test()'s stance; values
-    // reaching the runtime with those flags abort there.
-    if (receiverKind === "regex" && name === "exec") {
-        if (call.arguments.length !== 1)
-            return null; // exec takes exactly the subject
-        let recv = access.expression;
-        while (ts.isParenthesizedExpression(recv))
-            recv = recv.expression;
-        if (ts.isRegularExpressionLiteral(recv)) {
-            const flags = recv.text.slice(recv.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1121", call);
-            }
-        }
-        const re = lowerer.lowerExpr(access.expression);
-        const subject = lowerer.lowerExprExpecting(call.arguments[0], STRING);
-        const resultT = { kind: "union", unionId: lowerer.unions.intern([arrayOf(STRING), { kind: "nullT" }]) };
-        return { kind: "regexIntrinsic", method: "match", receiver: subject, args: [re], type: resultT, loc };
-    }
-    // `s.match(re)` for non-g/y regexes: Node's exec-shaped result reduced
-    // to the honest slice — the `string[] | null` union holding
-    // [whole match, ...captures] or the null arm. The g-flag match returns
-    // EVERY match (a different shape) and /y is stateful — both fence at
-    // compile time on literal arguments (values reaching the runtime with
-    // those flags abort, the test() stance). `.index`/`.input` reads on
-    // the result fence per member (array-typed value); `.groups` reads
-    // desugar at their access sites when the regex is statically known
-    // (lowerMatchGroupsRead).
-    // `s.match(re)` also claims a NULLABLE string receiver (string + unit
-    // arms — `process.versions.openssl.match(...)`, the Dict<string>
-    // member the node suite's crypto helper reads): the checked
-    // extraction narrows to the string arm and a unit value throws the
-    // catchable TypeError at the read, where Node's own member read
-    // throws — tsc only admits the spelling in JS sources.
-    const nullableStringRecv = receiverKind === "union" &&
-        name === "match" &&
-        (() => {
-            const t = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-            if (t?.kind !== "union")
-                return false;
-            const arms = lowerer.unions.get(t.unionId)?.arms ?? [];
-            return arms.some((a) => a.kind === "string") && arms.every((a) => a.kind === "string" || isUnitType(a));
-        })();
-    if ((receiverKind === "string" || nullableStringRecv) && name === "match") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern match: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        let reNode = arg0;
-        while (ts.isParenthesizedExpression(reNode))
-            reNode = reNode.expression;
-        if (ts.isRegularExpressionLiteral(reNode)) {
-            const flags = reNode.text.slice(reNode.text.lastIndexOf("/") + 1);
-            if (flags.includes("g") || flags.includes("y")) {
-                lowerer.unsupported("SC1120", call, "'.match()' with the 'g' or 'y' flag (an every-match array is a different shape — use replaceAll/split, or test() per position)");
-            }
-        }
-        const receiver = nullableStringRecv ? lowerer.lowerExprExpecting(access.expression, STRING) : lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        // RegExpMatchArray | null maps to the string[] | null union by
-        // itself; intern it directly when the checker's spelling doesn't —
-        // or when it maps to something WIDER (an optional-chain call node
-        // types `s?.match(re)` with the chain's `| undefined`; the intrinsic
-        // itself answers string[] | null, and the chain wrapper widens).
-        const exactT = { kind: "union", unionId: lowerer.unions.intern([arrayOf(STRING), { kind: "nullT" }]) };
-        const mapped = lowerer.mapTypeOf(lowerer.typeOf(call));
-        const resultT = mapped && typeEquals(mapped, exactT) ? mapped : exactT;
-        return { kind: "regexIntrinsic", method: "match", receiver, args: [re], type: resultT, loc };
-    }
-    // `s.matchAll(re)` — the every-match iterator drained EAGERLY into a
-    // string[][] (one honest match slice per row — match's rule). Lazy vs
-    // eager is unobservable here: strings are immutable, and the spec
-    // clones the regex at the call, so nothing can perturb the drain. The
-    // eager array IS what the two lowered consumers see anyway (the
-    // immediate [...spread] and the for-of walk); a stored iterator's
-    // .next() fences as an array member like any other. Non-global
-    // regexes throw Node's exact TypeError at runtime, catchably
-    // (replaceAll's stance).
-    if (receiverKind === "string" && name === "matchAll") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern form: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        const receiver = lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        return {
-            kind: "regexIntrinsic",
-            method: "matchAll",
-            receiver,
-            args: [re],
-            type: arrayOf(arrayOf(STRING)),
-            loc,
-        };
-    }
-    // `s.search(re)` — the first match's UTF-16 index, or -1. No g/y fence
-    // (unlike test/match): Symbol.search neither reads nor writes lastIndex
-    // — a fresh exec from position 0, so /g is irrelevant and /y anchors at
-    // 0, exactly Node. Never throws.
-    if (receiverKind === "string" && name === "search") {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null; // string-pattern form: the SC2020 fence
-        if (call.arguments.length !== 1)
-            return null;
-        const receiver = lowerReceiver();
-        const re = lowerer.lowerExpr(arg0);
-        return { kind: "regexIntrinsic", method: "search", receiver, args: [re], type: F64, loc };
-    }
-    if (receiverKind === "string" &&
-        (name === "replace" || name === "replaceAll" || name === "split")) {
-        const arg0 = call.arguments[0];
-        if (!arg0 || lowerer.mapTypeOf(lowerer.typeOf(arg0))?.kind !== "regex")
-            return null;
-        const receiver = lowerReceiver();
-        // Split's omitted or undefined limit is 2^32-1. Complete it here so
-        // both IR backends and the runtime have one required (regex, limit)
-        // shape; an optional-number value selects the default at runtime.
-        const args = name === "split"
-            ? [lowerer.lowerExpr(arg0), lowerSplitLimitArg(lowerer, call.arguments[1], loc)]
-            : call.arguments.map((a) => lowerer.lowerExpr(a));
-        if (name !== "split" && args[1]?.type.kind !== "string") {
-            lowerer.unsupported("SC1120", call.arguments[1] ?? call, "function replacement values (replacements must be string templates)");
-        }
-        return {
-            kind: "regexIntrinsic",
-            method: name,
-            receiver,
-            args,
-            type: name === "split" ? arrayOf(STRING) : STRING,
-            loc,
-        };
-    }
-    return null;
-}
-/** `s.slice(1, 4)` and friends → strIntrinsic. Null when this isn't an
-   * ambient string method call (caller keeps its generic rejection). Missing
-   * optional arguments are omitted from `args` — the backend fills the
-   * documented defaults; the IR never encodes them (Infinity isn't
-   * JSON-safe). tsc has already checked arity and argument types against
-   * ambient/scriptc.d.ts. */
-export function lowerStringMethodCall(lowerer, call, access, dynReceiver) {
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    if (dynReceiver === undefined && access.name.text === "localeCompare")
-        return lowerLocaleCompareCall(lowerer, call, access);
-    const entry = own(STR_METHODS, access.name.text);
-    if (!entry)
-        return null;
-    // A validated dyn receiver (`pkg.name.replace(...)` on a JSON.parse
-    // value) arrives pre-extracted through `dynReceiver`; its checker type
-    // is `any`, so the type/symbol gates don't apply — the dyn value's
-    // methods can only BE the string intrinsics.
-    if (dynReceiver === undefined) {
-        const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-        // `require.main?.filename.startsWith(...)`: the checker types the
-        // receiver `string | undefined` (the chain's short-circuit arm), but
-        // the entry-module fold lowers it to a compile-time STRING — the
-        // suite harness's skip() shape. Everything else keeps the strict
-        // string gate.
-        if (receiverIr?.kind !== "string" && !isRequireMainFilename(lowerer, access.expression))
-            return null;
-        if (!lowerer.isStdlibMember(access))
-            return null;
-    }
-    // The lib declares optional parameters beyond the lowered forms
-    // (includes/startsWith/endsWith take a position); fence the unlowered
-    // arities instead of passing arguments the runtime doesn't take.
-    if (call.arguments.length < entry.minArgs || call.arguments.length > entry.maxArgs) {
-        lowerer.noLowering(`.${access.name.text} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"} on strings`, call);
-    }
-    const receiver = dynReceiver ? dynReceiver() : lowerer.lowerExpr(access.expression);
-    const args = entry.method === "split"
-        ? [lowerer.lowerExpr(call.arguments[0]), lowerSplitLimitArg(lowerer, call.arguments[1], locOf(call))]
-        : call.arguments.map((a) => lowerer.lowerExpr(a));
-    // split's separator must BE a string here (a regex argument was
-    // claimed by lowerRegexMethodCall before this path) — the lib's
-    // `string | RegExp` union has no lowering as a VALUE.
-    if (entry.method === "split" && args[0].type.kind !== "string") {
-        lowerer.unsupported("SC1090", call.arguments[0], `'.split()' on a '${lowerer.fmt(args[0].type)}' separator (pass a string, or a regex literal)`);
-    }
-    // padStart/padEnd with the fill omitted: Node pads with " " — the
-    // same call with the default made explicit.
-    if ((entry.method === "padStart" || entry.method === "padEnd") && args.length === 1) {
-        args.push({ kind: "strLit", value: " ", type: STRING, loc: locOf(call) });
-    }
-    return {
-        kind: "strIntrinsic",
-        method: entry.method,
-        receiver,
-        args,
-        type: entry.result,
-        loc: locOf(call),
-    };
-}
-/** `a.localeCompare(b)` — the one-argument form only (locales/options
-   * select ICU collations that do not exist here). Lowers to an interned
-   * synthetic function returning -1/0/1 by CODE-UNIT order — the same
-   * ordering as the string relational operators — NOT Node's ICU default
-   * collation: a documented divergence (SEMANTICS.md; e.g. Node says
-   * "a" < "B" under ICU while code units say "B" < "a"). For same-case
-   * ASCII the orders agree. Null when the receiver isn't a stdlib string
-   * (caller keeps its generic rejection). */
-function lowerLocaleCompareCall(lowerer, call, access) {
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    if (receiverIr?.kind !== "string")
-        return null;
-    if (!lowerer.isStdlibMember(access))
-        return null;
-    const loc = locOf(call);
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering(`.localeCompare with ${call.arguments.length} arguments`, call, "the locales/options parameters select ICU collations that have no lowering — " +
-            "pass exactly the comparison string");
-    }
-    const receiver = lowerer.lowerExpr(access.expression);
-    const arg = lowerer.lowerExpr(call.arguments[0]);
-    if (arg.type.kind !== "string")
-        lowerer.badType(call.arguments[0], lowerer.typeOf(call.arguments[0]));
-    const key = "localeCompare";
-    let helper = lowerer.arrHofHelpers.get(key);
-    if (!helper) {
-        helper = `%str.localeCompare`;
-        lowerer.arrHofHelpers.set(key, helper);
-        lowerer.liftedFns.push(buildLocaleCompareFn(helper, loc));
-    }
-    return { kind: "call", callee: helper, args: [receiver, arg], type: F64, loc };
-}
-/** `return a < b ? -1 : a > b ? 1 : 0` over the strCmp primitive (the
-   * relational operators' exact machinery — one interned helper, no new IR
-   * or runtime surface). */
-function buildLocaleCompareFn(name, loc) {
-    const cmp = (op) => ({ kind: "strCmp", op, left: varRef("a.0", STRING, loc), right: varRef("b.0", STRING, loc), type: BOOL, loc });
-    const body = [
-        {
-            kind: "return",
-            value: {
-                kind: "ternary",
-                cond: cmp("<"),
-                then: numLit(-1, loc),
-                else_: { kind: "ternary", cond: cmp(">"), then: numLit(1, loc), else_: numLit(0, loc), type: F64, loc },
-                type: F64,
-                loc,
-            },
-            loc,
-        },
-    ];
-    return {
-        name,
-        params: [
-            { localId: "a.0", name: "a", type: STRING },
-            { localId: "b.0", name: "b", type: STRING },
-        ],
-        returnType: F64,
-        locals: [
-            { id: "a.0", name: "a", type: STRING, mutable: true },
-            { id: "b.0", name: "b", type: STRING, mutable: true },
-        ],
-        body,
-        loc,
-    };
-}
-/* ── typed arrays / Buffer ─────────────────────────────────────────────── */
-/** The typed-array constructors with a runtime representation, by lib
- * interface name. The other TypedArray flavors (Int8Array, Float64Array,
- * DataView, ...) fall through to the generic stdlib-constructor fence. */
-const BYTES_CTORS = {
-    Uint8Array: "u8",
-    Uint32Array: "u32",
-    Int32Array: "i32",
-    Float32Array: "f32",
-};
-/** `new Uint8Array(...)` / `new Uint32Array(...)` / `new Float32Array(...)`
-   * (stdlib provenance — a user's own class with the name resolves through
-   * classBySymbol). Lowered argument shapes: none (empty), a length
-   * (zero-filled; ToIndex at runtime — invalid lengths throw Node's
-   * RangeError), a same-kind typed array or Buffer (an independent COPY —
-   * the readFile chain's `new Uint8Array(await readFile(p))`), a number[]
-   * literal (element-coerced; its contextual type is the lib's
-   * ArrayLike/Iterable union, which cannot map — the Set-seed pattern), or
-   * a number[]-typed value. ArrayBuffer/view forms are fenced: scriptc
-   * typed arrays own their storage. Null when this isn't a stdlib
-   * typed-array construction. */
-export function lowerBytesNew(lowerer, expr, symbol) {
-    if (symbol && symbol.name === "DataView" && lowerer.isStdlibSymbol(symbol)) {
-        return lowerDataViewNew(lowerer, expr);
-    }
-    const elem = symbol ? own(BYTES_CTORS, symbol.name) : undefined;
-    if (!elem || !symbol || !lowerer.isStdlibSymbol(symbol))
-        return null;
-    const name = symbol.name;
-    const type = bytesOf(elem);
-    const loc = locOf(expr);
-    const args = expr.arguments ?? [];
-    if (args.length === 0)
-        return { kind: "bytesNew", source: null, type, loc };
-    if (args.length === 1 && !ts.isSpreadElement(args[0])) {
-        const argNode = args[0];
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
-            const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-            return { kind: "bytesNew", source: seed, type, loc };
-        }
-        // The SYNTACTIC `new T(new ArrayBuffer(n))` and `new T(new
-        // SharedArrayBuffer(n))` forms — fresh-buffer construction (the
-        // shared spelling is the Atomics.wait sleep idiom's). The buffer
-        // never exists as a value: n must be a byte-length LITERAL divisible
-        // by the element size (tsc would admit any number; a bad one is
-        // Node's RangeError — rejected at compile time instead of
-        // half-lowering), and the whole expression is a zero-filled typed
-        // array of n/elemSize elements. Erasing the buffer is exact: nothing
-        // else can ever reference it, so neither sharing (scriptc has no
-        // threads) nor aliasing is observable — SEMANTICS.md documents the
-        // stance. The RESIZABLE form (a maxByteLength options bag) fences by
-        // name: resize needs the buffer to exist as a value, and none does.
-        if (ts.isNewExpression(argNode) &&
-            ts.isIdentifier(argNode.expression) &&
-            (argNode.expression.text === "ArrayBuffer" ||
-                argNode.expression.text === "SharedArrayBuffer") &&
-            lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode.expression) ?? undefined)) {
-            const bufCtor = argNode.expression.text;
-            if ((argNode.arguments?.length ?? 0) > 1) {
-                lowerer.noLowering(`new ${name} over a resizable ${bufCtor}`, argNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
-                    "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
-                    "erases into the view): drop the options bag");
-            }
-            const elemSize = elem === "u8" ? 1 : 4;
-            const lenArg = argNode.arguments?.length === 1 ? argNode.arguments[0] : undefined;
-            const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
-            const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-            if (byteLen === null || byteLen % elemSize !== 0 || byteLen < 0) {
-                lowerer.noLowering(`new ${name} over this ${bufCtor}`, argNode, `the byte length must be a number literal divisible by ${elemSize} — new ${name}(new ${bufCtor}(${elemSize}))`);
-            }
-            const count = { kind: "numLit", value: byteLen / elemSize, type: F64, loc };
-            return { kind: "bytesNew", source: count, type, loc };
-        }
-        const src = lowerer.lowerExpr(argNode);
-        if (src.type.kind === "f64" ||
-            typeEquals(src.type, type) ||
-            (src.type.kind === "array" && src.type.elem.kind === "f64")) {
-            return { kind: "bytesNew", source: src, type, loc };
-        }
-        if (src.type.kind === "bytes") {
-            lowerer.noLowering(`new ${name} over a '${lowerer.fmt(src.type)}'`, argNode, "cross-kind typed-array conversion has no lowering — copy element by element");
-        }
-        lowerer.noLowering(`new ${name} over '${lowerer.fmt(src.type)}' values`, argNode, `supported: new ${name}(), (length), (typedArray) — always a copy — or (number[]); ` +
-            "ArrayBuffers and views do not exist here (narrow unions first)");
-    }
-    lowerer.noLowering(`new ${name} with ${args.length} arguments`, expr, `supported: new ${name}(), (length), (typedArray), or (number[])`);
-}
-/** `new DataView(x.buffer, byteOffset?, byteLength?)` (stdlib provenance).
-   * The first argument must be the SYNTACTIC `.buffer` of a typed-array/
-   * Buffer value — `x.buffer` names x's own storage (scriptc typed arrays
-   * always own it whole, byteOffset 0), so the view construction takes x
-   * itself as the receiver and no ArrayBuffer value ever exists.
-   * byteOffset/byteLength are optional f64s (omitted args OMITTED, like
-   * slice); bad indices THROW Node's RangeErrors catchably. The result is
-   * a true borrowed view: reads and writes through it alias x. */
-function lowerDataViewNew(lowerer, expr) {
-    const loc = locOf(expr);
-    const args = expr.arguments ?? [];
-    const bufNode = args[0];
-    if (!bufNode || args.length > 3 || args.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`new DataView with ${args.length} arguments`, expr, "supported: new DataView(x.buffer), (x.buffer, byteOffset), or (x.buffer, byteOffset, byteLength)");
-    }
-    // The FRESH-BUFFER form: `new DataView(new ArrayBuffer(n), ...)` — the
-    // buffer erases into the view (nothing else can ever reference it, so
-    // the aliasing a shared buffer would exhibit is unobservable): the
-    // view's storage is a fresh zero-filled n-byte allocation. n must be a
-    // non-negative integer LITERAL (tsc admits any number; a fractional
-    // one is ToIndex truncation nothing here implements). byteOffset and
-    // byteLength keep their runtime Node-RangeError story. The RESIZABLE
-    // form (a maxByteLength options bag) fences by name.
-    if (ts.isNewExpression(bufNode) &&
-        ts.isIdentifier(bufNode.expression) &&
-        bufNode.expression.text === "ArrayBuffer" &&
-        lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(bufNode.expression) ?? undefined)) {
-        if ((bufNode.arguments?.length ?? 0) > 1) {
-            lowerer.noLowering("new DataView over a resizable ArrayBuffer", bufNode, "a maxByteLength options bag makes the buffer resizable, and resizing needs the buffer " +
-                "to exist as a runtime value — no free-standing ArrayBuffer value exists (the buffer here " +
-                "erases into the view): drop the options bag");
-        }
-        const lenArg = bufNode.arguments?.length === 1 ? bufNode.arguments[0] : undefined;
-        const lenT = lenArg ? lowerer.typeOf(lenArg) : null;
-        const byteLen = lenT?.isNumberLiteralType() ? lenT.value : null;
-        if (byteLen === null || !Number.isInteger(byteLen) || byteLen < 0) {
-            lowerer.noLowering("new DataView over this ArrayBuffer", bufNode, "the byte length must be a non-negative integer literal — new DataView(new ArrayBuffer(8))");
-        }
-        const count = { kind: "numLit", value: byteLen, type: F64, loc };
-        const receiver = { kind: "bytesNew", source: count, type: BYTES_U8, loc };
-        const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-    }
-    const hint = "views compile over a typed array's own storage — new DataView(x.buffer, byteOffset?, byteLength?) " +
-        "where x is a Uint8Array/Uint32Array/Float32Array/Buffer value — or a fresh buffer erased into " +
-        "the view: new DataView(new ArrayBuffer(n), ...); free-standing ArrayBuffers have no representation";
-    if (!ts.isPropertyAccessExpression(bufNode) || bufNode.name.text !== "buffer" || bufNode.questionDotToken) {
-        lowerer.noLowering("new DataView over this buffer expression", bufNode, hint);
-    }
-    const srcIr = lowerer.mapTypeOf(lowerer.typeOf(bufNode.expression));
-    if (srcIr?.kind !== "bytes" || !lowerer.isStdlibMember(bufNode)) {
-        lowerer.noLowering(`new DataView over '.buffer' of a '${lowerer.checker.typeToString(lowerer.typeOf(bufNode.expression))}'`, bufNode, hint);
-    }
-    const receiver = lowerer.lowerExpr(bufNode.expression);
-    const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-    return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-}
-/** Method calls on typed-array/Buffer receivers: slice and subarray (BOTH
-   * copy — subarray's sharing is the documented divergence), set(src,
-   * offset?), and the u8-only Buffer surface: toString(enc?) plus the
-   * whole numeric read/write family (fixed widths BE/LE and the
-   * variable-width read/writeUIntLE quartet — BUF_NUM_METHODS). Everything
-   * else the lib declares (fill, indexOf, reverse, ...) falls through to
-   * the SC2020 member fence. Null when this isn't a bytes method call. */
-export function lowerBytesMethodCall(lowerer, call, access) {
-    if (lowerer.chainBlocked(access, call))
-        return null;
-    const name = access.name.text;
-    const receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-    if (receiverIr?.kind !== "bytes")
-        return null;
-    if (!lowerer.isStdlibMember(access))
-        return null;
-    const loc = locOf(call);
-    const nArgs = call.arguments.length;
-    if (receiverIr.elem === "u8" && name === "toSorted") {
-        return lowerBytesToSortedCall(lowerer, call, access, receiverIr);
-    }
-    if (receiverIr.elem === "u8" && name === "toReversed") {
-        if (nArgs !== 0) {
-            lowerer.noLowering(`.toReversed with ${nArgs} arguments on Uint8Array`, call);
-        }
-        return {
-            kind: "bytesIntrinsic",
-            method: "toReversed",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [],
-            type: receiverIr,
-            loc,
-        };
-    }
-    if (receiverIr.elem === "u8" && name === "with") {
-        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
-        }
-        return {
-            kind: "bytesIntrinsic",
-            method: "with",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [
-                lowerer.lowerExprExpecting(call.arguments[0], F64),
-                lowerer.lowerExprExpecting(call.arguments[1], F64),
-            ],
-            type: receiverIr,
-            loc,
-        };
-    }
-    if (receiverIr.elem === "u8" && name === "join") {
-        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`.join with ${nArgs} arguments on Uint8Array`, call);
-        }
-        const separatorDefault = {
-            kind: "strLit",
-            value: ",",
-            type: STRING,
-            loc,
-        };
-        const separator = call.arguments[0]
-            ? lowerOptionalDefaultArg(lowerer, call.arguments[0], STRING, separatorDefault)
-            : separatorDefault;
-        return {
-            kind: "bytesIntrinsic",
-            method: "join",
-            receiver: lowerer.lowerExpr(access.expression),
-            args: [separator],
-            type: STRING,
-            loc,
-        };
-    }
-    if (name === "slice" || name === "subarray") {
-        if (nArgs > 2) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64));
-        // subarray is a VIEW (TypedArray.prototype.subarray aliases), and
-        // Buffer's slice() is subarray's deprecated Node alias — resolved by
-        // where the member is declared, the toString discipline below. Only
-        // the plain typed arrays' slice() copies (JS-exact).
-        const declaredOnBuffer = name === "slice" &&
-            (() => {
-                const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-                return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-            })();
-        const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
-        return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
-    }
-    if (name === "fill" && receiverIr.elem !== "u8") {
-        // TypedArray.prototype.fill on the non-u8 kinds: per-element value
-        // coercion, slice-clamped relative indices, never throws. u8
-        // receivers keep the Buffer fill family (string patterns, throwing
-        // offset validation) — lowerBufferInstanceMethod's surface.
-        if (nArgs < 1 || nArgs > 3) {
-            lowerer.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const v = lowerer.lowerExprExpecting(call.arguments[0], F64);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
-    }
-    if (name === "set") {
-        if (nArgs < 1 || nArgs > 2) {
-            lowerer.noLowering(`.set with ${nArgs} arguments on typed arrays`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const src = lowerer.lowerExpr(call.arguments[0]);
-        if (!typeEquals(src.type, receiverIr)) {
-            lowerer.noLowering(`.set from '${lowerer.fmt(src.type)}' values`, call.arguments[0], "only a same-kind typed array copies in (number[] sources have no lowering — narrow unions first)");
-        }
-        const args = [src];
-        if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], F64));
-        return { kind: "bytesIntrinsic", method: "setFrom", receiver, args, type: VOID, loc };
-    }
-    if (name === "toString") {
-        // Buffer's toString(encoding?) — utf8 by default. A 0-arg toString
-        // resolved against the plain Uint8Array interface is JS's
-        // Array-toString (comma join), a different operation: fenced.
-        const declaredOnBuffer = (() => {
-            const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-            return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-        })();
-        if (receiverIr.elem !== "u8" || !declaredOnBuffer) {
-            lowerer.noLowering("typed-array toString", call, 'Buffer.from(x).toString("utf8" | "hex" | "base64") is the lowered string conversion');
-        }
-        if (nArgs > 3)
-            lowerer.noLowering(`.toString with ${nArgs} arguments on Buffers`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
-        const encNode = call.arguments[0];
-        let method = "toString";
-        let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
-        if (encNode) {
-            const encType = lowerer.typeOf(encNode);
-            const encName = encType.isStringLiteralType()
-                ? knownBufEncoding(encType.value)
-                : undefined;
-            if (encName !== undefined) {
-                // Keep literals on the canonical, non-throwing fast path.
-                enc = { kind: "strLit", value: encName, type: STRING, loc };
-            }
-            else {
-                const undefinedArg = lowerStaticallyUndefinedArg(lowerer, encNode);
-                if (undefinedArg) {
-                    // An explicit undefined is the omitted-encoding default. Keep
-                    // the canonical, non-throwing path while preserving effects
-                    // from equivalent spellings such as `void sideEffect()`.
-                    enc = defaultAfterUndefined(undefinedArg, enc);
-                }
-                else {
-                    // A BufferEncoding-typed variable selects its decoder at
-                    // runtime. Optional variables default their undefined arm to
-                    // utf8; the checked intrinsic canonicalizes every present
-                    // alias/case and raises Node's ERR_UNKNOWN_ENCODING when a cast
-                    // lets a bad value through.
-                    enc = lowerOptionalDefaultArg(lowerer, encNode, STRING, enc);
-                    method = "toStringVar";
-                }
-            }
-        }
-        // The range form toString(enc, start[, end]) decodes the clamped
-        // [start, end) byte window (Node's slice-then-decode). An omitted
-        // end stays omitted (2 intrinsic args) — the emitter supplies the
-        // receiver's length, because EXPLICIT negative ends clamp to empty
-        // in Node and no in-band sentinel can represent "omitted" safely.
-        if (nArgs > 1) {
-            const start = lowerer.lowerExprExpecting(call.arguments[1], F64);
-            if (nArgs === 3) {
-                const end = lowerer.lowerExprExpecting(call.arguments[2], F64);
-                return { kind: "bytesIntrinsic", method, receiver, args: [enc, start, end], type: STRING, loc };
-            }
-            return { kind: "bytesIntrinsic", method, receiver, args: [enc, start], type: STRING, loc };
-        }
-        return { kind: "bytesIntrinsic", method, receiver, args: [enc], type: STRING, loc };
-    }
-    // The Buffer-declared comparison/search/mutation surface. All of
-    // these resolve against the Buffer interface (the checker keeps most
-    // off plain typed arrays; where the lib DOES declare a same-named
-    // TypedArray member — indexOf, includes, fill — the semantics differ,
-    // so only Buffer-declared resolutions lower and u8 receivers gate the
-    // rest).
-    const declOnBuffer = (() => {
-        const nameSym = lowerer.checker.getSymbolAtLocation(access.name);
-        return nameSym !== undefined && lowerer.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
-    })();
-    if (declOnBuffer && receiverIr.elem === "u8") {
-        const bufMethod = lowerBufferInstanceMethod(lowerer, call, access, name, loc);
-        if (bufMethod)
-            return bufMethod;
-    }
-    // The Buffer numeric read/write families — every fixed-width kind in
-    // both endiannesses ("Uint" and "UInt" alike: Node aliases both), plus
-    // the variable-width read/writeUIntLE quartet. The kind token rides as
-    // a strLit args[0]; omitted offsets complete to Node's default 0.
-    const numKind = own(BUF_NUM_METHODS, name);
-    if (numKind !== undefined) {
-        if (receiverIr.elem !== "u8") {
-            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
-        }
-        const write = name.startsWith("write");
-        const required = write ? 1 : 0; // value; offset defaults to 0
-        if (nArgs < required || nArgs > required + 1) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const kind = { kind: "strLit", value: numKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
-        if (nArgs === required) {
-            args.push({ kind: "numLit", value: 0, type: F64, loc }); // Node's offset default
-        }
-        return { kind: "bytesIntrinsic", method: write ? "writeNum" : "readNum", receiver, args, type: F64, loc };
-    }
-    const varKind = own(BUF_NUM_VAR_METHODS, name);
-    if (varKind !== undefined) {
-        if (receiverIr.elem !== "u8") {
-            lowerer.noLowering(`.${name} on a '${lowerer.fmt(receiverIr)}'`, call, "the numeric families read/write Buffer bytes");
-        }
-        const write = name.startsWith("write");
-        const required = write ? 3 : 2; // Node declares offset AND byteLength required
-        if (nArgs !== required) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const kind = { kind: "strLit", value: varKind, type: STRING, loc };
-        const args = [kind, ...call.arguments.map((a) => lowerer.lowerExprExpecting(a, F64))];
-        return { kind: "bytesIntrinsic", method: write ? "writeNumVar" : "readNumVar", receiver, args, type: F64, loc };
-    }
-    // DataView getters (DataView maps to bytes<u8>, so the receiver kind
-    // and stdlib provenance land here; the checker keeps these names off
-    // typed arrays and Buffers). The multi-byte kinds take the optional
-    // littleEndian bool (omitted = big-endian, the JS default). All THROW
-    // Node's RangeError on a bad offset (may-throw seeds).
-    const dvGetter = own(DV_GETTERS, name);
-    if (dvGetter !== undefined && receiverIr.elem === "u8") {
-        if (dvGetter.method === "dvGetBigUint64Number" || dvGetter.method === "dvGetBigInt64Number") {
-            // bigint values have no representation — only the COMPOSED
-            // `Number(view.getBigUint64/getBigInt64(...))` compiles (the
-            // randomBytesToString pattern): the 8-byte integer converts to
-            // double exactly as Number(bigint) would, and the bigint never
-            // exists as a value (the f64-typed intrinsic result IS what the
-            // identity Number(f64) lowering hands back).
-            const p = call.parent;
-            const composed = ts.isCallExpression(p) &&
-                p.arguments.length === 1 &&
-                p.arguments[0] === call &&
-                ts.isIdentifier(p.expression) &&
-                p.expression.text === "Number" &&
-                lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(p.expression) ?? undefined);
-            if (!composed) {
-                lowerer.noLowering(`.${name} outside Number(...)`, call, `bigint values have no representation — Number(view.${name}(offset, littleEndian?)) is the lowered form`);
-            }
-        }
-        const maxArgs = dvGetter.le ? 2 : 1;
-        if (nArgs < 1 || nArgs > maxArgs) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = [lowerer.lowerExprExpecting(call.arguments[0], F64)];
-        if (nArgs === 2)
-            args.push(lowerer.lowerExprExpecting(call.arguments[1], BOOL));
-        return { kind: "bytesIntrinsic", method: dvGetter.method, receiver, args, type: F64, loc };
-    }
-    // DataView setters — the getters' mirror: (byteOffset, value) plus the
-    // optional littleEndian bool on the multi-byte kinds. Void results;
-    // the same constant Node RangeError on a bad offset (may-throw seeds).
-    // setBigUint64/setBigInt64 never lower (bigint ARGUMENTS have no
-    // representation and no composed form exists) — they keep the member
-    // fence, as does setFloat16.
-    const dvSetter = own(DV_SETTERS, name);
-    if (dvSetter !== undefined && receiverIr.elem === "u8") {
-        const maxArgs = dvSetter.le ? 3 : 2;
-        if (nArgs < 2 || nArgs > maxArgs) {
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        }
-        const receiver = lowerer.lowerExpr(access.expression);
-        const args = [
-            lowerer.lowerExprExpecting(call.arguments[0], F64),
-            lowerer.lowerExprExpecting(call.arguments[1], F64),
-        ];
-        if (nArgs === 3)
-            args.push(lowerer.lowerExprExpecting(call.arguments[2], BOOL));
-        return { kind: "bytesIntrinsic", method: dvSetter.method, receiver, args, type: VOID, loc };
-    }
-    return null;
-}
-/** Node's Buffer encoding names → the runtime's canonical spelling (every
- * alias folds at compile time; the runtime sees only canonical names).
- * Shared by toString, Buffer.from, and Buffer.byteLength. */
-const BUF_ENCODINGS = {
-    utf8: "utf8",
-    "utf-8": "utf8",
-    hex: "hex",
-    base64: "base64",
-    base64url: "base64url",
-    latin1: "latin1",
-    binary: "latin1",
-    ascii: "ascii",
-    utf16le: "utf16le",
-    "utf-16le": "utf16le",
-    ucs2: "utf16le",
-    "ucs-2": "utf16le",
-};
-/** A literal encoding's canonical name, or undefined for a spelling Node
- * does not know — the ladder callers (stream options) turn unknown
- * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
-export function knownBufEncoding(name) {
-    return own(BUF_ENCODINGS, name);
-}
-/** The literal encoding argument of a Buffer surface, normalized — or a
- * fence when it isn't a literal alias Node knows. */
-export function bufEncoding(lowerer, what, encNode) {
-    const t = lowerer.typeOf(encNode);
-    const v = t.isStringLiteralType() ? own(BUF_ENCODINGS, t.value) : undefined;
-    if (v === undefined) {
-        lowerer.noLowering(`${what} with this encoding`, encNode, 'a literal "utf8", "hex", "base64", "base64url", "latin1", "binary", "ascii", "utf16le", or "ucs2" spelling is the lowered encoding surface');
-    }
-    return v;
-}
-/** The fixed-width Buffer numeric methods by source name → the readNum/
- * writeNum kind token. Node declares BOTH capitalizations ("UInt" is the
- * original, "Uint" the aliased spelling) — the tables carry both. */
-const BUF_NUM_METHODS = (() => {
-    const out = {};
-    for (const rw of ["read", "write"]) {
-        for (const u of ["UInt", "Uint"]) {
-            out[`${rw}${u}8`] = "u8";
-            out[`${rw}${u}16BE`] = "u16be";
-            out[`${rw}${u}16LE`] = "u16le";
-            out[`${rw}${u}32BE`] = "u32be";
-            out[`${rw}${u}32LE`] = "u32le";
-        }
-        out[`${rw}Int8`] = "i8";
-        out[`${rw}Int16BE`] = "i16be";
-        out[`${rw}Int16LE`] = "i16le";
-        out[`${rw}Int32BE`] = "i32be";
-        out[`${rw}Int32LE`] = "i32le";
-        out[`${rw}FloatBE`] = "f32be";
-        out[`${rw}FloatLE`] = "f32le";
-        out[`${rw}DoubleBE`] = "f64be";
-        out[`${rw}DoubleLE`] = "f64le";
-    }
-    return out;
-})();
-/** The variable-width quartet (offset + byteLength) → sign/endian token. */
-const BUF_NUM_VAR_METHODS = {
-    readUIntBE: "ube",
-    readUintBE: "ube",
-    readUIntLE: "ule",
-    readUintLE: "ule",
-    readIntBE: "ibe",
-    readIntLE: "ile",
-    writeUIntBE: "ube",
-    writeUintBE: "ube",
-    writeUIntLE: "ule",
-    writeUintLE: "ule",
-    writeIntBE: "ibe",
-    writeIntLE: "ile",
-};
-/** The Buffer-declared comparison/search/mutation methods on a u8
- * receiver: equals, compare, indexOf/lastIndexOf/includes (number,
- * string-with-encoding, and Buffer needles), fill, copy, swap16/32/64,
- * and write. Null when `name` isn't one of them (the numeric families
- * and the generic bytes surface try next). Encodings must be literals
- * (bufEncoding's fence); a trailing string-typed argument is the
- * encoding, exactly Node's overloads. */
-function lowerBufferInstanceMethod(lowerer, call, access, name, loc) {
-    const args = call.arguments;
-    const nArgs = args.length;
-    if (args.some(ts.isSpreadElement))
-        return null;
-    const isStringArg = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]))?.kind === "string";
-    const u8Arg = (i) => {
-        const v = lowerer.lowerExpr(args[i]);
-        if (!(v.type.kind === "bytes" && v.type.elem === "u8")) {
-            lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
-        }
-        return v;
-    };
-    // The checked-dynamic crossing for a compare/equals argument slot: dyn
-    // passes through, convertible statics (the invalid-input probes'
-    // literals) wrap in dynFrom, `undefined` literals ride the same wrap.
-    // Fences (never returns) when the value cannot cross — an island jsval.
-    const chkArg = (i) => {
-        // Object literals take the dyn literal path directly (method members
-        // box as dyn functions — the typed record fence never applies).
-        if (ts.isObjectLiteralExpression(args[i])) {
-            return lowerDynObjectLiteral(lowerer, args[i]);
-        }
-        const v = lowerer.lowerExpr(args[i]);
-        if (v.type.kind === "dyn")
-            return v;
-        if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
-            return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
-        }
-        lowerer.noLowering(`.${name} of '${lowerer.fmt(v.type)}' values`, args[i], "a Buffer/Uint8Array argument is the lowered shape (narrow unions first)");
-    };
-    const argIrKind = (i) => lowerer.mapTypeOf(lowerer.typeOf(args[i]));
-    if (name === "equals") {
-        if (nArgs !== 1)
-            lowerer.noLowering(`.equals with ${nArgs} arguments`, call);
-        if (argIrKind(0)?.kind === "bytes") {
-            const other = u8Arg(0);
-            const receiver = lowerer.lowerExpr(access.expression);
-            return { kind: "bytesIntrinsic", method: "equals", receiver, args: [other], type: BOOL, loc };
-        }
-        // Not statically bytes (the invalid-input probes, untyped JS
-        // helpers): Node's "otherBuffer" argument ladder runs at runtime.
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "libCall", fn: "bytes.equalsChk", args: [receiver, chkArg(0)], type: BOOL, loc };
-    }
-    if (name === "compare") {
-        if (nArgs > 5)
-            lowerer.noLowering(`.compare with ${nArgs} arguments`, call);
-        const fast = nArgs >= 1 &&
-            argIrKind(0)?.kind === "bytes" &&
-            call.arguments.slice(1).every((a) => lowerer.mapTypeOf(lowerer.typeOf(a))?.kind === "f64");
-        if (fast) {
-            const target = u8Arg(0);
-            const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-            const receiver = lowerer.lowerExpr(access.expression);
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver, args: [target, ...idx], type: F64, loc };
-        }
-        // An absent/ill-typed target or offset (`a.compare()`, string
-        // offsets, explicit undefined): Node's target/targetStart/targetEnd/
-        // sourceStart/sourceEnd ladder runs at runtime; absent slots pass
-        // the undefined dyn (Node defaults apply there).
-        const receiver = lowerer.lowerExpr(access.expression);
-        const slots = [];
-        for (let i = 0; i < 5; i++)
-            slots.push(i < nArgs ? chkArg(i) : dynUndefinedExpr(loc));
-        return { kind: "libCall", fn: "bytes.compareChk", args: [receiver, ...slots], type: F64, loc };
-    }
-    if (name === "indexOf" || name === "lastIndexOf" || name === "includes") {
-        if (nArgs < 1 || nArgs > 3)
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        // The overloads: (v), (v, byteOffset), (v, encoding), (v, byteOffset,
-        // encoding) — a trailing string-typed arg is the encoding.
-        let encName = "utf8";
-        let offNode;
-        if (nArgs === 3) {
-            offNode = args[1];
-            encName = bufEncoding(lowerer, `.${name}`, args[2]);
-        }
-        else if (nArgs === 2) {
-            if (isStringArg(1))
-                encName = bufEncoding(lowerer, `.${name}`, args[1]);
-            else
-                offNode = args[1];
-        }
-        const resultT = name === "includes" ? BOOL : F64;
-        const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (vT?.kind === "f64") {
-            // A number needle wraps & 0xFF at runtime (Buffer semantics; the
-            // encoding is irrelevant, like Node).
-            const v = lowerer.lowerExprExpecting(args[0], F64);
-            const numArgs = [v, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
-            const method = name === "indexOf" ? "indexOfNum" : name === "lastIndexOf" ? "lastIndexOfNum" : "includesNum";
-            return { kind: "bytesIntrinsic", method, receiver, args: numArgs, type: resultT, loc };
-        }
-        let needle;
-        let align = 1;
-        if (vT?.kind === "string") {
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            needle = { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
-            if (encName === "utf16le")
-                align = 2;
-        }
-        else if (vT?.kind === "bytes" && vT.elem === "u8") {
-            needle = lowerer.lowerExpr(args[0]);
-        }
-        else {
-            lowerer.noLowering(`.${name} of '${lowerer.checker.typeToString(lowerer.typeOf(args[0]))}' values`, args[0], "string, number, and Buffer/Uint8Array needles search (narrow unions first)");
-        }
-        const alignLit = { kind: "numLit", value: align, type: F64, loc };
-        const searchArgs = [needle, alignLit, ...(offNode ? [lowerer.lowerExprExpecting(offNode, F64)] : [])];
-        return { kind: "bytesIntrinsic", method: name, receiver, args: searchArgs, type: resultT, loc };
-    }
-    if (name === "fill") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
-        // A trailing string-typed arg past the value is the encoding.
-        let encNode;
-        let idxNodes = call.arguments.slice(1);
-        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
-            encNode = idxNodes[idxNodes.length - 1];
-            idxNodes = idxNodes.slice(0, -1);
-        }
-        if (idxNodes.length > 2)
-            lowerer.noLowering(`.fill with ${nArgs} arguments`, call);
-        const idx = idxNodes.map((a) => lowerer.lowerExprExpecting(a, F64));
-        const receiverT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
-        if (receiverT?.kind !== "bytes")
-            lowerer.badType(access.expression, lowerer.typeOf(access.expression));
-        const vT = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-        const receiver = lowerer.lowerExpr(access.expression);
-        if (vT?.kind === "string") {
-            const encName = encNode ? bufEncoding(lowerer, ".fill", encNode) : "utf8";
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver, args: [s, enc, ...idx], type: BYTES_U8, loc };
-        }
-        if (encNode)
-            lowerer.noLowering(".fill with an encoding on a non-string value", encNode);
-        if (vT?.kind === "f64") {
-            const v = lowerer.lowerExprExpecting(args[0], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver, args: [v, ...idx], type: BYTES_U8, loc };
-        }
-        const pattern = u8Arg(0);
-        return { kind: "bytesIntrinsic", method: "fill", receiver, args: [pattern, ...idx], type: BYTES_U8, loc };
-    }
-    if (name === "copy") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.copy with ${nArgs} arguments`, call);
-        const target = u8Arg(0);
-        const idx = call.arguments.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "copy", receiver, args: [target, ...idx], type: F64, loc };
-    }
-    if (name === "swap16" || name === "swap32" || name === "swap64") {
-        if (nArgs !== 0)
-            lowerer.noLowering(`.${name} with ${nArgs} arguments`, call);
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: name, receiver, args: [], type: BYTES_U8, loc };
-    }
-    if (name === "write") {
-        if (nArgs < 1 || nArgs > 4)
-            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
-        // (str), (str, enc), (str, offset), (str, offset, enc),
-        // (str, offset, length), (str, offset, length, enc).
-        let encNode;
-        let idxNodes = call.arguments.slice(1);
-        if (idxNodes.length > 0 && isStringArg(nArgs - 1)) {
-            encNode = idxNodes[idxNodes.length - 1];
-            idxNodes = idxNodes.slice(0, -1);
-        }
-        if (idxNodes.length > 2)
-            lowerer.noLowering(`.write with ${nArgs} arguments`, call);
-        const encName = encNode ? bufEncoding(lowerer, "Buffer.write", encNode) : "utf8";
-        const s = lowerer.lowerExprExpecting(args[0], STRING);
-        const enc = { kind: "strLit", value: encName, type: STRING, loc };
-        const offset = idxNodes[0]
-            ? lowerer.lowerExprExpecting(idxNodes[0], F64)
-            : { kind: "numLit", value: 0, type: F64, loc };
-        const writeArgs = [s, enc, offset, ...(idxNodes[1] ? [lowerer.lowerExprExpecting(idxNodes[1], F64)] : [])];
-        const receiver = lowerer.lowerExpr(access.expression);
-        return { kind: "bytesIntrinsic", method: "writeStr", receiver, args: writeArgs, type: F64, loc };
-    }
-    return null;
-}
-/** The DataView getter surface by source name. `le` marks the multi-byte
- * kinds whose lib signature declares the optional littleEndian parameter
- * (the 8-bit getters take none). The Big pair only compiles composed
- * inside Number(...) — see the use site. */
-const DV_GETTERS = {
-    getUint8: { method: "dvGetUint8", le: false },
-    getInt8: { method: "dvGetInt8", le: false },
-    getUint16: { method: "dvGetUint16", le: true },
-    getInt16: { method: "dvGetInt16", le: true },
-    getUint32: { method: "dvGetUint32", le: true },
-    getInt32: { method: "dvGetInt32", le: true },
-    getFloat32: { method: "dvGetFloat32", le: true },
-    getFloat64: { method: "dvGetFloat64", le: true },
-    getBigUint64: { method: "dvGetBigUint64Number", le: true },
-    getBigInt64: { method: "dvGetBigInt64Number", le: true },
-};
-const DV_SETTERS = {
-    setUint8: { method: "dvSetUint8", le: false },
-    setInt8: { method: "dvSetInt8", le: false },
-    setUint16: { method: "dvSetUint16", le: true },
-    setInt16: { method: "dvSetInt16", le: true },
-    setUint32: { method: "dvSetUint32", le: true },
-    setInt32: { method: "dvSetInt32", le: true },
-    setFloat32: { method: "dvSetFloat32", le: true },
-    setFloat64: { method: "dvSetFloat64", le: true },
-};
-/** The Buffer statics — `Buffer.from(...)`, `Buffer.alloc(n)`,
-   * `Buffer.concat(list)`, `Buffer.isBuffer(x)` — on THE stdlib Buffer
-   * global (name + provenance; fallback and @types/node alike). Null when
-   * the callee isn't a Buffer-static access. */
-export function lowerBufferStaticCall(lowerer, call, access) {
-    if (call.questionDotToken || access.questionDotToken)
-        return null;
-    if (!lowerer.isStdlibGlobal(access.expression, "Buffer"))
-        return null;
-    const member = access.name.text;
-    const loc = locOf(call);
-    const args = call.arguments;
-    if (member === "from") {
-        // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
-        // x's storage (Node shares the ArrayBuffer; length is in BYTES).
-        // The first argument must be the SYNTACTIC `.buffer` of a typed
-        // array — the DataView peel — and the construction rides the same
-        // dataViewNew intrinsic (offset/length validation throws Node's
-        // DataView-shaped RangeErrors; valid indices behave exactly).
-        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
-            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
-            const srcNode = args[0].expression;
-            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(srcNode));
-            if (srcIr?.kind === "bytes") {
-                const receiver = lowerer.lowerExpr(srcNode);
-                const idxArgs = args.slice(1).map((a) => lowerer.lowerExprExpecting(a, F64));
-                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
-            }
-        }
-        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
-            const argNode = args[0];
-            if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-                // A number[] literal (contextually typed by the lib's readonly
-                // number[] slot — build it element-wise, the Set-seed pattern).
-                if (args.length === 1) {
-                    const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, F64));
-                    const seed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
-                    return { kind: "bytesNew", source: seed, type: BYTES_U8, loc };
-                }
-            }
-            else {
-                const srcIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
-                if (srcIr?.kind === "string") {
-                    const encNode = args[1];
-                    const encName = encNode ? bufEncoding(lowerer, "Buffer.from", encNode) : "utf8";
-                    const s = lowerer.lowerExprExpecting(argNode, STRING);
-                    const enc = { kind: "strLit", value: encName, type: STRING, loc };
-                    return { kind: "libCall", fn: "buffer.fromStr", args: [s, enc], type: BYTES_U8, loc };
-                }
-                if (args.length === 1 && srcIr?.kind === "bytes" && srcIr.elem === "u8") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
-                }
-                if (args.length === 1 && srcIr?.kind === "array" && srcIr.elem.kind === "f64") {
-                    return { kind: "bytesNew", source: lowerer.lowerExpr(argNode), type: BYTES_U8, loc };
-                }
-            }
-        }
-        lowerer.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
-            "Buffer.from(number[]), or Buffer.from(x.buffer, byteOffset?, length?) — a view sharing x's " +
-            "storage (no free-standing ArrayBuffer value exists; narrow unions first)");
-    }
-    if (member === "alloc" || member === "allocUnsafe") {
-        const maxArgs = member === "alloc" ? 3 : 1;
-        if (args.length < 1 || args.length > maxArgs || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.${member} with ${args.length} arguments`, call);
-        }
-        // allocUnsafe's contents are UNSPECIFIED in Node (uninitialized pool
-        // memory); a zero-filled buffer is a valid instance of unspecified,
-        // and the deterministic choice — a program observing the difference
-        // is depending on garbage.
-        const size = lowerer.lowerExprExpecting(args[0], F64);
-        const fresh = { kind: "bytesNew", source: size, type: BYTES_U8, loc };
-        if (args.length === 1)
-            return fresh;
-        // alloc(size, fill, encoding?): the fill semantics ARE fill()'s —
-        // the fresh buffer is the receiver of a whole-range fill.
-        const fillT = lowerer.mapTypeOf(lowerer.typeOf(args[1]));
-        if (fillT?.kind === "string") {
-            const encName = args[2] ? bufEncoding(lowerer, "Buffer.alloc", args[2]) : "utf8";
-            const s = lowerer.lowerExprExpecting(args[1], STRING);
-            const enc = { kind: "strLit", value: encName, type: STRING, loc };
-            return { kind: "bytesIntrinsic", method: "fillStr", receiver: fresh, args: [s, enc], type: BYTES_U8, loc };
-        }
-        if (args.length > 2) {
-            lowerer.noLowering("Buffer.alloc with an encoding on a non-string fill", args[2]);
-        }
-        if (fillT?.kind === "f64") {
-            const v = lowerer.lowerExprExpecting(args[1], F64);
-            return { kind: "bytesIntrinsic", method: "fillNum", receiver: fresh, args: [v], type: BYTES_U8, loc };
-        }
-        if (fillT?.kind === "bytes" && fillT.elem === "u8") {
-            const pattern = lowerer.lowerExpr(args[1]);
-            return { kind: "bytesIntrinsic", method: "fill", receiver: fresh, args: [pattern], type: BYTES_U8, loc };
-        }
-        lowerer.noLowering(`Buffer.alloc with a '${lowerer.checker.typeToString(lowerer.typeOf(args[1]))}' fill`, args[1], "number, string, and Buffer/Uint8Array fills are the lowered shapes");
-    }
-    if (member === "concat") {
-        if (args.length < 1 || args.length > 2 || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.concat with ${args.length} arguments`, call);
-        }
-        const argNode = args[0];
-        let list;
-        if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
-            const elems = argNode.elements.map((el) => lowerer.lowerExprExpecting(el, BYTES_U8));
-            list = { kind: "arrayLit", elems, type: arrayOf(BYTES_U8), loc };
-        }
-        else {
-            list = lowerer.lowerExpr(argNode);
-            if (!typeEquals(list.type, arrayOf(BYTES_U8))) {
-                lowerer.noLowering(`Buffer.concat of '${lowerer.fmt(list.type)}' values`, argNode, "one Uint8Array[]/Buffer[] value (or literal) is the lowered list shape");
-            }
-        }
-        if (args.length === 2) {
-            // The totalLength form truncates or zero-pads (and THROWS Node's
-            // 'length' RangeError on bad totals).
-            const total = lowerer.lowerExprExpecting(args[1], F64);
-            return { kind: "libCall", fn: "buffer.concatLen", args: [list, total], type: BYTES_U8, loc };
-        }
-        return { kind: "libCall", fn: "buffer.concat", args: [list], type: BYTES_U8, loc };
-    }
-    if (member === "compare") {
-        // The static form: Buffer.compare(a, b) IS a.compare(b).
-        if (args.length !== 2 || args.some(ts.isSpreadElement)) {
-            lowerer.noLowering(`Buffer.compare with ${args.length} arguments`, call);
-        }
-        const sides = args.map((a) => lowerer.lowerExpr(a));
-        if (sides.every((v) => v.type.kind === "bytes" && v.type.elem === "u8")) {
-            return { kind: "bytesIntrinsic", method: "compareBuf", receiver: sides[0], args: [sides[1]], type: F64, loc };
-        }
-        // A side that is not statically bytes (the invalid-input probes,
-        // untyped JS helpers): Node's "buf1"/"buf2" argument ladder runs
-        // at runtime — a well-typed dyn still compares.
-        const dyns = sides.map((v, i) => {
-            if (v.type.kind === "dyn")
-                return v;
-            if (v.kind === "unitLit" || lowerer.dynConvertible(v.type)) {
-                return { kind: "dynFrom", value: v, type: DYN, loc: v.loc };
-            }
-            lowerer.noLowering(`Buffer.compare of '${lowerer.fmt(v.type)}' values`, args[i], "Buffer/Uint8Array values compare (narrow unions first)");
-        });
-        return { kind: "libCall", fn: "buffer.compareChk", args: dyns, type: F64, loc };
-    }
-    if (member === "isBuffer") {
-        // The type-predicate narrowing test. Lowered where it DECIDES
-        // something: a union-typed argument with a Buffer arm becomes a
-        // runtime tag test (tsc's narrowing then types the branches, the
-        // discriminated-union machinery). Statically-decided arguments are
-        // fenced — the answer is a constant, and the operand's evaluation
-        // would have to be discarded.
-        if (args.length === 1 && !ts.isSpreadElement(args[0])) {
-            const v = lowerer.lowerExpr(args[0]);
-            if (v.type.kind === "union") {
-                const def = lowerer.unions.get(v.type.unionId);
-                const tag = def ? def.arms.findIndex((a) => a.kind === "bytes" && a.elem === "u8") : -1;
-                if (tag >= 0) {
-                    return { kind: "unionIsTag", unionId: v.type.unionId, tag, negated: false, value: v, type: BOOL, loc };
-                }
-            }
-            lowerer.noLowering(`Buffer.isBuffer of '${lowerer.fmt(v.type)}' values`, args[0], "the check lowers as a runtime tag test on unions with a Buffer arm — here the answer is static");
-        }
-        lowerer.noLowering("Buffer.isBuffer with this argument shape", call);
-    }
-    if (member === "byteLength") {
-        // Buffer.byteLength(string, enc?) — the UTF-16-aware per-encoding
-        // count — or of a typed array/Buffer (its byte length, a property
-        // read at heart).
-        if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
-            const srcIr = lowerer.mapTypeOf(lowerer.typeOf(args[0]));
-            if (srcIr?.kind === "string") {
-                const encName = args[1] ? bufEncoding(lowerer, "Buffer.byteLength", args[1]) : "utf8";
-                const s = lowerer.lowerExprExpecting(args[0], STRING);
-                const enc = { kind: "strLit", value: encName, type: STRING, loc };
-                return { kind: "libCall", fn: "buffer.byteLenStr", args: [s, enc], type: F64, loc };
-            }
-            if (srcIr?.kind === "bytes" && args.length === 1) {
-                const receiver = lowerer.lowerExpr(args[0]);
-                return { kind: "bytesIntrinsic", method: "byteLength", receiver, args: [], type: F64, loc };
-            }
-        }
-        lowerer.noLowering("Buffer.byteLength with this argument shape", call, "supported: Buffer.byteLength(string, literalEncoding?) or Buffer.byteLength(typedArray)");
-    }
-    if (member === "isEncoding") {
-        // The runtime alias-set test — a plain bool over any string value
-        // (Node's case-insensitive normalizeEncoding check).
-        if (args.length === 1 && !ts.isSpreadElement(args[0]) && lowerer.mapTypeOf(lowerer.typeOf(args[0]))?.kind === "string") {
-            const s = lowerer.lowerExprExpecting(args[0], STRING);
-            return { kind: "libCall", fn: "buffer.isEncoding", args: [s], type: BOOL, loc };
-        }
-        lowerer.noLowering("Buffer.isEncoding with this argument shape", call, "one string-typed argument is the lowered form");
-    }
-    return null; // of, copyBytesFrom, ... → the SC2020 member fence
-}
 /** `Object.keys/values/entries` over an INDEX-SIGNATURE (overflow-carrying)
    * record shape: declared fields answer first from the compile-time field
    * list (declaration order, undefined-valued fields skipped — exactly the