@scriptc/compiler 0.4.6 → 0.4.8

package/dist/frontend/lowering/containers/array-callbacks.js

@@ -10,11 +10,12 @@ import { isJsSourceFile, locOf } from "../../program.js";
 import { buildArraySortFn, buildSortKeyFn, closureKeyOrder, sortKeysId, sortKeysOrder, } from "../lower-array-sort.js";
 import { arrayIndexPresent, arraySlotSnapshot, arraySnapshotAppend, arraySnapshotValue, arrayValueRead, arrayValueStore, arrayValueType, currentArrayIndexPresent, elementMayBeForeign, foreignElementThrow, primitiveElement, slotSnapshotLocals, unreadArgument, } from "../array-values.js";
 import { typeKey } from "../../type-mapper.js";
-import { lowerArrayCallback, requireProducedArrayElement, callbackArrayElement, truthyFilterCallback, } from "./callback-arguments.js";
+import { lowerArrayCallback, requireProducedArrayElement, unitOnlyArrayElement, callbackArrayElement, truthyFilterCallback, } from "./callback-arguments.js";
 import { reverseArrayLoop, arrayLengthDeclaration, arrayCallbackParams, arrayCallbackLocals, callArrayCallback, } from "./array-iteration.js";
 import { dynamicReceiverThrows } from "./dynamic-receivers.js";
 import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "../optional-arguments.js";
-import { checkedFilterNarrowing } from "./filter-predicates.js";
+import { checkedFilterNarrowing, supersetGuardFields } from "./filter-predicates.js";
+import { omittableTrailingParam } from "../coercions/function-adapters.js";
 /** `a.map(fn)` / `a.filter(fn)` / `a.forEach(fn)` desugar to a direct
  * call of a synthetic module function — one per method + element/result
  * type + callback-arity combination, interned — whose body is a plain
@@ -37,6 +38,7 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(argNode) ?? undefined);
     const present = !booleanFilter && presentElements(lowerer, call, elem);
     const valueT = callbackValueType(lowerer, elem, present);
+    const thisArg = hofThisArg(lowerer, call);
     if (booleanFilter) {
         if (valueT.kind === "union")
             lowerer.requireTruthyUnion(valueT.unionId, argNode);
@@ -48,7 +50,7 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     }
     const callback = booleanFilter
         ? { fnArg: truthyFilterCallback(lowerer, valueT, loc), arity: 1, unread: false }
-        : lowerArrayCallback(lowerer, argNode, [valueT], arrayOf(elem));
+        : lowerArrayCallback(lowerer, argNode, [valueT], arrayOf(elem), false, method === "map" ? (unitOnlyArrayElement(lowerer, call) ?? undefined) : undefined);
     const { fnArg, arity } = callback;
     // Only an array that can hold elements outside its element type needs to
     // leave an element its callback ignores unread.
@@ -81,15 +83,19 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
     const outElem = filtered !== null ? filtered.elem : callbackArrayElement(lowerer, call, fnRet);
     // A filter that re-tags its elements keeps the single union-typed visit.
     // A callback that never reads its element has no use for a typed one.
-    const fast = present || booleanFilter || unread || (method === "filter" && !typeEquals(outElem, elem))
+    const fast = present ||
+        booleanFilter ||
+        unread ||
+        thisArg !== null ||
+        (method === "filter" && !typeEquals(outElem, elem))
         ? null
         : lowerFastCallback(lowerer, argNode, [valueT], 0, elem, arrayOf(elem), callback);
-    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+    const helper = arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
     const resultType = method === "map" || method === "filter" ? arrayOf(outElem) : VOID;
     const result = {
         kind: "call",
         callee: helper,
-        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
         type: resultType,
         loc,
     };
@@ -104,6 +110,20 @@ export function lowerArrayHofCall(lowerer, call, access, method, elem) {
         loc,
     };
 }
+/** The thisArg of a callback HOF call (`a.map(f, thisArg)`), lowered as the
+ * checked-dynamic value the helper hands the callback as its call-site
+ * receiver. Null when the call has no second argument, in which case the
+ * helper keeps the two-slot frame and the callback's `this` is the ambient
+ * one, exactly as before. */
+function hofThisArg(lowerer, call) {
+    const node = call.arguments.nodes[1];
+    if (node === undefined)
+        return null;
+    if (call.arguments.nodes.length > 2) {
+        lowerer.noLowering(`.${ts.isPropertyAccessExpression(call.expression) ? call.expression.name.text : ""} with ${call.arguments.nodes.length} arguments`, call, "the supported form takes the callback and an optional thisArg");
+    }
+    return lowerer.lowerExprExpecting(node, DYN);
+}
 /** The element a filter keeps, and the checked conversion of the result
  * to the checker's narrower element when the predicate does not prove it.
  * An inferred inline type predicate proves one source arm, or a class
@@ -158,6 +178,18 @@ function filterKeptElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
     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";
+    // A record target that declares fields the receiver's record element has no
+    // slot for: the elements were narrowed when they were stored, so those
+    // fields no longer exist at runtime and no per-field check can recover them.
+    const widened = supersetGuardFields(lowerer, elem, outElem);
+    const missingFields = widened === null
+        ? ""
+        : ` (the receiver's element type has no slot for ${widened
+            .slice(0, 4)
+            .map((field) => `'${field}'`)
+            .join(", ")}${widened.length > 4 ? ` and ${widened.length - 4} more` : ""} — each ` +
+            `element was narrowed when it was stored, so those fields do not exist at runtime and ` +
+            `the predicate cannot make them real)`;
     const written = !booleanFilter &&
         ((!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) ||
             argNode.type !== undefined);
@@ -170,10 +202,10 @@ function filterKeptElem(lowerer, call, argNode, elem, valueT, booleanFilter) {
             return helper;
         if (!ts.isArrowFunction(argNode) && !ts.isFunctionExpression(argNode)) {
             lowerer.unsupported("SC1090", argNode, `narrowing '.filter' to '${lowerer.fmt(outElem)}' through a callback VALUE (no checked ` +
-                `conversion from '${lowerer.fmt(elem)}' — ${annotateEscape})`);
+                `conversion from '${lowerer.fmt(elem)}'${missingFields} — ${annotateEscape})`);
         }
         lowerer.unsupported("SC1090", argNode, `narrowing '.filter' to '${lowerer.fmt(outElem)}' with a hand-written type predicate (no ` +
-            `checked conversion from '${lowerer.fmt(elem)}' — ${annotateEscape})`);
+            `checked conversion from '${lowerer.fmt(elem)}'${missingFields} — ${annotateEscape})`);
     }
     const classRefinement = !booleanFilter && outElem.kind === "object" && canAssertClassValue(lowerer, valueT, outElem);
     if (!classRefinement &&
@@ -439,8 +471,8 @@ const FILTER_SNAPSHOT = { isForeign: "vf.0", value: "v.0", foreign: "vd.0" };
  * 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, outElem = fnRet, site = "", fastT = null, present = false, unread = false) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRet, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}:${typeKey(outElem)}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -456,7 +488,7 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
         split: !!fastT,
         unread,
     });
-    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present, unread);
+    const fn = buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT, present, unread, withThis);
     lowerer.liftedFns.push(fastT ? withFastCallback(fn, fastT, elem) : fn);
     return name;
 }
@@ -465,10 +497,17 @@ function arrayHofHelper(lowerer, method, elem, fnRet, arity, loc, outElem = fnRe
  * 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. */
+ * callback mutation, and the callback's third-argument identity.
+ *
+ * `filter` joins them: the kept elements are the checker's result element
+ * (`(b): b is TextContent` over `(TextContent | ImageContent)[] |
+ * (ThinkingContent | TextContent)[]` answers `TextContent[]`), so each arm
+ * filters its own array and converts its survivors through the checked
+ * narrowing — a predicate that kept an element it does not describe throws
+ * the TypeError. An arm with no such conversion leaves the fence in place. */
 export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
     const method = access.name.text;
-    if (method !== "map" && method !== "forEach")
+    if (method !== "map" && method !== "forEach" && method !== "filter")
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
@@ -504,7 +543,7 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
         ? valueArms[0]
         : { kind: "union", unionId: lowerer.unions.intern(valueArms) };
     const argNode = call.arguments.nodes[0];
-    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [valueT], receiverT);
+    const { fnArg, arity } = lowerArrayCallback(lowerer, argNode, [valueT], receiverT, false, method === "map" ? (unitOnlyArrayElement(lowerer, call) ?? undefined) : undefined);
     const fnRet = fnArg.type.ret;
     if (method === "map" && fnRet.kind === "void") {
         // `void[]` has no element (see the plain-receiver map path).
@@ -512,14 +551,50 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
     }
     if (method === "map")
         requireProducedArrayElement(lowerer, call, "'.map()'", fnRet);
-    const outElem = method === "map" ? callbackArrayElement(lowerer, call, fnRet) : VOID;
-    const resultT = method === "map" ? arrayOf(outElem) : VOID;
+    if (method === "filter" && !filterPredicateOk(lowerer, fnRet)) {
+        if (fnRet.kind === "void") {
+            lowerer.unsupported("SC1090", call, "'.filter()' with a void-returning predicate (the callback return value is erased before its truthiness can be tested)");
+        }
+        lowerer.badType(call, lowerer.typeOf(call));
+    }
+    // `map` stores the callback's answer; `filter` keeps the elements its
+    // predicate named. The kept element is the CHECKER's result element, which
+    // for a written type predicate is narrower than every arm's own:
+    // `(b): b is TextContent` over `(TextContent | ImageContent)[] |
+    // (ThinkingContent | TextContent)[]` answers `TextContent[]`. Each arm
+    // filters its own concrete array and converts its survivors to that
+    // element through the checked narrowing — a predicate that kept an element
+    // it does not describe throws instead of misreading it. No conversion the
+    // arms cannot make honestly means the fence stays.
+    let outElem = VOID;
+    const narrowing = [];
+    if (method === "map") {
+        outElem = callbackArrayElement(lowerer, call, fnRet);
+    }
+    else if (method === "filter") {
+        const result = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (!result || result.kind !== "array")
+            return null;
+        outElem = result.elem;
+        const typeText = filterTypeText(lowerer, call);
+        for (const array of arrays) {
+            if (typeEquals(array.elem, outElem)) {
+                narrowing.push(null);
+                continue;
+            }
+            const helper = checkedFilterNarrowing(lowerer, array.elem, outElem, typeText, locOf(call));
+            if (helper === null)
+                return null;
+            narrowing.push(helper);
+        }
+    }
+    const resultT = method === "forEach" ? VOID : arrayOf(outElem);
     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));
+    const helper = arrayUnionHofHelper(lowerer, method, receiverT, arrays, fnArg.type, arity, fnRet, outElem, narrowing, locOf(call));
     return {
         kind: "call",
         callee: helper,
@@ -531,9 +606,14 @@ export function lowerArrayUnionHofCall(lowerer, call, access, receiverT) {
         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)}`;
+function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arity, fnRet, outElem, narrowing, loc) {
+    const resultT = method === "forEach" ? VOID : arrayOf(outElem);
+    // A filter's per-arm conversions are part of what the helper does, so two
+    // sites that share receiver, callback and result but convert differently
+    // keep their own helper. `map`/`forEach` never narrow, and leaving their
+    // key untouched keeps the helpers a program already emitted byte-identical.
+    const narrowingKey = method === "filter" ? `:${narrowing.map((helper) => helper ?? "").join(",")}` : "";
+    const key = `union:${method}:${receiverT.unionId}:${typeKey(callbackT)}:${typeKey(resultT)}${narrowingKey}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -541,7 +621,7 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
     lowerer.arrHofHelpers.set(key, name);
     const receiver = varRef("a.0", receiverT, loc);
     const callback = varRef("f.0", callbackT, loc);
-    const branch = (array) => {
+    const branch = (array, index) => {
         const tag = lowerer.armTag(receiverT.unionId, array);
         const concrete = {
             kind: "unionNarrow",
@@ -556,16 +636,29 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
         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 };
+        const callee = arrayHofHelper(lowerer, method, array.elem, fnRet, arity, loc, method === "filter" ? array.elem : outElem);
+        const invoke = {
+            kind: "call",
+            callee,
+            args: [concrete, adapted],
+            type: method === "filter" ? arrayOf(array.elem) : resultT,
+            loc,
+        };
+        // Survivors of this arm's own array, converted to the checker's result
+        // element. The helper throws for a kept element the predicate does not
+        // describe, so a lying predicate never reinterprets a value.
+        const armNarrow = narrowing[index] ?? null;
+        const answer = armNarrow === null
+            ? invoke
+            : { kind: "call", callee: armNarrow, args: [invoke], type: resultT, loc };
         return resultT.kind === "void"
             ? [
                 { kind: "exprStmt", expr: invoke, loc },
                 { kind: "return", value: null, loc },
             ]
-            : [{ kind: "return", value: invoke, loc }];
+            : [{ kind: "return", value: answer, loc }];
     };
-    let body = branch(arrays[arrays.length - 1]);
+    let body = branch(arrays[arrays.length - 1], arrays.length - 1);
     for (let i = arrays.length - 2; i >= 0; i--) {
         const array = arrays[i];
         body = [
@@ -580,7 +673,7 @@ function arrayUnionHofHelper(lowerer, method, receiverT, arrays, callbackT, arit
                     type: BOOL,
                     loc,
                 },
-                then: branch(array),
+                then: branch(array, i),
                 else_: body,
                 loc,
             },
@@ -632,13 +725,13 @@ function filterRetainedValue(lowerer, v, elem, outElem, 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, outElem, fastT = null, present = false, unread = false) {
+function buildArrayHofFn(lowerer, name, method, elem, fnRet, arity, loc, outElem, fastT = null, present = false, unread = false, withThis = false) {
     const arrT = arrayOf(elem);
     const valueT = callbackValueType(lowerer, elem, present);
     const fnT = funcOf([valueT, F64, arrT].slice(0, arity), fnRet);
-    const locals = arrayCallbackLocals(arrT, fnT);
-    const params = arrayCallbackParams(arrT, fnT);
-    const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc);
+    const locals = arrayCallbackLocals(arrT, fnT, withThis);
+    const params = arrayCallbackParams(arrT, fnT, withThis);
+    const callF = (arg) => callArrayCallback(arrT, fnT, fnRet, arity, arg, loc, withThis);
     const getElem = callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc);
     // What the callback takes: the element, or a placeholder for one it
     // ignores (callbackValueRead's `unread`).
@@ -907,6 +1000,7 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
+    const thisArg = hofThisArg(lowerer, call);
     // find's result must be reachable from the element itself; a predicate
     // that narrows to another layout keeps the optional element visit.
     const present = presentElements(lowerer, call, elem) &&
@@ -930,17 +1024,17 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
         method === "every" ||
         method === "findIndex" ||
         method === "findLastIndex") {
-        const fast = present || unread
+        const fast = present || unread || thisArg !== null
             ? null
             : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, { fnArg, arity }, bindUntyped);
         const fastT = fast?.type ?? null;
         const helper = method === "findIndex" || method === "findLastIndex"
-            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT, present, unread)
-            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present, unread);
+            ? findIndexHelper(lowerer, elem, fnRet, arity, last, loc, callbackSite(fast ?? fnArg), fastT, present, unread, thisArg !== null)
+            : someEveryHelper(lowerer, method, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fastT, present, unread, thisArg !== null);
         return {
             kind: "call",
             callee: helper,
-            args: [receiver, fnArg, ...(fast ? [fast] : [])],
+            args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
             type: method === "findIndex" || method === "findLastIndex" ? F64 : BOOL,
             loc,
         };
@@ -962,8 +1056,14 @@ export function lowerArrayFindLikeCall(lowerer, call, access, method, elem, bind
     if (undefTag < 0)
         lowerer.badType(call, lowerer.typeOf(call));
     const retag = findResultRetag(lowerer, call, argNode, method, valueT, resultT, unchangedElement);
-    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg), present, unread);
-    return { kind: "call", callee: helper, args: [receiver, fnArg], type: resultT, loc };
+    const helper = findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, callbackSite(fnArg), present, unread, thisArg !== null);
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg, ...(thisArg ? [thisArg] : [])],
+        type: resultT,
+        loc,
+    };
 }
 /** The retag helper that converts a found element into find's result union,
  * or null when the element converts directly. Only an inline callback with
@@ -1017,9 +1117,9 @@ export function predicateToBoolean(e) {
  *   for (i = 0; i < n; i++) { v = a[i]; if (f(v)) return <v as result arm>; }
  *   return <undefined arm>;
  */
-function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false, unread = false) {
+function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, retag, site = "", present = false, unread = false, withThis = false) {
     const method = last ? "findLast" : "find";
-    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(resultT)}:${typeKey(fnRet)}:${arity}${site}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1056,7 +1156,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
             ...arraySlotSnapshot(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, FILTER_SNAPSHOT, loc),
             {
                 kind: "if",
-                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, placeholder ?? v, loc)),
+                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, placeholder ?? v, loc, withThis)),
                 then: [
                     {
                         kind: "return",
@@ -1072,7 +1172,7 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
             read,
             {
                 kind: "if",
-                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc)),
+                cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, v, loc, withThis)),
                 then: [{ kind: "return", value: found, loc }],
                 else_: null,
                 loc,
@@ -1089,10 +1189,10 @@ function findHelper(lowerer, elem, resultT, undefTag, fnRet, arity, last, loc, r
     ];
     lowerer.liftedFns.push({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: resultT,
         locals: [
-            ...arrayCallbackLocals(arrT, fnT),
+            ...arrayCallbackLocals(arrT, fnT, withThis),
             { id: "v.0", name: "v", type: valueT, mutable: false },
             ...(ignored
                 ? slotSnapshotLocals(lowerer, elem, FILTER_SNAPSHOT).filter((l) => l.id !== "v.0")
@@ -1120,9 +1220,9 @@ function findFoundValue(lowerer, v, resultT, retag, loc) {
  *
  *   n = a.length; for (...) if (f(a[i], i, a)) return i;  return -1;
  */
-function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false, unread = false) {
+function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
     const method = last ? "findLastIndex" : "findIndex";
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1144,7 +1244,7 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
     const visit = [
         {
             kind: "if",
-            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc)),
+            cond: predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis)),
             then: [{ kind: "return", value: varRef("i.0", F64, loc), loc }],
             else_: null,
             loc,
@@ -1160,9 +1260,9 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: F64,
-        locals: [...arrayCallbackLocals(arrT, fnT)],
+        locals: [...arrayCallbackLocals(arrT, fnT, withThis)],
         body,
         loc,
     }, fastT, elem));
@@ -1173,8 +1273,8 @@ function findIndexHelper(lowerer, elem, fnRet, arity, last, loc, site = "", fast
  *   some:  n = a.length; for (...) if (f(a[i])) return true;  return false;
  *   every: n = a.length; for (...) if (!f(a[i])) return false; return true;
  */
-function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false) {
-    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `${method}:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1192,7 +1292,7 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
     });
     const arrT = arrayOf(elem);
     const fnT = funcOf([callbackValueType(lowerer, elem, present), F64, arrT].slice(0, arity), fnRet);
-    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc));
+    const callF = predicateToBoolean(callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis));
     const body = [
         arrayLengthDeclaration(arrT, loc),
         countedFor(loc, varRef("n.0", F64, loc), () => [
@@ -1218,9 +1318,9 @@ function someEveryHelper(lowerer, method, elem, fnRet, arity, loc, site = "", fa
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: BOOL,
-        locals: [...arrayCallbackLocals(arrT, fnT)],
+        locals: [...arrayCallbackLocals(arrT, fnT, withThis)],
         body,
         loc,
     }, fastT, elem));
@@ -1239,6 +1339,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
     const argNode = call.arguments.nodes[0];
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
+    const thisArg = hofThisArg(lowerer, call);
     const present = presentElements(lowerer, call, elem);
     const lowered = lowerArrayCallback(lowerer, argNode, [callbackValueType(lowerer, elem, present)], arrT);
     const { fnArg, arity } = lowered;
@@ -1253,7 +1354,7 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             recv: { kind: "dynFrom", value: receiver, liveRef: true, type: DYN, loc },
             method: "flatMap",
             calleeName: ts.getTextOfNode(access),
-            args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }],
+            args: [{ kind: "dynFrom", value: fnArg, type: DYN, loc }, ...(thisArg ? [thisArg] : [])],
             type: DYN,
             loc,
         };
@@ -1264,11 +1365,11 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             ? flatMapUnionPlan(lowerer, call, argNode, fnRet)
             : null;
         if (plan) {
-            const helper = flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present);
+            const helper = flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present, thisArg !== null);
             return {
                 kind: "call",
                 callee: helper,
-                args: [receiver, fnArg],
+                args: [receiver, fnArg, ...(thisArg ? [thisArg] : [])],
                 type: arrayOf(plan.outElem),
                 loc,
             };
@@ -1284,32 +1385,32 @@ export function lowerArrayFlatMapCall(lowerer, call, access, elem) {
             lowerer.badType(call, lowerer.typeOf(call));
         requireProducedArrayElement(lowerer, call, "'.flatMap()'", fnRet);
         const outElem = callbackArrayElement(lowerer, call, fnRet);
-        const fast = present || unread
+        const fast = present || unread || thisArg !== null
             ? null
             : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
                 fnArg,
                 arity,
             });
-        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+        const helper = arrayHofHelper(lowerer, "flatMap", elem, fnRet, arity, loc, outElem, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
         return {
             kind: "call",
             callee: helper,
-            args: [receiver, fnArg, ...(fast ? [fast] : [])],
+            args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
             type: arrayOf(outElem),
             loc,
         };
     }
-    const fast = present || unread
+    const fast = present || unread || thisArg !== null
         ? null
         : lowerFastCallback(lowerer, argNode, [arrayValueType(lowerer, elem)], 0, elem, arrT, {
             fnArg,
             arity,
         });
-    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread);
+    const helper = flatMapHelper(lowerer, elem, fnRet, arity, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, present, unread, thisArg !== null);
     return {
         kind: "call",
         callee: helper,
-        args: [receiver, fnArg, ...(fast ? [fast] : [])],
+        args: [receiver, fnArg, ...(fast ? [fast] : []), ...(thisArg ? [thisArg] : [])],
         type: fnRet,
         loc,
     };
@@ -1326,16 +1427,19 @@ function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
     const arms = lowerer.unions.get(fnRet.unionId)?.arms;
     if (!arms)
         return null;
-    // The `never[]` constituents of the callback's checked result.
+    // The constituents of the callback's checked result that can hold no
+    // element: a `never[]` arm, and the empty tuple a bare `[]` arm infers
+    // when the enclosing call has a contextual array type (`return x ? [a]
+    // : []` in a `f(): T[]`).
     const emptyArms = [];
     const signature = lowerer.checker.getCallSignatures(lowerer.typeOf(argNode))[0];
     if (signature) {
         const ret = lowerer.checker.getReturnTypeOfSignature(signature);
         for (const part of ret.isUnionType() ? ts.constituentTypes(ret) : [ret]) {
-            if (!lowerer.checker.isArrayType(part))
+            if (!lowerer.checker.isArrayType(part) && !lowerer.checker.isTupleType(part))
                 continue;
-            const [element] = lowerer.checker.getTypeArguments(part);
-            if (element === undefined || (element.flags & ts.TypeFlags.Never) === 0)
+            const element = lowerer.checker.getTypeArguments(part)[0];
+            if (element !== undefined && (element.flags & ts.TypeFlags.Never) === 0)
                 continue;
             const mapped = lowerer.mapTypeOf(part);
             if (mapped)
@@ -1352,6 +1456,7 @@ function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
             return false;
         return lowerer.armTag(outElem.unionId, t) >= 0;
     };
+    const tupleConverts = (arm) => (lowerer.shapes.get(arm.shapeId)?.fields ?? []).every((f) => converts(f.type));
     const plan = [];
     for (const arm of arms) {
         if (arm.kind === "array" && emptyArms.some((e) => typeEquals(e, arm)))
@@ -1360,6 +1465,11 @@ function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
         // undefined included, so its element type is the result's.
         else if (arm.kind === "array" && typeEquals(arm.elem, outElem))
             plan.push("spread");
+        // A contextual array type makes a multi-statement body's `[pair]`
+        // infer as a one-element TUPLE (`return x ? [pair] : []`), whose
+        // fields contribute in order.
+        else if (arm.kind === "record" && lowerer.shapes.get(arm.shapeId)?.tuple && tupleConverts(arm))
+            plan.push("tuple");
         else if (arm.kind !== "array" && converts(arm))
             plan.push("value");
         else
@@ -1370,10 +1480,10 @@ function flatMapUnionPlan(lowerer, call, argNode, fnRet) {
 /** The flatMap loop over a union-returning callback: each result tests
  * its arm and appends its elements, nothing, or itself (Node's
  * IsArray decision per value). */
-function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
+function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present, withThis = false) {
     // The plan is part of the key: one union result type can carry an empty
     // `never[]` arm in one callback and a populated array arm in another.
-    const key = `flatMapUnion:${typeKey(elem)}:${typeKey(fnRet)}:${typeKey(plan.outElem)}:${plan.arms.join(",")}:${arity}${present ? ":present" : ""}`;
+    const key = `flatMapUnion:${typeKey(elem)}:${typeKey(fnRet)}:${typeKey(plan.outElem)}:${plan.arms.join(",")}:${arity}${present ? ":present" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1394,7 +1504,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
         loc,
     });
     const locals = [
-        ...arrayCallbackLocals(arrT, fnT),
+        ...arrayCallbackLocals(arrT, fnT, withThis),
         { id: "out.0", name: "out", type: outT, mutable: false },
         { id: "r.0", name: "r", type: fnRet, mutable: false },
     ];
@@ -1410,6 +1520,23 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
         };
         if (plan.arms[tag] === "empty")
             return [];
+        if (plan.arms[tag] === "tuple") {
+            const tuple = arm;
+            // The fields are stored by name ("0", "1", "10", "2", …): the
+            // elements append in index order.
+            const elements = [...(lowerer.shapes.get(tuple.shapeId)?.fields ?? [])].sort((a, b) => Number(a.name) - Number(b.name));
+            return elements.map((field) => {
+                const read = {
+                    kind: "recordGet",
+                    obj: narrowed,
+                    shapeId: tuple.shapeId,
+                    field: field.name,
+                    type: field.type,
+                    loc,
+                };
+                return arrayValueStore(lowerer, outRef(), outLength(), lowerer.coerceToExpected(read, plan.outElem), plan.outElem, loc);
+            });
+        }
         if (plan.arms[tag] === "value") {
             // A unit arm's value is the unit itself, which has no narrowed
             // representation.
@@ -1522,7 +1649,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
                     {
                         kind: "varDecl",
                         localId: "r.0",
-                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc), loc, withThis),
                         loc,
                     },
                     ...dispatch,
@@ -1535,7 +1662,7 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
     ];
     lowerer.liftedFns.push({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: outT,
         locals,
         body,
@@ -1552,8 +1679,8 @@ function flatMapUnionHelper(lowerer, elem, fnRet, arity, plan, loc, present) {
  *   }
  *   return out;
  */
-function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false) {
-    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}`;
+function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null, present = false, unread = false, withThis = false) {
+    const key = `flatMap:${typeKey(elem)}:${typeKey(fnRet)}:${arity}${site}${fastT ? ":split" : ""}${present ? ":present" : ""}${unread ? ":unread" : ""}${withThis ? ":this" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
@@ -1638,7 +1765,7 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
                     {
                         kind: "varDecl",
                         localId: "r.0",
-                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc),
+                        init: callArrayCallback(arrT, fnT, fnRet, arity, callbackValueRead(lowerer, varRef("a.0", arrT, loc), varRef("i.0", F64, loc), elem, present, loc, unread), loc, withThis),
                         loc,
                     },
                     {
@@ -1664,10 +1791,10 @@ function flatMapHelper(lowerer, elem, fnRet, arity, loc, site = "", fastT = null
     ];
     lowerer.liftedFns.push(withFastCallback({
         name,
-        params: arrayCallbackParams(arrT, fnT),
+        params: arrayCallbackParams(arrT, fnT, withThis),
         returnType: fnRet,
         locals: [
-            ...arrayCallbackLocals(arrT, fnT),
+            ...arrayCallbackLocals(arrT, fnT, withThis),
             { id: "out.0", name: "out", type: fnRet, mutable: false },
             { id: "r.0", name: "r", type: fnRet, mutable: false },
             { id: "m.0", name: "m", type: F64, mutable: false },
@@ -1692,19 +1819,46 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
     if (!argNode)
         lowerer.unsupported("SC1090", call, "this call form"); // tsc-guarded
     const hasInit = call.arguments.nodes.length === 2;
-    const accT = lowerer.runtimeOptionalReduceTypes.get(call) ??
-        (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
-    if (accT.kind === "void" || accT.kind === "func")
+    const overrideT = lowerer.runtimeOptionalReduceTypes.get(call) ?? null;
+    const staticAccT = overrideT ?? (hasInit ? lowerer.irTypeOf(call) : arrayValueType(lowerer, elem));
+    if (staticAccT.kind === "void" || staticAccT.kind === "func")
         lowerer.badType(call, lowerer.typeOf(call));
-    const lowered = lowerArrayCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], arrT, false, accT);
+    const lowered = lowerArrayCallback(lowerer, argNode, [staticAccT, arrayValueType(lowerer, elem)], arrT, false, staticAccT);
     const { fnArg, arity } = lowered;
+    // A JavaScript function with NO declared parameters whose body reads
+    // `arguments` has that hidden slot as its whole ABI, which the synthetic
+    // loop cannot fill: `callValue` passes exactly the declared parameters
+    // (none), so the callback would see an empty `arguments` where JavaScript
+    // passes (accumulator, element, index, array). Name the parameters
+    // instead; that is the same value with a checkable type. Read the
+    // callback's OWN type: the slot adaptation above (a dyn function boundary)
+    // erases the hidden slot from `fnArg.type`. A callback that names its
+    // parameters keeps working — `arguments` is built from the call's
+    // arguments there, not from a hidden slot.
+    if (lowered.rawType.kind === "func" &&
+        lowered.rawType.params.length === 0 &&
+        lowered.rawType.rest === true &&
+        lowered.rawType.restAbi === undefined)
+        lowerer.unsupported("SC1090", argNode, "a reduce callback that reads 'arguments' (name the parameters the callback uses)");
+    // The callback's own answer is what the accumulator receives. An inline
+    // lambda is contextually typed by the call (its returns coerce inside its
+    // own lowering), but a function DECLARATION keeps its declared return. When
+    // the checker's accumulator type cannot hold that value — `xs.reduce(function
+    // () { count++ }, 1)` answers undefined, a program the checker already
+    // diagnosed — the accumulator is the checked-dynamic value JavaScript
+    // produces instead of a miscast (the untyped-reduce shape; see
+    // accumulatorAdmitsAnswer).
+    const accT = overrideT !== null || accumulatorAdmitsAnswer(lowerer, staticAccT, fnArg.type.ret)
+        ? staticAccT
+        : DYN;
     // Only an array that can hold elements outside its element type needs to
-    // leave an element its callback ignores unread.
+    // leave an element its callback ignores unread. A dynamic accumulator is
+    // the untyped shape; it keeps the single visit and the callback's own ABI.
     const unread = lowered.unread && elementMayBeForeign(lowerer, elem);
-    const fast = unread
+    const fast = unread || accT.kind === "dyn"
         ? null
         : lowerFastCallback(lowerer, argNode, [accT, arrayValueType(lowerer, elem)], 1, elem, arrT, { fnArg, arity }, false, accT);
-    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type.ret, arity, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, unread);
+    const helper = reduceHelper(lowerer, method, elem, accT, fnArg.type, hasInit, loc, callbackSite(fast ?? fnArg), fast?.type ?? null, unread);
     const args = [receiver, fnArg];
     if (hasInit)
         args.push(lowerer.lowerExprExpecting(call.arguments.nodes[1], accT));
@@ -1714,6 +1868,33 @@ export function lowerArrayReduceCall(lowerer, call, access, method, elem) {
         args.push(fast);
     return { kind: "call", callee: helper, args, type: accT, loc };
 }
+/** The accumulator's value as the callback's first parameter declares it.
+ * Equal types pass the local straight through; a dynamic accumulator handed
+ * to a typed parameter converts at the call (the callback is lowered first,
+ * so its ABI is a fact and a value of another kind throws — "types don't
+ * lie"). */
+function accumulatorArgument(lowerer, param, accT, loc) {
+    const value = varRef("acc.0", accT, loc);
+    return param === undefined || typeEquals(param, accT)
+        ? value
+        : lowerer.coerceToExpected(value, param);
+}
+/** Whether the checker's accumulator type stores the callback's answer
+ * itself. A scalar accumulator holds only its own scalar, and a void answer
+ * (a callback with no return statement) is `undefined`; both leave the
+ * checker's type unable to carry the value (a program the checker already
+ * diagnosed), which the reduction accumulates dynamically instead of
+ * miscasting. Every other pair keeps `coerceToExpected`'s static plan. */
+function accumulatorAdmitsAnswer(lowerer, accT, fnRet) {
+    if (lowerer.coercibleValue(fnRet, accT))
+        return true;
+    if (fnRet.kind === "void" || isUnitType(fnRet))
+        return false;
+    return !(scalarKind(accT) && scalarKind(fnRet));
+}
+function scalarKind(t) {
+    return t.kind === "f64" || t.kind === "string" || t.kind === "bool";
+}
 /** The reduce/reduceRight loops, from existing IR nodes:
  *
  *   with init:    acc = z; n = a.length; for (...) acc = f(acc, a[i]); return acc;
@@ -1724,14 +1905,23 @@ export 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 exact message. */
-function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, site = "", fastT = null, unread = false) {
+function reduceHelper(lowerer, method, elem, accT, fnArg, hasInit, loc, site = "", fastT = null, unread = false) {
+    // The callback's own ABI decides the helper's `f` slot: a dynamic
+    // accumulator (accT) is coerced at the call and the store, so the closure
+    // keeps the parameter types its lowering produced.
+    const fnT = fnArg;
+    const fnRet = fnT.ret;
+    const arity = fnT.params.length;
     const key = `${method}:${typeKey(elem)}:${typeKey(accT)}:${typeKey(fnRet)}:${arity}:${hasInit ? "init" : "seed"}${site}${fastT ? ":split" : ""}${unread ? ":unread" : ""}`;
     const existing = lowerer.arrHofHelpers.get(key);
     if (existing)
         return existing;
     const name = keyedHelperName(lowerer, `%arr.${method}`, key);
     lowerer.arrHofHelpers.set(key, name);
-    if (method === "reduce")
+    // A dynamic accumulator stays out of the pipeline registry: the fused
+    // loops type their accumulator from the checker's view (arrHofInfo), which
+    // this shape contradicts.
+    if (method === "reduce" && accT.kind !== "dyn")
         lowerer.arrHofInfo.set(name, {
             method,
             elem,
@@ -1744,7 +1934,6 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
             unread,
         });
     const arrT = arrayOf(elem);
-    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";
@@ -1861,7 +2050,12 @@ function reduceHelper(lowerer, method, elem, accT, fnRet, arity, hasInit, loc, s
                         value: lowerer.coerceToExpected({
                             kind: "callValue",
                             callee: varRef("f.0", fnT, loc),
-                            args: [varRef("acc.0", accT, loc), visited(), i, varRef("a.0", arrT, loc)].slice(0, arity),
+                            args: [
+                                accumulatorArgument(lowerer, fnT.params[0], accT, loc),
+                                visited(),
+                                i,
+                                varRef("a.0", arrT, loc),
+                            ].slice(0, arity),
                             type: fnRet,
                             loc,
                         }, accT),
@@ -1985,16 +2179,20 @@ export function lowerArraySortCall(lowerer, call, access, elem, arrT) {
     }
     let fnArg = undefinedArg ?? lowerOptionalElementComparator(lowerer, argNode, unwrappedArg, elem, arrT);
     // Reusable JS comparators often accept checked values. Adapt the array's
-    // element ABI just as other array callbacks do before sorting.
+    // element ABI just as other array callbacks do before sorting. A
+    // comparator declaring MORE parameters than sort passes (`(a, b, loose?)`,
+    // the imported semver shape) receives the surplus ones as undefined — the
+    // completion an ordinary two-argument call performs — so it adapts to the
+    // (a, b) slot like any other wider signature.
     if (fnArg.type.kind === "func" &&
-        fnArg.type.params.length <= 2 &&
-        fnArg.type.params.every((param) => lowerer.coercibleValue(elem, param))) {
+        fnArg.type.params.slice(2).every((param) => omittableTrailingParam(lowerer, param)) &&
+        fnArg.type.params.slice(0, 2).every((param) => lowerer.coercibleValue(elem, param))) {
         // Arithmetic on inferred JS values retains a checked result because
         // it can produce BigInt. The sort callback still requires a number.
         const result = fnArg.type.ret.kind === "dyn" && isJsSourceFile(ts.getSourceFileOfNode(argNode))
             ? F64
             : fnArg.type.ret;
-        const expected = funcOf(fnArg.type.params.map(() => elem), result);
+        const expected = funcOf(fnArg.type.params.slice(0, 2).map(() => elem), result);
         if (!typeEquals(fnArg.type, expected))
             fnArg = lowerer.coerceToExpected(fnArg, expected);
     }