@scriptc/compiler 0.1.3 → 0.1.5

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

@@ -19,20 +19,18 @@ export declare function lowerArrayMethodCall(lowerer: Lowerer, call: ts.CallExpr
    * parameter type). Null when this isn't a tuple slice/map — writers and
    * the rest of the surface keep their fences. */
 export declare function lowerTupleReadMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** An OOB-SAFE indexed read: `xs[i]`
-   * answers the interned `elem | undefined` union — the element when `i`
-   * is an integer in [0, len), JS's property-miss undefined otherwise —
-   * instead of the trap divergence 4 documents for program code.
-   * Package JS is inference-typed, guard-style code (`registeredArguments
-   * .slice(-1)[0]`, commander's last-element probe), and the trap would
-   * fire on working Node idioms; program files keep the documented trap
-   * (their annotations can prove bounds). Existing element unions retag
-   * into the canonical union with an added undefined arm. */
+/** An ordinary indexed read: values retain their element type, while
+ * holes, missing properties, and present undefined yield undefined. */
 export declare function lowerSafeIndexRead(lowerer: Lowerer, arr: IrExpr & {
     type: {
         kind: "array";
     };
 }, index: IrExpr, loc: SrcLoc): IrExpr | null;
+/** Fuse only our own f64-array read helper with immediate ToNumber.
+ * Reuse its arguments verbatim so the receiver and index still evaluate
+ * exactly once, in order, before the read. Do not specialize user calls,
+ * union-element arrays, or optional values stored in locals. */
+export declare function tryLowerNumericIndexRead(lowerer: Lowerer, operand: IrExpr, loc: SrcLoc): IrExpr | null;
 /** Backward-compatible name for the npm-static probe path. */
 export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
 /** `Array.from({ length: n }, mapfn)` — the counted-generation idiom — on

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

@@ -15,7 +15,7 @@ import { buildArraySortFn } from "./lower-array-sort.js";
 import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent } from "./array-values.js";
 import { typeKey } from "../type-mapper.js";
 import { boolLit, countedFor, numLit, varRef } from "../../ir/build.js";
-import { lowerOptionalArgument } from "./optional-arguments.js";
+import { lowerOptionalArgument, lowerPositionArgument, positionNumber } 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
@@ -95,6 +95,11 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             probedUntyped = true;
         }
     }
+    if (receiverIr?.kind === "union") {
+        const unionHof = lowerArrayUnionHofCall(lowerer, call, access, receiverIr);
+        if (unionHof)
+            return unionHof;
+    }
     if (receiverIr?.kind !== "array")
         return null;
     if (!probedUntyped && !lowerer.isStdlibMember(access))
@@ -282,14 +287,14 @@ export function lowerArrayMethodCall(lowerer, call, access) {
         };
     }
     // The lib declares wider call forms than the lowered surface —
-    // indexOf/includes take a fromIndex, join's separator is optional, the
-    // predicate/mapping HOFs take a thisArg. Each unlowered form is fenced
+    // join's separator is optional, and the predicate/mapping HOFs take
+    // a thisArg. Each unlowered form is fenced
     // per site (SC2020), never silently truncated to the supported
     // arguments. push/unshift lower every declared form (variadic, 0 args
     // included — Node returns the unchanged length); reduce/reduceRight
     // lower both declared forms (with and without an initial value).
     const arity = {
-        push: [0, Number.MAX_SAFE_INTEGER], unshift: [0, Number.MAX_SAFE_INTEGER], pop: [0, 0], indexOf: [1, 1], includes: [1, 1], join: [1, 1],
+        push: [0, Number.MAX_SAFE_INTEGER], unshift: [0, Number.MAX_SAFE_INTEGER], pop: [0, 0], indexOf: [1, 2], lastIndexOf: [1, 2], includes: [0, 2], join: [1, 1],
         concat: [0, Number.MAX_SAFE_INTEGER],
         slice: [0, 2], shift: [0, 0], splice: [1, 2], at: [1, 1],
         map: [1, 1], filter: [1, 1], forEach: [1, 1], find: [1, 1], findIndex: [1, 1], some: [1, 1],
@@ -301,12 +306,10 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             ? "the removal forms lower — splice(start, deleteCount?); to insert, build a new array with slice and push"
             : name === "join"
                 ? 'pass the separator explicitly: join(",")'
-                : name === "indexOf" || name === "includes"
-                    ? "the fromIndex parameter has no lowering — slice first, or loop"
-                    : name === "map" || name === "filter" || name === "forEach" ||
-                        name === "find" || name === "some" || name === "every" || name === "flatMap"
-                        ? "the thisArg parameter has no lowering — use an arrow function"
-                        : undefined;
+                : name === "map" || name === "filter" || name === "forEach" ||
+                    name === "find" || name === "some" || name === "every" || name === "flatMap"
+                    ? "the thisArg parameter has no lowering — use an arrow function"
+                    : undefined;
         lowerer.noLowering(`.${name} with ${call.arguments.length} argument${call.arguments.length === 1 ? "" : "s"}`, call, hint);
     }
     if (name === "push" || name === "unshift") {
@@ -388,7 +391,7 @@ export function lowerArrayMethodCall(lowerer, call, access) {
             loc,
         };
     }
-    if (name === "indexOf" || name === "includes") {
+    if (name === "indexOf" || name === "lastIndexOf" || name === "includes") {
         return lowerArraySearchCall(lowerer, call, access, name, elem);
     }
     if (name === "concat") {
@@ -526,14 +529,23 @@ export function lowerArrayMethodCall(lowerer, call, access) {
 /** `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. */
+ * indexOf and lastIndexOf skip 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);
+    const argNode = call.arguments[0] ?? call;
+    if (call.arguments.some(ts.isSpreadElement))
+        lowerer.noLowering(`.${method} with spread arguments`, call);
+    let needle = call.arguments[0]
+        ? lowerer.lowerExpr(call.arguments[0])
+        : { kind: "unitLit", unit: "undefined", type: UNDEFINED_T, loc };
+    const fromIndex = call.arguments[1]
+        ? lowerPositionArgument(lowerer, call.arguments[1], numLit(0, loc))
+        : method === "lastIndexOf"
+            ? { kind: "bin", op: "/", left: numLit(1, loc), right: numLit(0, loc), type: F64, loc }
+            : numLit(0, loc);
     // 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)) {
@@ -541,21 +553,25 @@ function lowerArraySearchCall(lowerer, call, access, method, 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" && elem.kind !== "bigint" && typeEquals(needle.type, elem)) {
+    if (method !== "lastIndexOf" && call.arguments.length === 1 && elem.kind !== "union" && elem.kind !== "bigint" && typeEquals(needle.type, elem)) {
         return {
             kind: "arrIntrinsic",
             method,
             receiver,
             args: [needle],
-            type: method === "indexOf" ? F64 : BOOL,
+            type: method === "includes" ? BOOL : F64,
             loc,
         };
     }
-    const valueT = arrayValueType(lowerer, elem);
+    let 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 (method === "lastIndexOf")
+            lowerer.noLowering(".lastIndexOf on an array of engine values", call);
+        if (call.arguments.length > 1)
+            lowerer.noLowering(`.${method} with fromIndex on '${lowerer.fmt(elem)}' elements`, call);
         if (!typeEquals(needle.type, elem))
             lowerer.badType(argNode, lowerer.typeOf(argNode));
         return {
@@ -563,15 +579,38 @@ function lowerArraySearchCall(lowerer, call, access, method, elem) {
             method,
             receiver,
             args: [needle],
-            type: method === "indexOf" ? F64 : BOOL,
+            type: method === "includes" ? BOOL : F64,
             loc,
         };
     }
-    const searchNeedle = lowerer.coerceInto(argNode, needle, valueT);
-    if (!typeEquals(searchNeedle.type, valueT))
+    // Search uses strict equality, never conversion to the array's element
+    // type. Retain primitive needles of a different kind in the comparison
+    // union so a nonmatching kind returns a miss instead of throwing.
+    const needleArms = needle.type.kind === "union"
+        ? lowerer.unions.get(needle.type.unionId).arms
+        : [needle.type];
+    const scalarNeedle = needleArms.every((arm) => arm.kind === "f64" || arm.kind === "string" || arm.kind === "bool" ||
+        arm.kind === "bigint" || arm.kind === "symbol" || isUnitType(arm));
+    const valueArms = lowerer.unions.get(valueT.unionId).arms;
+    if (scalarNeedle && !valueArms.some((arm) => arm.kind === "func" || arm.kind === "set")) {
+        const arms = [...valueArms];
+        for (const arm of needleArms)
+            if (!arms.some((existing) => typeEquals(existing, arm)))
+                arms.push(arm);
+        if (arms.length !== valueArms.length)
+            valueT = { kind: "union", unionId: lowerer.unions.intern(arms) };
+    }
+    const directNeedle = method === "lastIndexOf" && elem.kind !== "union" && typeEquals(needle.type, elem);
+    const searchNeedle = directNeedle ? needle : lowerer.coerceInto(argNode, needle, valueT);
+    // Checked dynamic extraction can copy a composite. Its new identity cannot
+    // be compared to an array element as though it were the original value.
+    if (method === "lastIndexOf" && searchNeedle.kind === "dynCheck" && (elem.kind === "record" || elem.kind === "array")) {
+        lowerer.noLowering(".lastIndexOf with a checked dynamic reference needle", call);
+    }
+    if (!directNeedle && !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 };
+    const helper = arraySearchHelper(lowerer, method, elem, valueT, searchNeedle.type, directNeedle, fromIndex.type, call.arguments[1] ?? call, loc);
+    return { kind: "call", callee: helper, args: [receiver, searchNeedle, fromIndex], type: method === "includes" ? BOOL : F64, loc };
 }
 /** SameValueZero over a static value union. `unionEq` supplies strict
  * equality for every arm; the extra f64-arm test is the only difference for
@@ -615,25 +654,65 @@ function arraySearchEquality(lowerer, left, right, sameValueZero, 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)}`;
+function arraySearchHelper(lowerer, method, elem, valueT, needleT, directNeedle, fromT, fromNode, loc) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(valueT)}:${typeKey(needleT)}:${directNeedle}:${typeKey(fromT)}`;
     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 resultT = method === "includes" ? BOOL : F64;
     const arrRef = varRef("a.0", arrT, loc);
     const indexRef = varRef("i.0", F64, loc);
-    const needleRef = varRef("needle.0", valueT, loc);
+    const needleRef = varRef("needle.0", needleT, loc);
     const stateRef = varRef("state.0", F64, loc);
     const nextRef = varRef("next.0", F64, loc);
+    const fromRef = varRef("from.0", fromT, loc);
+    const numberRef = varRef("number.0", F64, loc);
+    const integerRef = varRef("integer.0", F64, loc);
+    // Snapshot length before coercing fromIndex, then apply ToIntegerOrInfinity.
+    const number = positionNumber(lowerer, fromRef, numLit(0, loc), fromNode, "array search position");
+    const integer = {
+        kind: "ternary",
+        cond: { kind: "libCall", fn: "num.isNaN", args: [numberRef], type: BOOL, loc },
+        then: numLit(0, loc),
+        else_: { kind: "libCall", fn: "math.trunc", args: [numberRef], type: F64, loc },
+        type: F64,
+        loc,
+    };
+    const forwardStart = {
+        kind: "ternary",
+        cond: { kind: "bin", op: "<", left: integerRef, right: numLit(0, loc), type: BOOL, loc },
+        then: {
+            kind: "libCall", fn: "math.max",
+            args: [{ kind: "bin", op: "+", left: varRef("n.0", F64, loc), right: integerRef, type: F64, loc }, numLit(0, loc)],
+            type: F64, loc,
+        },
+        // Adding positive zero canonicalizes a truncated negative zero.
+        else_: { kind: "bin", op: "+", left: integerRef, right: numLit(0, loc), type: F64, loc },
+        type: F64,
+        loc,
+    };
+    const start = method === "lastIndexOf" ? {
+        kind: "ternary",
+        cond: { kind: "bin", op: "<", left: integerRef, right: numLit(0, loc), type: BOOL, loc },
+        then: { kind: "bin", op: "+", left: varRef("n.0", F64, loc), right: integerRef, type: F64, loc },
+        else_: {
+            kind: "libCall", fn: "math.min",
+            args: [
+                { kind: "bin", op: "+", left: integerRef, right: numLit(0, loc), type: F64, loc },
+                { kind: "bin", op: "-", left: varRef("n.0", F64, loc), right: numLit(1, loc), type: F64, loc },
+            ],
+            type: F64, loc,
+        },
+        type: F64, loc,
+    } : forwardStart;
     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 = {
+    const optionalValue = {
         kind: "ternary",
         cond: { kind: "bin", op: "===", left: stateRef, right: numLit(1, loc), type: BOOL, loc },
         then: typeEquals(elem, valueT) ? rawRead : lowerer.coerceToExpected(rawRead, valueT),
@@ -641,12 +720,14 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
         type: valueT,
         loc,
     };
-    const equal = arraySearchEquality(lowerer, varRef("value.0", valueT, loc), needleRef, method === "includes", loc);
-    const match = method === "indexOf"
+    const value = directNeedle ? rawRead : optionalValue;
+    const readT = directNeedle ? elem : valueT;
+    const equal = arraySearchEquality(lowerer, varRef("value.0", readT, loc), needleRef, method === "includes", loc);
+    const match = method !== "includes"
         ? {
             kind: "logical",
             op: "&&",
-            left: { kind: "bin", op: "!==", left: stateRef, right: numLit(0, loc), type: BOOL, loc },
+            left: { kind: "bin", op: directNeedle ? "===" : "!==", left: stateRef, right: numLit(directNeedle ? 1 : 0, loc), type: BOOL, loc },
             right: equal,
             type: BOOL,
             loc,
@@ -655,7 +736,7 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
     const undefinedTag = lowerer.armTag(valueT.unionId, UNDEFINED_T);
     if (undefinedTag < 0)
         throw new InternalCompilerError("array search helper needs an undefined tag");
-    const needleIsUndefined = {
+    const needleIsUndefined = directNeedle ? boolLit(false, loc) : {
         kind: "unionIsTag",
         unionId: valueT.unionId,
         tag: undefinedTag,
@@ -667,7 +748,7 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
     const advance = {
         kind: "assign",
         localId: "i.0",
-        value: { kind: "bin", op: "+", left: indexRef, right: numLit(1, loc), type: F64, loc },
+        value: { kind: "bin", op: method === "lastIndexOf" ? "-" : "+", left: indexRef, right: numLit(1, loc), type: F64, loc },
         loc,
     };
     const visitPresent = [
@@ -675,13 +756,13 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
         {
             kind: "if",
             cond: match,
-            then: [{ kind: "return", value: method === "indexOf" ? indexRef : boolLit(true, loc), loc }],
+            then: [{ kind: "return", value: method === "includes" ? boolLit(true, loc) : indexRef, loc }],
             else_: null,
             loc,
         },
         advance,
     ];
-    const skipHole = [
+    const skipHole = method === "lastIndexOf" ? [advance] : [
         {
             kind: "varDecl",
             localId: "next.0",
@@ -707,28 +788,36 @@ function arraySearchHelper(lowerer, method, elem, valueT, loc) {
         name,
         params: [
             { localId: "a.0", name: "a", type: arrT },
-            { localId: "needle.0", name: "needle", type: valueT },
+            { localId: "needle.0", name: "needle", type: needleT },
+            { localId: "from.0", name: "from", type: fromT },
         ],
         returnType: resultT,
         locals: [
             { id: "a.0", name: "a", type: arrT, mutable: true },
-            { id: "needle.0", name: "needle", type: valueT, mutable: true },
+            { id: "needle.0", name: "needle", type: needleT, mutable: true },
+            { id: "from.0", name: "from", type: fromT, mutable: false },
+            { id: "number.0", name: "number", type: F64, mutable: false },
+            { id: "integer.0", name: "integer", type: F64, mutable: false },
             { 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 },
+            { id: "value.0", name: "value", type: readT, mutable: false },
         ],
         body: [
             readLenStmt(arrT, loc),
-            { kind: "varDecl", localId: "i.0", init: numLit(0, loc), loc },
+            { kind: "varDecl", localId: "number.0", init: number, loc },
+            { kind: "varDecl", localId: "integer.0", init: integer, loc },
+            { kind: "varDecl", localId: "i.0", init: start, loc },
             {
                 kind: "while",
-                cond: { kind: "bin", op: "<", left: indexRef, right: varRef("n.0", F64, loc), type: BOOL, loc },
+                cond: method === "lastIndexOf"
+                    ? { kind: "bin", op: ">=", left: indexRef, right: numLit(0, loc), type: BOOL, loc }
+                    : { 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 },
+            { kind: "return", value: method === "includes" ? boolLit(false, loc) : numLit(-1, loc), loc },
         ],
         loc,
     });
@@ -828,6 +917,18 @@ function hofCallbackArg(lowerer, argNode, lead, arrT, bindUntyped = false) {
         }
         lowerer.implicitParamTypes = previousImplicit;
     }
+    // Array storage widens indexed reads with undefined so holes remain
+    // observable. The HOF helper guards every callback behind arrayHas,
+    // so an exact-ABI builtin closure may safely adapt from its declared
+    // parameter to that guarded union. Keep this exception scoped to the
+    // compiler-generated builtin values; ordinary callback-value policy is
+    // unchanged.
+    if (fnArg.type.kind === "func" && lowerer.isBuiltinCallableValue(fnArg)) {
+        const callbackType = funcOf(full.slice(0, fnArg.type.params.length), fnArg.type.ret);
+        if (!typeEquals(fnArg.type, callbackType)) {
+            fnArg = lowerer.coerceToExpected(fnArg, callbackType);
+        }
+    }
     if (fnArg.type.kind !== "func" ||
         fnArg.type.params.length > full.length ||
         !fnArg.type.params.every((p, i) => typeEquals(p, full[i]))) {
@@ -1043,6 +1144,139 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
     lowerer.liftedFns.push(buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem));
     return name;
 }
+/** The TS 5.2+ callable-union array rule: a `T[] | U[]` receiver exposes
+ * common HOFs with a callback over `T | U`. The runtime value remains the
+ * original concrete array arm — never a copied `(T | U)[]` — and an
+ * arm-specific function adapter wraps the element and receiver arguments
+ * into the union-wide callback ABI. That preserves sparse-array reads,
+ * callback mutation, and the callback's third-argument identity. */
+function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
+    const method = access.name.text;
+    if (method !== "map" && method !== "forEach")
+        return null;
+    if (!lowerer.isStdlibMember(access))
+        return null;
+    const def = lowerer.unions.get(receiverT.unionId);
+    if (!def || def.arms.length < 2 || !def.arms.every((arm) => arm.kind === "array"))
+        return null;
+    if (call.arguments.length !== 1 || !call.arguments[0])
+        return null;
+    const arrays = def.arms;
+    const valueArms = [];
+    const addValueArm = (type) => {
+        if (type.kind === "dyn" || type.kind === "jsval" || type.kind === "caught" || type.kind === "void")
+            return false;
+        if (type.kind === "union") {
+            const inner = lowerer.unions.get(type.unionId);
+            if (!inner)
+                return false;
+            for (const arm of inner.arms) {
+                if (!valueArms.some((candidate) => typeEquals(candidate, arm)))
+                    valueArms.push(arm);
+            }
+            return true;
+        }
+        if (!valueArms.some((candidate) => typeEquals(candidate, type)))
+            valueArms.push(type);
+        return true;
+    };
+    for (const array of arrays) {
+        if (!addValueArm(array.elem))
+            return null;
+    }
+    const valueT = valueArms.length === 1
+        ? valueArms[0]
+        : { kind: "union", unionId: lowerer.unions.intern(valueArms) };
+    const argNode = call.arguments[0];
+    const { fnArg, arity } = hofCallbackArg(lowerer, argNode, [valueT], receiverT);
+    const fnRet = fnArg.type.ret;
+    if (method === "map" && (fnRet.kind === "void" || fnRet.kind === "func")) {
+        lowerer.badType(call, lowerer.typeOf(call));
+    }
+    if (method === "map")
+        fenceProducedArrayElem(lowerer, call, "'.map()'", fnRet);
+    const outElem = method === "map" ? callbackArrayElem(lowerer, call, fnRet) : VOID;
+    const resultT = method === "map" ? arrayOf(outElem) : VOID;
+    for (const array of arrays) {
+        const armFnT = funcOf([arrayValueType(lowerer, array.elem), F64, array].slice(0, arity), fnRet);
+        if (!lowerer.cleanFuncAdaptable(fnArg.type, armFnT))
+            return null;
+    }
+    const helper = arrayUnionHofHelper(lowerer, method, receiverT, arrays, fnArg.type, arity, fnRet, outElem, locOf(call));
+    return {
+        kind: "call",
+        callee: helper,
+        args: [lowerer.coerceInto(access.expression, lowerer.lowerExpr(access.expression), receiverT), fnArg],
+        type: resultT,
+        loc: locOf(call),
+    };
+}
+function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arity, fnRet, outElem, loc) {
+    const resultT = method === "map" ? arrayOf(outElem) : VOID;
+    const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}`;
+    const existing = lowerer.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%arr.union.${lowerer.arrHofHelpers.size}`;
+    lowerer.arrHofHelpers.set(key, name);
+    const receiver = varRef("a.0", receiverT, loc);
+    const callback = varRef("f.0", callbackT, loc);
+    const branch = (array) => {
+        const tag = lowerer.armTag(receiverT.unionId, array);
+        const concrete = {
+            kind: "unionNarrow",
+            unionId: receiverT.unionId,
+            tag,
+            value: receiver,
+            type: array,
+            loc,
+        };
+        const armFnT = funcOf([arrayValueType(lowerer, array.elem), F64, array].slice(0, arity), fnRet);
+        const adapted = lowerer.coerceToExpected(callback, armFnT);
+        if (!typeEquals(adapted.type, armFnT)) {
+            throw new InternalCompilerError("lowerer bug: union-array callback stopped adapting");
+        }
+        const callee = arrayHofHelper(lowerer, method, array.elem, fnRet, arity, loc, outElem);
+        const invoke = { kind: "call", callee, args: [concrete, adapted], type: resultT, loc };
+        return resultT.kind === "void"
+            ? [{ kind: "exprStmt", expr: invoke, loc }, { kind: "return", value: null, loc }]
+            : [{ kind: "return", value: invoke, loc }];
+    };
+    let body = branch(arrays[arrays.length - 1]);
+    for (let i = arrays.length - 2; i >= 0; i--) {
+        const array = arrays[i];
+        body = [{
+                kind: "if",
+                cond: {
+                    kind: "unionIsTag",
+                    unionId: receiverT.unionId,
+                    tag: lowerer.armTag(receiverT.unionId, array),
+                    negated: false,
+                    value: receiver,
+                    type: BOOL,
+                    loc,
+                },
+                then: branch(array),
+                else_: body,
+                loc,
+            }];
+    }
+    lowerer.liftedFns.push({
+        name,
+        params: [
+            { localId: "a.0", name: "a", type: receiverT },
+            { localId: "f.0", name: "f", type: callbackT },
+        ],
+        returnType: resultT,
+        locals: [
+            { id: "a.0", name: "a", type: receiverT, mutable: false },
+            { id: "f.0", name: "f", type: callbackT, mutable: false },
+        ],
+        body,
+        loc,
+    });
+    return name;
+}
 /** READ-ONLY array methods on TUPLE receivers — `t.slice(...)` and
    * `t.map(f)`: a tuple is a fixed-shape record, but these methods never
    * write, so the positions snapshot into a fresh array (the for-of-over-
@@ -1141,15 +1375,8 @@ export function lowerTupleReadMethodCall(lowerer, call, access) {
     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`
-   * is an integer in [0, len), JS's property-miss undefined otherwise —
-   * instead of the trap divergence 4 documents for program code.
-   * Package JS is inference-typed, guard-style code (`registeredArguments
-   * .slice(-1)[0]`, commander's last-element probe), and the trap would
-   * fire on working Node idioms; program files keep the documented trap
-   * (their annotations can prove bounds). Existing element unions retag
-   * into the canonical union with an added undefined arm. */
+/** An ordinary indexed read: values retain their element type, while
+ * holes, missing properties, and present undefined yield undefined. */
 export function lowerSafeIndexRead(lowerer, arr, index, loc) {
     const elem = arr.type.elem;
     if (elem.kind === "void" || elem.kind === "dyn")
@@ -1178,6 +1405,21 @@ export function lowerSafeIndexRead(lowerer, arr, index, loc) {
     }
     return { kind: "call", callee: name, args: [arr, index], type: resultT, loc };
 }
+/** Fuse only our own f64-array read helper with immediate ToNumber.
+ * Reuse its arguments verbatim so the receiver and index still evaluate
+ * exactly once, in order, before the read. Do not specialize user calls,
+ * union-element arrays, or optional values stored in locals. */
+export function tryLowerNumericIndexRead(lowerer, operand, loc) {
+    if (operand.kind !== "call" || operand.callee !== lowerer.arrHofHelpers.get(`idxOr:${typeKey(F64)}`))
+        return null;
+    const [arr, index] = operand.args;
+    if (operand.args.length !== 2 || arr?.type.kind !== "array" || arr.type.elem.kind !== "f64" || index?.type.kind !== "f64")
+        return null;
+    // The intrinsic owns the evaluated receiver through index evaluation,
+    // then borrows it for one slot lookup. No extra helper parameter or
+    // separate state/getter expressions need to retain the array again.
+    return { kind: "arrIntrinsic", method: "getNumber", receiver: arr, args: [index], type: F64, loc };
+}
 /** Backward-compatible name for the npm-static probe path. */
 export const lowerNpmStaticSafeIndexRead = lowerSafeIndexRead;
 /** Interned synthetic function for one (elem, argument-shape) concat —