@scriptc/compiler 0.2.10 → 0.3.1

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

@@ -0,0 +1,1827 @@
+import { boolLit, countedFor, numLit, varRef } from "../../../ir/build.js";
+import { BOOL, F64, VOID, typeEquals, typeKey, } from "../../../ir/ir.js";
+import { everyExprChild, everyStmtChild, everyStmtList, transformStmtList, } from "../../../ir/traverse.js";
+import { arrayIndexPresent, arrayValueRead, arrayValueStore, arrayValueType, } from "../array-values.js";
+const PRODUCERS = new Set(["map", "filter", "flatMap", "flatMapArray"]);
+const TERMINALS = new Set([
+    "reduce",
+    "some",
+    "every",
+    "findIndex",
+    "forEach",
+]);
+function emptyEffects() {
+    return { throws: false, loops: false, reads: new Set(), writes: new Set() };
+}
+function mergeEffects(into, from) {
+    into.throws ||= from.throws;
+    into.loops ||= from.loops;
+    for (const id of from.reads)
+        into.reads.add(id);
+    for (const id of from.writes)
+        into.writes.add(id);
+}
+const PURE_MATH = new Set([
+    "math.abs",
+    "math.acos",
+    "math.acosh",
+    "math.asin",
+    "math.asinh",
+    "math.atan",
+    "math.atan2",
+    "math.atanh",
+    "math.cbrt",
+    "math.ceil",
+    "math.clz32",
+    "math.cos",
+    "math.cosh",
+    "math.exp",
+    "math.expm1",
+    "math.floor",
+    "math.fround",
+    "math.imul",
+    "math.log",
+    "math.log10",
+    "math.log1p",
+    "math.log2",
+    "math.max",
+    "math.min",
+    "math.pow",
+    "math.round",
+    "math.sign",
+    "math.sin",
+    "math.sinh",
+    "math.sqrt",
+    "math.tan",
+    "math.tanh",
+    "math.trunc",
+]);
+/** String methods that cannot throw or call user code on string/number
+ * arguments. */
+const PURE_STRING = new Set([
+    "length",
+    "charCodeAt",
+    "charAt",
+    "indexOf",
+    "includes",
+    "startsWith",
+    "endsWith",
+    "slice",
+    "substring",
+    "trim",
+    "trimStart",
+    "trimEnd",
+    "toLowerCase",
+    "toUpperCase",
+    "isWellFormed",
+    "toWellFormed",
+    "cpAt",
+]);
+function primitive(t) {
+    return t.kind === "f64" || t.kind === "string" || t.kind === "bool";
+}
+class CallbackEffects {
+    fns;
+    /** The unique function that creates each closure, or null when several do. */
+    creators = new Map();
+    memo = new Map();
+    active = new Set();
+    globals;
+    constructor(functions, globals) {
+        this.fns = new Map(functions.map((fn) => [fn.name, fn]));
+        this.globals = new Map(globals.map((g) => [g.id, g]));
+        for (const fn of functions) {
+            everyStmtList(fn.body, {
+                expr: (e) => {
+                    if (e.kind === "closure") {
+                        const prior = this.creators.get(e.fnName);
+                        this.creators.set(e.fnName, prior === undefined || prior === fn ? fn : null);
+                    }
+                    return true;
+                },
+                stmt: () => true,
+            });
+        }
+    }
+    fn(name) {
+        return this.fns.get(name);
+    }
+    scope(fn, all) {
+        return {
+            fn,
+            locals: new Map(fn.locals.map((l) => [l.id, l])),
+            captures: new Set((fn.captures ?? []).map((c) => c.localId)),
+            all,
+        };
+    }
+    /** Effects of calling `fn`, or null when they are not modeled. */
+    ofFunction(fn) {
+        const cached = this.memo.get(fn.name);
+        if (cached !== undefined)
+            return cached;
+        if (this.active.has(fn.name))
+            return null; // recursion
+        if (fn.async || fn.generator || fn.classCaptures?.length) {
+            this.memo.set(fn.name, null);
+            return null;
+        }
+        this.active.add(fn.name);
+        const effects = emptyEffects();
+        const scope = this.scope(fn, false);
+        const ok = fn.body.every((s) => this.stmt(s, scope, effects));
+        this.active.delete(fn.name);
+        const result = ok ? effects : null;
+        this.memo.set(fn.name, result);
+        return result;
+    }
+    /** Effects of evaluating `e` in `scope`; false when not modeled. */
+    expr(e, scope, out) {
+        const child = (c) => this.expr(c, scope, out);
+        const stmt = (s) => this.stmt(s, scope, out);
+        switch (e.kind) {
+            case "numLit":
+            case "strLit":
+            case "boolLit":
+            case "unitLit":
+                return true;
+            case "varRef":
+                return this.read(e.localId, scope, out);
+            case "assignExpr":
+                return this.write(e.localId, scope, out) && child(e.value);
+            case "incDec":
+                return this.read(e.localId, scope, out) && this.write(e.localId, scope, out);
+            case "bin":
+                return (e.left.type.kind !== "bigint" &&
+                    e.right.type.kind !== "bigint" &&
+                    child(e.left) &&
+                    child(e.right));
+            case "logical":
+            case "ternary":
+            case "nullish":
+            case "strConcat":
+            case "strEq":
+            case "strCmp":
+            case "toBool":
+            case "recordGet":
+            case "recordLit":
+            case "recordClone":
+            case "fieldGet":
+            case "unionWrap":
+            case "unionNarrow":
+            case "unionIsTag":
+            case "unionDisc":
+            case "upcast":
+            case "seqExpr":
+                return everyExprChild(e, child, stmt);
+            case "unary":
+                return primitive(e.operand.type) && child(e.operand);
+            case "toString":
+                return (primitive(e.operand.type) || e.operand.type.kind === "union") && child(e.operand);
+            case "arrayLit":
+                return !e.spreads?.length && everyExprChild(e, child, stmt);
+            case "arrIntrinsic":
+                return e.method === "length" && e.receiver.type.kind === "array" && child(e.receiver);
+            case "strIntrinsic":
+                return (PURE_STRING.has(e.method) &&
+                    e.args.every((a) => a.type.kind === "f64" || a.type.kind === "string") &&
+                    everyExprChild(e, child, stmt));
+            case "libCall":
+                if (e.fn === "error.nodeThrow") {
+                    out.throws = true;
+                    return everyExprChild(e, child, stmt);
+                }
+                if (e.fn === "error.new")
+                    return everyExprChild(e, child, stmt);
+                return PURE_MATH.has(e.fn) && everyExprChild(e, child, stmt);
+            case "closure":
+                return !e.adapts;
+            case "call": {
+                const callee = this.fns.get(e.callee);
+                if (!callee || callee.captures?.length)
+                    return false;
+                const effects = this.ofFunction(callee);
+                if (!effects)
+                    return false;
+                mergeEffects(out, effects);
+                return e.args.every(child);
+            }
+            case "callValue": {
+                if (e.receiver)
+                    return false;
+                const callee = this.resolve(e.callee, scope.fn, 0);
+                if (!callee)
+                    return false;
+                const effects = this.ofFunction(callee);
+                if (!effects)
+                    return false;
+                mergeEffects(out, effects);
+                return child(e.callee) && e.args.every(child);
+            }
+            default:
+                return false;
+        }
+    }
+    stmt(s, scope, out) {
+        const child = (c) => this.expr(c, scope, out);
+        const stmt = (c) => this.stmt(c, scope, out);
+        switch (s.kind) {
+            case "varDecl":
+                return s.init === null || child(s.init);
+            case "assign":
+                return this.write(s.localId, scope, out) && child(s.value);
+            case "throw":
+                out.throws = true;
+                return child(s.value);
+            case "while":
+            case "doWhile":
+            case "for":
+                out.loops = true;
+                return everyStmtChild(s, child, stmt);
+            case "exprStmt":
+            case "return":
+            case "if":
+            case "block":
+            case "break":
+            case "continue":
+                return everyStmtChild(s, child, stmt);
+            default:
+                return false;
+        }
+    }
+    read(id, scope, out) {
+        const local = scope.locals.get(id);
+        if (local) {
+            if (local.tdz)
+                out.throws = true;
+            if (scope.all || scope.captures.has(id))
+                out.reads.add(id);
+            return true;
+        }
+        const global = this.globals.get(id);
+        if (!global)
+            return false;
+        if (global.tdz || global.initFlag)
+            out.throws = true;
+        out.reads.add(id);
+        return true;
+    }
+    write(id, scope, out) {
+        const local = scope.locals.get(id);
+        if (local) {
+            if (local.tdz)
+                out.throws = true;
+            if (scope.all || scope.captures.has(id))
+                out.writes.add(id);
+            return true;
+        }
+        const global = this.globals.get(id);
+        if (!global)
+            return false;
+        if (global.tdz || global.initFlag)
+            out.throws = true;
+        out.writes.add(id);
+        return true;
+    }
+    /** The one function a function-valued expression evaluated in `fn` can
+     * hold: a closure literal, or a never-reassigned binding initialized by
+     * one (directly, or through a call whose every return is the same
+     * closure literal). Null when unknown. */
+    resolve(e, fn, depth) {
+        if (depth > 4)
+            return null;
+        if (e.kind === "closure") {
+            const target = this.fns.get(e.fnName);
+            return target && !e.adapts ? target : null;
+        }
+        if (e.kind !== "varRef")
+            return null;
+        const id = e.localId;
+        if (!fn.locals.some((l) => l.id === id))
+            return null;
+        if (fn.params.some((p) => p.localId === id))
+            return null;
+        if ((fn.captures ?? []).some((c) => c.localId === id)) {
+            const creator = this.creators.get(fn.name);
+            return creator ? this.resolveBinding(id, creator, depth + 1) : null;
+        }
+        return this.resolveBinding(id, fn, depth + 1);
+    }
+    resolveBinding(id, fn, depth) {
+        const local = fn.locals.find((l) => l.id === id);
+        if (!local || local.mutable || local.tdz)
+            return null;
+        if (fn.params.some((p) => p.localId === id))
+            return null;
+        let init = null;
+        let definitions = 0;
+        everyStmtList(fn.body, {
+            expr: (node) => {
+                if ((node.kind === "assignExpr" || node.kind === "incDec") && node.localId === id)
+                    definitions += 2;
+                return true;
+            },
+            stmt: (node) => {
+                if (node.kind === "varDecl" && node.localId === id) {
+                    definitions++;
+                    init = node.init;
+                }
+                else if ((node.kind === "assign" || node.kind === "forOf") && node.localId === id) {
+                    definitions += 2;
+                }
+                return true;
+            },
+        });
+        const value = init;
+        if (definitions !== 1 || value === null)
+            return null;
+        return this.resolveValue(value, fn, depth);
+    }
+    resolveValue(e, fn, depth) {
+        if (e.kind === "closure" || e.kind === "varRef")
+            return this.resolve(e, fn, depth);
+        if (e.kind !== "call")
+            return null;
+        const factory = this.fns.get(e.callee);
+        if (!factory || factory.captures?.length || factory.async || factory.generator)
+            return null;
+        let target = null;
+        let returns = 0;
+        const ok = everyStmtList(factory.body, {
+            expr: () => true,
+            stmt: (node) => {
+                if (node.kind !== "return")
+                    return true;
+                returns++;
+                const value = node.value;
+                if (value?.kind !== "closure" || value.adapts)
+                    return false;
+                if (target !== null && target !== value.fnName)
+                    return false;
+                target = value.fnName;
+                return true;
+            },
+        });
+        const name = target;
+        if (!ok || returns === 0 || name === null)
+            return null;
+        return this.fns.get(name) ?? null;
+    }
+}
+function isFunc(e) {
+    return e !== undefined && e.type.kind === "func";
+}
+function stageOf(lowerer, e) {
+    if (e.kind !== "call")
+        return null;
+    const info = lowerer.arrHofInfo.get(e.callee);
+    if (!info)
+        return null;
+    const expected = 2 + (info.method === "reduce" && info.hasInit ? 1 : 0) + (info.split ? 1 : 0);
+    if (e.args.length !== expected)
+        return null;
+    const receiver = e.args[0];
+    const slow = e.args[1];
+    const fast = info.split ? e.args[e.args.length - 1] : undefined;
+    if (!isFunc(slow) || (info.split && !isFunc(fast)))
+        return null;
+    if (receiver.type.kind !== "array" || !typeEquals(receiver.type.elem, info.elem))
+        return null;
+    return {
+        stage: { info, slow, fast: fast && isFunc(fast) ? fast : null, loc: e.loc },
+        receiver,
+    };
+}
+function matchChain(lowerer, e) {
+    let terminal;
+    let receiver;
+    const stages = [];
+    if (e.kind === "arrIntrinsic" && e.method === "length" && e.args.length === 0) {
+        if (e.receiver.type.kind !== "array")
+            return null;
+        terminal = { kind: "length" };
+        receiver = e.receiver;
+    }
+    else {
+        const top = stageOf(lowerer, e);
+        if (!top)
+            return null;
+        receiver = top.receiver;
+        if (TERMINALS.has(top.stage.info.method)) {
+            const init = top.stage.info.method === "reduce" && top.stage.info.hasInit && e.kind === "call"
+                ? e.args[2]
+                : null;
+            terminal = { kind: "call", stage: top.stage, init };
+        }
+        else if (PRODUCERS.has(top.stage.info.method)) {
+            terminal = { kind: "collect" };
+            stages.push(top.stage);
+        }
+        else
+            return null;
+    }
+    for (;;) {
+        const inner = stageOf(lowerer, receiver);
+        if (!inner || !PRODUCERS.has(inner.stage.info.method))
+            break;
+        stages.unshift(inner.stage);
+        receiver = inner.receiver;
+    }
+    let slice = null;
+    if (receiver.kind === "arrIntrinsic" &&
+        receiver.method === "slice" &&
+        receiver.args.length <= 2 &&
+        receiver.receiver.type.kind === "array" &&
+        receiver.type.kind === "array" &&
+        typeEquals(receiver.type, receiver.receiver.type) &&
+        receiver.args.every((a) => a.type.kind === "f64")) {
+        slice = { start: receiver.args[0] ?? null, end: receiver.args[1] ?? null };
+        receiver = receiver.receiver;
+    }
+    if (receiver.type.kind !== "array")
+        return null;
+    const removed = stages.length + (slice ? 1 : 0) - (terminal.kind === "collect" ? 1 : 0);
+    if (removed < 1)
+        return null;
+    return {
+        source: receiver,
+        sourceType: receiver.type,
+        slice,
+        stages,
+        terminal,
+        type: e.type,
+        loc: e.loc,
+    };
+}
+/** Fuse chains of array-HOF helper calls into one loop.
+ *
+ * `xs.filter(f).map(g).reduce(h, z)` lowers to nested helper calls, each
+ * materializing a full intermediate array. When every callback's effects
+ * are modeled (see CallbackEffects) and reordering them cannot be
+ * observed, the chain becomes one synthetic helper that runs each element
+ * through all stages before reading the next, and never builds the
+ * intermediate arrays. The rules, from strictest to weakest need:
+ *
+ * - No callback writes the heap, calls host code or an unknown function,
+ *   or recurses. Allocation and reads are fine: with no heap writes, every
+ *   read sees the same value in either order.
+ * - Callbacks may assign shared bindings (captured locals, globals), but
+ *   no other callback in the chain reads or assigns those bindings.
+ * - At most one callback may throw (or contain a loop, which might not
+ *   terminate); if one does, no other callback assigns anything. A throw
+ *   then leaves the same observable state in either order.
+ * - some/every/findIndex stop early, so the stages before them must not
+ *   throw, loop or assign at all: the unfused chain would have run them on
+ *   every element.
+ * - Index parameters receive the position in the array the unfused
+ *   stage would have visited: the source index while only maps (which
+ *   keep holes in place) precede it, else a count of the values that
+ *   reached the stage. Only the first stage over an unsliced source may
+ *   take the array parameter; any other would name an intermediate array.
+ * - Holes: map and slice preserve them, filter/flatMap drop them; every
+ *   consumer here skips them except findIndex, which is not fused when a
+ *   hole can reach it. Lengths are read once, before any callback, and no
+ *   callback can write an array.
+ *
+ * A `const` holding a chain that is read once, as the receiver of the next
+ * statement's consumer, is folded into that consumer when the rest of that
+ * statement is free of effects. */
+export function fuseArrayPipelines(lowerer, functions) {
+    if (lowerer.arrHofInfo.size === 0)
+        return;
+    const pass = new PipelineFusion(lowerer, functions);
+    for (const fn of functions.slice())
+        pass.run(fn);
+    functions.push(...pass.added);
+}
+class PipelineFusion {
+    lowerer;
+    added = [];
+    effects;
+    helpers = new Map();
+    constructor(lowerer, functions) {
+        this.lowerer = lowerer;
+        this.effects = new CallbackEffects(functions, lowerer.globalsList);
+    }
+    run(fn) {
+        const infos = this.lowerer.arrHofInfo;
+        const candidate = !everyStmtList(fn.body, {
+            expr: (e) => !(e.kind === "call" && infos.has(e.callee)),
+            stmt: () => true,
+        });
+        if (!candidate)
+            return;
+        const removed = new Set();
+        let body = this.lists(fn.body, fn, removed);
+        body = transformStmtList(body, {
+            stmt: (s) => s,
+            expr: (e) => this.fuse(e, fn) ?? e,
+        });
+        fn.body = body;
+        if (removed.size > 0)
+            fn.locals = fn.locals.filter((l) => !removed.has(l.id));
+    }
+    /* ── statement lists: fold single-use chain bindings ── */
+    lists(list, fn, removed) {
+        const nested = list.map((s) => this.nested(s, fn, removed));
+        const out = [];
+        for (let i = 0; i < nested.length; i++) {
+            let current = nested[i];
+            while (i + 1 < nested.length) {
+                const merged = this.fold(current, nested[i + 1], fn);
+                if (!merged)
+                    break;
+                removed.add(current.localId);
+                current = merged;
+                i++;
+            }
+            out.push(current);
+        }
+        return out;
+    }
+    nested(s, fn, removed) {
+        const l = (body) => this.lists(body, fn, removed);
+        switch (s.kind) {
+            case "if":
+                return { ...s, then: l(s.then), else_: s.else_ === null ? null : l(s.else_) };
+            case "while":
+            case "doWhile":
+            case "for":
+            case "forOf":
+            case "block":
+                return { ...s, body: l(s.body) };
+            case "switch":
+                return { ...s, cases: s.cases.map((c) => ({ ...c, body: l(c.body) })) };
+            case "tryCatch":
+                return {
+                    ...s,
+                    tryBody: l(s.tryBody),
+                    catchBody: s.catchBody === null ? null : l(s.catchBody),
+                    finallyBody: s.finallyBody === null ? null : l(s.finallyBody),
+                };
+            default:
+                return s;
+        }
+    }
+    /** `const L = <chain>; <stmt using L once as a consumer receiver>`. */
+    fold(decl, next, fn) {
+        if (decl.kind !== "varDecl" || decl.init === null)
+            return null;
+        const init = decl.init;
+        const id = decl.localId;
+        const local = fn.locals.find((l) => l.id === id);
+        if (!local || local.boxed || local.tdz || !typeEquals(local.type, init.type))
+            return null;
+        if (!matchChain(this.lowerer, init) && !stageOf(this.lowerer, init)) {
+            if (!(init.kind === "arrIntrinsic" && init.method === "slice"))
+                return null;
+        }
+        if (useCount(fn, id) !== 1)
+            return null;
+        // Only expression statements whose value is computed before any store.
+        let root;
+        switch (next.kind) {
+            case "varDecl":
+                if (next.init === null)
+                    return null;
+                root = next.init;
+                break;
+            case "assign":
+                root = next.value;
+                break;
+            case "exprStmt":
+                root = next.expr;
+                break;
+            case "return":
+                if (next.value === null)
+                    return null;
+                root = next.value;
+                break;
+            default:
+                return null;
+        }
+        const site = locateUse(this.lowerer, root, id);
+        if (!site)
+            return null;
+        const substituted = substituteReceiver(site.node, init);
+        // The chain now runs after the rest of `next`'s operands are evaluated;
+        // those must not observe or change anything the chain touches.
+        const plan = this.plan(substituted, fn);
+        const chainArgs = matchChain(this.lowerer, substituted);
+        if (!plan || !chainArgs)
+            return null;
+        if (site.conditional && (plan.risky || plan.writes.size > 0))
+            return null;
+        const scope = this.effects.scope(fn, true);
+        const rest = emptyEffects();
+        const placeholder = { kind: "numLit", value: 0, type: F64, loc: site.node.loc };
+        if (!this.effects.expr(replaceNode(root, site.node, placeholder), scope, rest))
+            return null;
+        if (rest.throws || rest.writes.size > 0 || intersects(rest.reads, plan.writes))
+            return null;
+        const moved = emptyEffects();
+        const movedArgs = [chainArgs.source];
+        if (chainArgs.slice?.start)
+            movedArgs.push(chainArgs.slice.start);
+        if (chainArgs.slice?.end)
+            movedArgs.push(chainArgs.slice.end);
+        if (!movedArgs.every((a) => this.effects.expr(a, scope, moved)))
+            return null;
+        if (moved.throws || moved.writes.size > 0 || moved.loops)
+            return null;
+        const value = replaceNode(root, site.node, substituted);
+        switch (next.kind) {
+            case "varDecl":
+                return { ...next, init: value };
+            case "assign":
+                return { ...next, value };
+            case "exprStmt":
+                return { ...next, expr: value };
+            case "return":
+                return { ...next, value };
+        }
+        return null;
+    }
+    /* ── expressions ── */
+    fuse(e, fn) {
+        const plan = this.plan(e, fn);
+        return plan ? this.emit(plan) : null;
+    }
+    /** Decide whether `e` is a fusable chain; null when it is not. */
+    plan(e, fn) {
+        const chain = matchChain(this.lowerer, e);
+        if (!chain)
+            return null;
+        const { stages, terminal } = chain;
+        const terminalStage = terminal.kind === "call" ? terminal.stage : null;
+        const callbacks = terminalStage ? [...stages, terminalStage] : stages;
+        // Element types must line up stage to stage.
+        let elem = chain.sourceType.elem;
+        for (const stage of callbacks) {
+            if (!typeEquals(stage.info.elem, elem))
+                return null;
+            if (stage.info.method === "filter" && !typeEquals(stage.info.outElem, stage.info.elem))
+                return null;
+            if ((stage.info.method === "map" || stage.info.method === "flatMap") &&
+                !typeEquals(stage.info.outElem, stage.info.fnRet))
+                return null;
+            elem = stage.info.outElem;
+        }
+        // Index arguments are reproduced; an array argument only names the source.
+        for (let k = 0; k < callbacks.length; k++) {
+            const stage = callbacks[k];
+            const lead = stage.info.method === "reduce" ? 1 : 0;
+            if (stage.info.arity > lead + 3)
+                return null;
+            if (stage.info.arity === lead + 3 && (k !== 0 || chain.slice))
+                return null;
+        }
+        if (terminalStage?.info.method === "reduce" && !terminalStage.info.hasInit)
+            return null;
+        const holes = holeCarrying(chain);
+        if (terminalStage?.info.method === "findIndex" && holes)
+            return null;
+        // Effects of each callback, in chain order.
+        const scope = this.effects.scope(fn, true);
+        const summaries = [];
+        const argReads = emptyEffects();
+        for (const stage of callbacks) {
+            for (const arg of [stage.slow, stage.fast]) {
+                if (!arg)
+                    continue;
+                if (!this.effects.expr(arg, scope, argReads))
+                    return null;
+            }
+            const target = this.effects.resolve(stage.fast ?? stage.slow, fn, 0);
+            const summary = target ? this.effects.ofFunction(target) : null;
+            if (!summary)
+                return null;
+            if (stage.fast) {
+                const slow = this.effects.resolve(stage.slow, fn, 0);
+                const slowSummary = slow ? this.effects.ofFunction(slow) : null;
+                if (!slowSummary)
+                    return null;
+                mergeEffects(summary, slowSummary);
+            }
+            summaries.push(summary);
+        }
+        if (argReads.throws || argReads.writes.size > 0)
+            return null;
+        const init = terminal.kind === "call" ? terminal.init : null;
+        if (init) {
+            if (!this.effects.expr(init, scope, argReads))
+                return null;
+            if (argReads.throws || argReads.writes.size > 0 || argReads.loops)
+                return null;
+        }
+        const writes = new Set();
+        let riskyCount = 0;
+        for (const s of summaries) {
+            for (const id of s.writes)
+                writes.add(id);
+            if (s.throws || s.loops)
+                riskyCount++;
+        }
+        if (riskyCount > 1)
+            return null;
+        for (let j = 0; j < summaries.length; j++) {
+            const sj = summaries[j];
+            if (riskyCount === 1 && !(sj.throws || sj.loops) && sj.writes.size > 0)
+                return null;
+            for (let k = 0; k < summaries.length; k++) {
+                if (j === k)
+                    continue;
+                const sk = summaries[k];
+                if (intersects(sj.writes, sk.reads) || intersects(sj.writes, sk.writes))
+                    return null;
+            }
+        }
+        if (intersects(argReads.reads, writes))
+            return null;
+        const early = terminalStage !== null &&
+            (terminalStage.info.method === "some" ||
+                terminalStage.info.method === "every" ||
+                terminalStage.info.method === "findIndex");
+        if (early) {
+            for (let k = 0; k < stages.length; k++) {
+                const s = summaries[k];
+                if (s.throws || s.loops || s.writes.size > 0)
+                    return null;
+            }
+        }
+        return { chain, callbacks, writes, risky: riskyCount > 0 };
+    }
+    /* ── helper construction ── */
+    /** A closure-literal callback whose body can be copied into the loop:
+     * small, no nested closures, and its captured bindings only read (they
+     * are passed in by value, read when the fused call starts; no callback
+     * in the chain assigns a binding another one reads). */
+    inlineTarget = (arg) => {
+        if (arg.kind !== "closure" || arg.adapts)
+            return null;
+        const fn = this.effects.fn(arg.fnName);
+        if (!fn || fn.async || fn.generator || fn.classCaptures?.length)
+            return null;
+        const captures = new Set((fn.captures ?? []).map((c) => c.localId));
+        if (captures.size !== arg.captures.length)
+            return null;
+        const effects = this.effects.ofFunction(fn);
+        if (!effects || intersects(effects.writes, captures))
+            return null;
+        if (fn.locals.some((l) => l.tdz || (l.boxed && !captures.has(l.id))))
+            return null;
+        let size = 0;
+        const small = everyStmtList(fn.body, {
+            expr: (e) => ++size <= MAX_INLINE_NODES && e.kind !== "closure" && e.kind !== "selfRef",
+            stmt: (s) => ++size <= MAX_INLINE_NODES && s.kind !== "tryCatch",
+        });
+        return small ? fn : null;
+    };
+    emit(plan) {
+        const built = new FusedLoop(this.lowerer, plan.chain, this.inlineTarget).build();
+        if (!built)
+            return null;
+        let name = this.helpers.get(built.key);
+        if (!name) {
+            name = `%arr.fused.${this.helpers.size}`;
+            this.helpers.set(built.key, name);
+            this.added.push({ ...built.fn, name });
+        }
+        return {
+            kind: "call",
+            callee: name,
+            args: built.args,
+            type: plan.chain.type,
+            loc: plan.chain.loc,
+        };
+    }
+}
+function intersects(a, b) {
+    for (const id of a)
+        if (b.has(id))
+            return true;
+    return false;
+}
+/** Map and slice keep holes in place; filter and flatMap drop them. */
+function holeCarrying(chain) {
+    return chain.stages.every((s) => s.info.method === "map");
+}
+function useCount(fn, id) {
+    let uses = 0;
+    everyStmtList(fn.body, {
+        expr: (e) => {
+            switch (e.kind) {
+                case "varRef":
+                case "assignExpr":
+                case "incDec":
+                    if (e.localId === id)
+                        uses++;
+                    break;
+                case "closure":
+                    if (e.captures.includes(id))
+                        uses += 2;
+                    break;
+            }
+            return true;
+        },
+        stmt: (s) => {
+            if ((s.kind === "assign" || s.kind === "forOf") && s.localId === id)
+                uses += 2;
+            if (s.kind === "varDecl" && s.localId === id && s.init === null)
+                uses += 2;
+            return true;
+        },
+    });
+    return uses;
+}
+/** The consumer node in `root` whose receiver is `varRef id`, and whether
+ * it is evaluated only conditionally. */
+function locateUse(lowerer, root, id) {
+    let found = null;
+    const isUse = (e) => {
+        const receiver = e.kind === "arrIntrinsic" && e.method === "length"
+            ? e.receiver
+            : e.kind === "call" && lowerer.arrHofInfo.has(e.callee)
+                ? e.args[0]
+                : undefined;
+        return receiver?.kind === "varRef" && receiver.localId === id;
+    };
+    const walk = (e, conditional) => {
+        if (isUse(e)) {
+            found = { node: e, conditional };
+            return false;
+        }
+        const branching = conditional ||
+            e.kind === "ternary" ||
+            e.kind === "logical" ||
+            e.kind === "nullish" ||
+            e.kind === "orDefault" ||
+            e.kind === "optChain" ||
+            e.kind === "seqExpr" ||
+            e.kind === "closure";
+        return everyExprChild(e, (c) => walk(c, branching && !(e.kind === "ternary" && c === e.cond)), () => true);
+    };
+    walk(root, false);
+    return found;
+}
+function substituteReceiver(node, receiver) {
+    if (node.kind === "arrIntrinsic")
+        return { ...node, receiver };
+    if (node.kind === "call")
+        return { ...node, args: [receiver, ...node.args.slice(1)] };
+    return node;
+}
+function replaceNode(root, target, replacement) {
+    if (root === target)
+        return replacement;
+    return transformExprOnce(root, target, replacement);
+}
+function transformExprOnce(root, target, replacement) {
+    const [stmt] = transformStmtList([{ kind: "exprStmt", expr: root, loc: root.loc }], {
+        stmt: (s) => s,
+        expr: (e) => (e === target ? replacement : e),
+    });
+    return stmt.expr;
+}
+const MAX_INLINE_NODES = 400;
+class FusedLoop {
+    lowerer;
+    chain;
+    inlineTarget;
+    params = [];
+    locals = [];
+    args = [];
+    keyParts = [];
+    callees = [];
+    loc;
+    next = 0;
+    failed = false;
+    constructor(lowerer, chain, inlineTarget) {
+        this.lowerer = lowerer;
+        this.chain = chain;
+        this.inlineTarget = inlineTarget;
+        this.loc = chain.loc;
+    }
+    fresh(name) {
+        return `${name}.${this.next++}`;
+    }
+    local(name, type, mutable = false) {
+        const id = this.fresh(name);
+        this.locals.push({ id, name, type, mutable });
+        return id;
+    }
+    param(name, value, key) {
+        const id = this.fresh(name);
+        this.params.push({ localId: id, name, type: value.type });
+        this.locals.push({ id, name, type: value.type, mutable: false });
+        this.args.push(value);
+        this.keyParts.push(`${key}:${typeKey(value.type)}`);
+        return varRef(id, value.type, this.loc);
+    }
+    /** How the loop reaches one callback argument; decided at first use. */
+    callee(arg) {
+        const known = this.callees.find((c) => c.arg === arg);
+        if (known)
+            return known;
+        const target = this.inlineTarget(arg);
+        let callee;
+        if (target && arg.kind === "closure") {
+            const captures = new Map();
+            (target.captures ?? []).forEach((capture, index) => {
+                const source = arg.captures[index];
+                const ref = this.param("cap", varRef(source, capture.type, this.loc), `cap@${target.name}`);
+                captures.set(capture.localId, ref.localId);
+            });
+            this.keyParts.push(`inline@${target.name}`);
+            callee = { arg, ref: null, inline: target, captures };
+        }
+        else {
+            const site = arg.kind === "closure" ? `@${arg.fnName}` : "";
+            callee = { arg, ref: this.param("f", arg, `cb${site}`), inline: null, captures: null };
+        }
+        this.callees.push(callee);
+        return callee;
+    }
+    /** Statements and the value of calling `callee` with `args`. */
+    invoke(callee, args, ret) {
+        const loc = this.loc;
+        if (!callee.inline) {
+            return {
+                pre: [],
+                value: { kind: "callValue", callee: callee.ref, args, type: ret, loc },
+            };
+        }
+        const fn = callee.inline;
+        if (fn.params.length !== args.length) {
+            this.failed = true;
+            return { pre: [], value: { kind: "numLit", value: 0, type: F64, loc } };
+        }
+        const renamed = new Map(callee.captures);
+        // A parameter the body never assigns can name its argument's local
+        // directly: the loop's value locals are not assigned while the
+        // inlined body runs.
+        const assigned = new Set();
+        everyStmtList(fn.body, {
+            expr: (e) => {
+                if (e.kind === "assignExpr" || e.kind === "incDec")
+                    assigned.add(e.localId);
+                return true;
+            },
+            stmt: (st) => {
+                if (st.kind === "assign" || st.kind === "forOf")
+                    assigned.add(st.localId);
+                return true;
+            },
+        });
+        const aliased = new Set();
+        fn.params.forEach((p, index) => {
+            const arg = args[index];
+            if (arg.kind === "varRef" && !assigned.has(p.localId) && typeEquals(arg.type, p.type)) {
+                renamed.set(p.localId, arg.localId);
+                aliased.add(p.localId);
+            }
+        });
+        for (const l of fn.locals) {
+            if (renamed.has(l.id))
+                continue;
+            const id = this.local(l.name, l.type, true);
+            renamed.set(l.id, id);
+        }
+        const labels = new Map();
+        const exit = this.fresh("%fused.exit");
+        const label = (name) => {
+            let id = labels.get(name);
+            if (!id) {
+                id = this.fresh("%fused.label");
+                labels.set(name, id);
+            }
+            return id;
+        };
+        const result = fn.returnType.kind === "void" ? null : this.local("ret", fn.returnType, true);
+        const rename = (id) => renamed.get(id) ?? id;
+        const body = transformStmtList(fn.body, {
+            expr: (e) => {
+                switch (e.kind) {
+                    case "varRef":
+                    case "incDec":
+                    case "assignExpr":
+                        return { ...e, localId: rename(e.localId) };
+                    default:
+                        return e;
+                }
+            },
+            stmt: (s) => {
+                switch (s.kind) {
+                    case "return": {
+                        const exitStmt = { kind: "break", label: exit, loc: s.loc };
+                        if (s.value === null || result === null) {
+                            return s.value === null
+                                ? exitStmt
+                                : {
+                                    kind: "block",
+                                    body: [{ kind: "exprStmt", expr: s.value, loc: s.loc }, exitStmt],
+                                    loc: s.loc,
+                                };
+                        }
+                        return {
+                            kind: "block",
+                            body: [{ kind: "assign", localId: result, value: s.value, loc: s.loc }, exitStmt],
+                            loc: s.loc,
+                        };
+                    }
+                    case "varDecl":
+                    case "assign":
+                        return { ...s, localId: rename(s.localId) };
+                    case "break":
+                    case "continue":
+                        return s.label && s.label !== exit ? { ...s, label: label(s.label) } : s;
+                    case "while":
+                    case "doWhile":
+                    case "for":
+                    case "block":
+                        return s.labels ? { ...s, labels: s.labels.map(label) } : s;
+                    default:
+                        return s;
+                }
+            },
+        });
+        const bind = fn.params.flatMap((p, index) => aliased.has(p.localId)
+            ? []
+            : [{ kind: "varDecl", localId: rename(p.localId), init: args[index], loc }]);
+        const pre = [];
+        if (result !== null)
+            pre.push({ kind: "varDecl", localId: result, init: null, loc });
+        pre.push({ kind: "block", labels: [exit], body: [...bind, ...body], loc });
+        return {
+            pre,
+            value: result === null
+                ? { kind: "numLit", value: 0, type: F64, loc }
+                : varRef(result, fn.returnType, loc),
+        };
+    }
+    build() {
+        const { chain, loc } = this;
+        const arrT = chain.sourceType;
+        const a = this.param("a", chain.source, "src");
+        const n = this.local("n", F64);
+        const body = [
+            {
+                kind: "varDecl",
+                localId: n,
+                init: { kind: "arrIntrinsic", method: "length", receiver: a, args: [], type: F64, loc },
+                loc,
+            },
+        ];
+        const nRef = varRef(n, F64, loc);
+        // Slice bounds: ToIntegerOrInfinity, then relative to the length.
+        let lo = numLit(0, loc);
+        let hi = nRef;
+        if (chain.slice) {
+            const bound = (value, name, fallback) => {
+                if (!value)
+                    return fallback;
+                const raw = this.param(name, value, name);
+                const t = this.local(`${name}Int`, F64);
+                const at = this.local(`${name}At`, F64);
+                const tRef = varRef(t, F64, loc);
+                const sum = { kind: "bin", op: "+", left: nRef, right: tRef, type: F64, loc };
+                const lt = (left, right) => ({
+                    kind: "bin",
+                    op: "<",
+                    left,
+                    right,
+                    type: BOOL,
+                    loc,
+                });
+                const pick = (cond, then, else_) => ({
+                    kind: "ternary",
+                    cond,
+                    then,
+                    else_,
+                    type: F64,
+                    loc,
+                });
+                body.push({
+                    kind: "varDecl",
+                    localId: t,
+                    init: pick({ kind: "bin", op: "!==", left: raw, right: raw, type: BOOL, loc }, numLit(0, loc), { kind: "libCall", fn: "math.trunc", args: [raw], type: F64, loc }),
+                    loc,
+                }, {
+                    kind: "varDecl",
+                    localId: at,
+                    init: pick(lt(tRef, numLit(0, loc)), pick(lt(sum, numLit(0, loc)), numLit(0, loc), sum), pick(lt(nRef, tRef), nRef, tRef)),
+                    loc,
+                });
+                return varRef(at, F64, loc);
+            };
+            lo = bound(chain.slice.start, "start", numLit(0, loc));
+            hi = bound(chain.slice.end, "end", nRef);
+            this.keyParts.push(`slice:${chain.slice.start ? 1 : 0}${chain.slice.end ? 1 : 0}`);
+        }
+        const terminalStage = chain.terminal.kind === "call" ? chain.terminal.stage : null;
+        for (const stage of terminalStage ? [...chain.stages, terminalStage] : chain.stages) {
+            this.keyParts.push(`${stage.info.method}:${typeKey(stage.info.elem)}:${typeKey(stage.info.fnRet)}:${stage.info.arity}:${stage.info.present ? "p" : ""}`);
+        }
+        const holes = holeCarrying(chain);
+        const resultT = chain.type;
+        const terminal = chain.terminal;
+        const epilogue = [];
+        // Terminal state. The reduce seed is a parameter evaluated after the
+        // callbacks, like the unfused call's argument.
+        let acc = null;
+        let count = null;
+        let out = null;
+        const stateDecls = [];
+        if (terminal.kind === "call" && terminal.stage.info.method === "reduce") {
+            acc = this.local("acc", terminal.stage.info.outElem, true);
+            epilogue.push({ kind: "return", value: varRef(acc, terminal.stage.info.outElem, loc), loc });
+        }
+        else if (terminal.kind === "length" ||
+            (terminal.kind === "call" && terminal.stage.info.method === "findIndex")) {
+            count = this.local("count", F64, true);
+            stateDecls.push({ kind: "varDecl", localId: count, init: numLit(0, loc), loc });
+            epilogue.push({
+                kind: "return",
+                value: terminal.kind === "length" ? varRef(count, F64, loc) : numLit(-1, loc),
+                loc,
+            });
+        }
+        else if (terminal.kind === "collect") {
+            out = this.local("out", resultT);
+            stateDecls.push({
+                kind: "varDecl",
+                localId: out,
+                init: { kind: "arrayLit", elems: [], type: resultT, loc },
+                loc,
+            });
+            if (holes) {
+                stateDecls.push({
+                    kind: "arraySetLength",
+                    arr: varRef(out, resultT, loc),
+                    length: {
+                        kind: "ternary",
+                        cond: { kind: "bin", op: "<", left: lo, right: hi, type: BOOL, loc },
+                        then: { kind: "bin", op: "-", left: hi, right: lo, type: F64, loc },
+                        else_: numLit(0, loc),
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                });
+            }
+            epilogue.push({ kind: "return", value: varRef(out, resultT, loc), loc });
+        }
+        else if (terminal.kind === "call") {
+            const method = terminal.stage.info.method;
+            if (method === "some" || method === "every")
+                epilogue.push({ kind: "return", value: boolLit(method === "every", loc), loc });
+        }
+        const i = varRef("i.0", F64, loc);
+        this.locals.push({ id: "i.0", name: "i", type: F64, mutable: true });
+        const slotRead = () => ({ kind: "arrayGet", arr: a, index: i, type: arrT.elem, loc });
+        const outIndex = () => chain.slice ? { kind: "bin", op: "-", left: i, right: lo, type: F64, loc } : i;
+        const counters = new Map();
+        /** The index argument for the value now reaching callback `k`. */
+        const indexArg = (k, pre) => {
+            if (chain.stages.slice(0, k).every((s) => s.info.method === "map"))
+                return outIndex();
+            let counter = counters.get(k);
+            if (counter === undefined) {
+                counter = this.local("index", F64, true);
+                counters.set(k, counter);
+                stateDecls.push({ kind: "varDecl", localId: counter, init: numLit(0, loc), loc });
+            }
+            const ix = this.local("ix", F64);
+            pre.push({ kind: "varDecl", localId: ix, init: varRef(counter, F64, loc), loc }, increment(counter, loc));
+            return varRef(ix, F64, loc);
+        };
+        /** Call callback `k` with `lead` arguments, a value, and the index and
+         * array arguments it declares. */
+        const deliver = (stage, k, lead, flow) => {
+            const arity = stage.info.arity;
+            const value = varRef(flow.id, flow.type, loc);
+            const at = lead.length;
+            const pick = () => {
+                if (arity <= at)
+                    return { arg: stage.slow, value: null };
+                const fast = stage.fast;
+                if (fast && typeEquals(fast.type.params[at], flow.type))
+                    return { arg: fast, value };
+                const paramT = stage.slow.type.params[at];
+                if (typeEquals(paramT, flow.type))
+                    return { arg: stage.slow, value };
+                if (paramT.kind === "union" && flow.type.kind !== "union") {
+                    const tag = this.lowerer.armTag(paramT.unionId, flow.type);
+                    if (tag >= 0)
+                        return {
+                            arg: stage.slow,
+                            value: { kind: "unionWrap", unionId: paramT.unionId, tag, value, type: paramT, loc },
+                        };
+                }
+                return null;
+            };
+            const chosen = pick();
+            if (!chosen)
+                return null;
+            const before = [];
+            const args = chosen.value ? [...lead, chosen.value] : lead.slice();
+            if (chosen.value && arity > args.length)
+                args.push(indexArg(k, before));
+            if (chosen.value && arity > args.length)
+                args.push(a);
+            const called = this.invoke(this.callee(chosen.arg), args.slice(0, arity), chosen.arg.type.ret);
+            return { pre: [...before, ...called.pre], value: called.value };
+        };
+        const fail = () => {
+            this.failed = true;
+            return [];
+        };
+        /** Turn the source slot into a value for the callback of `stage`. */
+        const read = (stage, rest) => {
+            if (stage.info.present) {
+                const v = this.local("v", arrT.elem);
+                return [
+                    { kind: "varDecl", localId: v, init: slotRead(), loc },
+                    ...rest({ kind: "value", id: v, type: arrT.elem }),
+                ];
+            }
+            const valueT = arrayValueType(this.lowerer, arrT.elem);
+            if (stage.fast) {
+                // The split visit: a value goes on as the plain element, a present
+                // undefined as the undefined arm.
+                const missing = this.lowerer.wrappedUndefined(valueT, loc);
+                if (!missing)
+                    return fail();
+                const v = this.local("v", arrT.elem);
+                const u = this.local("u", valueT);
+                return [
+                    {
+                        kind: "if",
+                        cond: {
+                            kind: "bin",
+                            op: "===",
+                            left: { kind: "arrayState", arr: a, index: i, type: F64, loc },
+                            right: numLit(1, loc),
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [
+                            { kind: "varDecl", localId: v, init: slotRead(), loc },
+                            ...rest({ kind: "value", id: v, type: arrT.elem }),
+                        ],
+                        else_: [
+                            { kind: "varDecl", localId: u, init: missing, loc },
+                            ...rest({ kind: "value", id: u, type: valueT }),
+                        ],
+                        loc,
+                    },
+                ];
+            }
+            const u = this.local("u", valueT);
+            return [
+                {
+                    kind: "varDecl",
+                    localId: u,
+                    init: arrayValueRead(this.lowerer, a, i, arrT.elem, loc),
+                    loc,
+                },
+                ...rest({ kind: "value", id: u, type: valueT }),
+            ];
+        };
+        /** The statements that run one value through stages k.. and the terminal. */
+        const visit = (k, flow) => {
+            if (k === chain.stages.length)
+                return finish(flow);
+            const stage = chain.stages[k];
+            const info = stage.info;
+            if (flow.kind === "slot")
+                return read(stage, (value) => visit(k, value));
+            const called = deliver(stage, k, [], flow);
+            if (!called)
+                return fail();
+            const { pre, value: result } = called;
+            switch (info.method) {
+                case "map":
+                case "flatMap": {
+                    const id = this.local("m", info.fnRet);
+                    return [
+                        ...pre,
+                        { kind: "varDecl", localId: id, init: result, loc },
+                        ...visit(k + 1, { kind: "value", id, type: info.fnRet }),
+                    ];
+                }
+                case "filter":
+                    return [
+                        ...pre,
+                        {
+                            kind: "if",
+                            cond: result.type.kind === "bool"
+                                ? result
+                                : { kind: "toBool", operand: result, type: BOOL, loc },
+                            then: visit(k + 1, flow),
+                            else_: null,
+                            loc,
+                        },
+                    ];
+                case "flatMapArray": {
+                    const r = this.local("r", info.fnRet);
+                    const m = this.local("len", F64);
+                    const j = this.local("j", F64, true);
+                    const inner = info.fnRet.elem;
+                    const rRef = varRef(r, info.fnRet, loc);
+                    const jRef = varRef(j, F64, loc);
+                    let each;
+                    if (k + 1 === chain.stages.length && terminal.kind === "length") {
+                        each = finish({ kind: "slot" });
+                    }
+                    else {
+                        const w = this.local("w", arrayValueType(this.lowerer, inner));
+                        const element = arrayValueRead(this.lowerer, rRef, jRef, inner, loc);
+                        each = [
+                            { kind: "varDecl", localId: w, init: element, loc },
+                            ...visit(k + 1, { kind: "value", id: w, type: element.type }),
+                        ];
+                    }
+                    return [
+                        ...pre,
+                        { kind: "varDecl", localId: r, init: result, loc },
+                        {
+                            kind: "varDecl",
+                            localId: m,
+                            init: {
+                                kind: "arrIntrinsic",
+                                method: "length",
+                                receiver: rRef,
+                                args: [],
+                                type: F64,
+                                loc,
+                            },
+                            loc,
+                        },
+                        {
+                            kind: "for",
+                            init: { kind: "varDecl", localId: j, init: numLit(0, loc), loc },
+                            cond: {
+                                kind: "bin",
+                                op: "<",
+                                left: jRef,
+                                right: varRef(m, F64, loc),
+                                type: BOOL,
+                                loc,
+                            },
+                            update: {
+                                kind: "assign",
+                                localId: j,
+                                value: { kind: "bin", op: "+", left: jRef, right: numLit(1, loc), type: F64, loc },
+                                loc,
+                            },
+                            body: [
+                                {
+                                    kind: "if",
+                                    cond: arrayIndexPresent(rRef, jRef, loc),
+                                    then: each,
+                                    else_: null,
+                                    loc,
+                                },
+                            ],
+                            loc,
+                        },
+                    ];
+                }
+                default:
+                    return fail();
+            }
+        };
+        /** The terminal's action for one value. */
+        const finish = (flow) => {
+            if (terminal.kind === "length")
+                return [increment(count, loc)];
+            if (terminal.kind === "collect") {
+                if (flow.kind !== "value")
+                    return fail();
+                const last = chain.stages[chain.stages.length - 1];
+                const outT = resultT;
+                if (!typeEquals(outT.elem, last.info.outElem))
+                    return fail();
+                const outRef = varRef(out, resultT, loc);
+                const index = holes
+                    ? outIndex()
+                    : { kind: "arrIntrinsic", method: "length", receiver: outRef, args: [], type: F64, loc };
+                return [
+                    arrayValueStore(this.lowerer, outRef, index, varRef(flow.id, flow.type, loc), outT.elem, loc),
+                ];
+            }
+            const stage = terminal.stage;
+            const method = stage.info.method;
+            if (flow.kind === "slot")
+                return read(stage, (value) => finish(value));
+            if (method === "reduce") {
+                const accT = stage.info.outElem;
+                const called = deliver(stage, chain.stages.length, [varRef(acc, accT, loc)], flow);
+                if (!called || !typeEquals(called.value.type, accT))
+                    return fail();
+                return [...called.pre, { kind: "assign", localId: acc, value: called.value, loc }];
+            }
+            const called = deliver(stage, chain.stages.length, [], flow);
+            if (!called)
+                return fail();
+            const { pre, value: result } = called;
+            if (method === "forEach") {
+                return stage.slow.type.ret.kind === "void" && result.kind === "numLit"
+                    ? pre
+                    : [...pre, { kind: "exprStmt", expr: result, loc }];
+            }
+            const test = predicateToBoolean(result);
+            if (method === "some")
+                return [
+                    ...pre,
+                    {
+                        kind: "if",
+                        cond: test,
+                        then: [{ kind: "return", value: boolLit(true, loc), loc }],
+                        else_: null,
+                        loc,
+                    },
+                ];
+            if (method === "every")
+                return [
+                    ...pre,
+                    {
+                        kind: "if",
+                        cond: { kind: "unary", op: "!", operand: test, type: BOOL, loc },
+                        then: [{ kind: "return", value: boolLit(false, loc), loc }],
+                        else_: null,
+                        loc,
+                    },
+                ];
+            if (method === "findIndex")
+                return [
+                    ...pre,
+                    {
+                        kind: "if",
+                        cond: test,
+                        then: [{ kind: "return", value: varRef(count, F64, loc), loc }],
+                        else_: null,
+                        loc,
+                    },
+                    increment(count, loc),
+                ];
+            return fail();
+        };
+        // Callbacks are parameters in stage order; the reduce seed follows them.
+        for (const stage of terminalStage ? [...chain.stages, terminalStage] : chain.stages) {
+            void stage;
+        }
+        const present = visit(0, { kind: "slot" });
+        if (this.failed)
+            return null;
+        if (acc !== null && terminal.kind === "call") {
+            const z = this.param("z", terminal.init, "init");
+            stateDecls.unshift({ kind: "varDecl", localId: acc, init: z, loc });
+        }
+        body.push(...stateDecls);
+        const hole = holes && terminal.kind === "length" ? [increment(count, loc)] : null;
+        const loopBody = [
+            { kind: "if", cond: arrayIndexPresent(a, i, loc), then: present, else_: hole, loc },
+        ];
+        const loop = chain.slice
+            ? {
+                kind: "for",
+                init: { kind: "varDecl", localId: "i.0", init: lo, loc },
+                cond: { kind: "bin", op: "<", left: i, right: hi, type: BOOL, loc },
+                update: {
+                    kind: "assign",
+                    localId: "i.0",
+                    value: { kind: "bin", op: "+", left: i, right: numLit(1, loc), type: F64, loc },
+                    loc,
+                },
+                body: loopBody,
+                loc,
+            }
+            : countedFor(loc, nRef, () => loopBody);
+        body.push(loop, ...epilogue);
+        this.keyParts.push(`${terminal.kind}:${typeKey(resultT)}`);
+        const returnType = terminal.kind === "call" && terminal.stage.info.method === "forEach" ? VOID : resultT;
+        const fn = {
+            params: this.params,
+            returnType,
+            locals: this.locals,
+            body,
+            loc,
+        };
+        foldKnownUnions(fn);
+        scalarizeRecordTemporaries(this.lowerer, fn);
+        return { fn, args: this.args, key: this.keyParts.join("|") };
+    }
+}
+function increment(id, loc) {
+    return {
+        kind: "assign",
+        localId: id,
+        value: {
+            kind: "bin",
+            op: "+",
+            left: varRef(id, F64, loc),
+            right: numLit(1, loc),
+            type: F64,
+            loc,
+        },
+        loc,
+    };
+}
+/** ToBoolean of a predicate result, as the some/every/findIndex helpers apply it. */
+function predicateToBoolean(e) {
+    if (e.type.kind === "bool")
+        return e;
+    if (e.type.kind === "dyn")
+        return { kind: "dynTest", test: "truthy", value: e, type: BOOL, loc: e.loc };
+    return { kind: "toBool", operand: e, type: BOOL, loc: e.loc };
+}
+/** A union local the fused loop wrapped from a plain value has a known
+ * tag: its tag tests fold, its narrowing is the plain value, and the wrap
+ * itself goes away once nothing reads it. */
+function foldKnownUnions(fn) {
+    const writes = new Map();
+    const count = (id) => {
+        writes.set(id, (writes.get(id) ?? 0) + 1);
+    };
+    everyStmtList(fn.body, {
+        expr: (e) => {
+            if (e.kind === "assignExpr" || e.kind === "incDec")
+                count(e.localId);
+            return true;
+        },
+        stmt: (s) => {
+            if (s.kind === "varDecl" || s.kind === "assign" || s.kind === "forOf")
+                count(s.localId);
+            return true;
+        },
+    });
+    const known = new Map();
+    everyStmtList(fn.body, {
+        expr: () => true,
+        stmt: (s) => {
+            if (s.kind === "varDecl" &&
+                s.init?.kind === "unionWrap" &&
+                s.init.value.kind === "varRef" &&
+                writes.get(s.localId) === 1 &&
+                writes.get(s.init.value.localId) === 1)
+                known.set(s.localId, { tag: s.init.tag, value: s.init.value });
+            return true;
+        },
+    });
+    if (known.size === 0)
+        return;
+    const fold = (e) => {
+        if (e.kind === "unionIsTag" && e.value.kind === "varRef") {
+            const k = known.get(e.value.localId);
+            if (k)
+                return boolLit((k.tag === e.tag) !== e.negated, e.loc);
+        }
+        if (e.kind === "unionNarrow" && e.value.kind === "varRef") {
+            const k = known.get(e.value.localId);
+            if (k && k.tag === e.tag && typeEquals(k.value.type, e.type))
+                return { ...k.value, loc: e.loc };
+        }
+        if (e.kind === "ternary") {
+            const cond = fold(e.cond);
+            if (cond.kind === "boolLit")
+                return fold(cond.value ? e.then : e.else_);
+        }
+        return e;
+    };
+    let body = transformStmtList(fn.body, { stmt: (s) => s, expr: fold });
+    const reads = new Set();
+    everyStmtList(body, {
+        expr: (e) => {
+            if (e.kind === "varRef")
+                reads.add(e.localId);
+            return true;
+        },
+        stmt: () => true,
+    });
+    const dead = new Set([...known.keys()].filter((id) => !reads.has(id)));
+    if (dead.size > 0) {
+        const prune = (list) => list
+            .filter((s) => !(s.kind === "varDecl" && dead.has(s.localId)))
+            .map((s) => {
+            switch (s.kind) {
+                case "if":
+                    return { ...s, then: prune(s.then), else_: s.else_ === null ? null : prune(s.else_) };
+                case "for":
+                case "while":
+                case "doWhile":
+                case "block":
+                    return { ...s, body: prune(s.body) };
+                default:
+                    return s;
+            }
+        });
+        body = prune(body);
+        fn.locals = fn.locals.filter((l) => !dead.has(l.id));
+    }
+    fn.body = body;
+}
+/* ── per-element record temporaries ──────────────────────────────────── */
+/** Inside a fused loop, a record one inlined stage builds and the next
+ * only reads field by field never needs to exist. A group of record locals
+ * connected by copies, each defined only by a literal of their shape (or a
+ * copy within the group) and used only through field reads, becomes one
+ * scalar local per field. Literal fields still evaluate in source order
+ * (through temporaries, so a literal may read the fields it replaces).
+ * Identity cannot be observed: no use besides a field read survives. */
+function scalarizeRecordTemporaries(lowerer, fn) {
+    const params = new Set(fn.params.map((p) => p.localId));
+    const candidates = new Map();
+    for (const l of fn.locals) {
+        if (l.type.kind !== "record" || l.boxed || l.tdz || params.has(l.id))
+            continue;
+        const shape = lowerer.shapes.get(l.type.shapeId);
+        if (!shape ||
+            shape.tuple ||
+            shape.indexValue ||
+            shape.fields.length === 0 ||
+            shape.fields.length > 8 ||
+            !shape.fields.every((f) => f.type.kind === "f64" || f.type.kind === "bool"))
+            continue;
+        candidates.set(l.id, l);
+    }
+    if (candidates.size === 0)
+        return;
+    const parent = new Map();
+    const find = (id) => {
+        let root = id;
+        while (parent.has(root))
+            root = parent.get(root);
+        return root;
+    };
+    const union = (x, y) => {
+        const rx = find(x);
+        const ry = find(y);
+        if (rx !== ry)
+            parent.set(rx, ry);
+    };
+    const bad = new Set();
+    const sameShape = (x, y) => candidates.get(x).type.shapeId === candidates.get(y).type.shapeId;
+    const literalOk = (e, shapeId) => e.kind === "recordLit" &&
+        e.type.kind === "record" &&
+        e.type.shapeId === shapeId &&
+        e.fields.every((f) => !f.overflow && !f.drop);
+    const expr = (e) => {
+        if (e.kind === "recordGet" && e.obj.kind === "varRef" && candidates.has(e.obj.localId))
+            return true;
+        if ((e.kind === "varRef" || e.kind === "assignExpr" || e.kind === "incDec") &&
+            candidates.has(e.localId))
+            bad.add(e.localId);
+        if (e.kind === "closure")
+            for (const id of e.captures)
+                if (candidates.has(id))
+                    bad.add(id);
+        return everyExprChild(e, expr, stmt);
+    };
+    const definition = (id, value) => {
+        const target = candidates.get(id);
+        if (value === null)
+            return;
+        if (value.kind === "varRef" && candidates.has(value.localId)) {
+            if (sameShape(id, value.localId))
+                union(id, value.localId);
+            else
+                bad.add(id);
+            return;
+        }
+        if (literalOk(value, target.type.shapeId)) {
+            for (const f of value.fields)
+                expr(f.value);
+            return;
+        }
+        bad.add(id);
+        expr(value);
+    };
+    const stmt = (s) => {
+        if ((s.kind === "varDecl" || s.kind === "assign") && candidates.has(s.localId)) {
+            definition(s.localId, s.kind === "varDecl" ? s.init : s.value);
+            return true;
+        }
+        if (s.kind === "forOf" && candidates.has(s.localId))
+            bad.add(s.localId);
+        return everyStmtChild(s, expr, stmt);
+    };
+    fn.body.forEach(stmt);
+    const badRoots = new Set([...bad].map(find));
+    const chosen = [...candidates.keys()].filter((id) => !badRoots.has(find(id)));
+    if (chosen.length === 0)
+        return;
+    const fields = new Map();
+    const added = [];
+    let next = 0;
+    const used = new Set(fn.locals.map((l) => l.id));
+    const fresh = (name) => {
+        let id;
+        do
+            id = `${name}.s${next++}`;
+        while (used.has(id));
+        used.add(id);
+        return id;
+    };
+    for (const id of chosen) {
+        const local = candidates.get(id);
+        const shape = lowerer.shapes.get(local.type.shapeId);
+        const map = new Map();
+        for (const f of shape.fields) {
+            const fid = fresh(`${local.name}.${f.name}`);
+            map.set(f.name, fid);
+            added.push({ id: fid, name: `${local.name}.${f.name}`, type: f.type, mutable: true });
+        }
+        fields.set(id, map);
+    }
+    const fieldType = (id, field) => lowerer.shapes.get(candidates.get(id).type.shapeId).fields.find((f) => f.name === field)
+        .type;
+    const rewriteExpr = (e) => {
+        const [s] = transformStmtList([{ kind: "exprStmt", expr: e, loc: e.loc }], {
+            stmt: (x) => x,
+            expr: (x) => {
+                if (x.kind === "recordGet" && x.obj.kind === "varRef") {
+                    const id = fields.get(x.obj.localId)?.get(x.field);
+                    if (id)
+                        return { kind: "varRef", localId: id, type: x.type, loc: x.loc };
+                }
+                return x;
+            },
+        });
+        return s.expr;
+    };
+    const rewriteList = (list) => list.flatMap(rewriteStmt);
+    const rewriteStmt = (s) => {
+        if ((s.kind === "varDecl" || s.kind === "assign") && fields.has(s.localId)) {
+            const map = fields.get(s.localId);
+            const value = s.kind === "varDecl" ? s.init : s.value;
+            const store = (fid, v) => s.kind === "varDecl"
+                ? { kind: "varDecl", localId: fid, init: v, loc: s.loc }
+                : { kind: "assign", localId: fid, value: v, loc: s.loc };
+            if (value === null)
+                return [...map.values()].map((fid) => store(fid, null));
+            if (value.kind === "varRef") {
+                const from = fields.get(value.localId);
+                return [...map].map(([name, fid]) => store(fid, varRef(from.get(name), fieldType(s.localId, name), s.loc)));
+            }
+            const literal = value;
+            const temps = [];
+            const values = new Map();
+            for (const f of literal.fields) {
+                const t = fresh(`${candidates.get(s.localId).name}.${f.name}.t`);
+                const type = fieldType(s.localId, f.name);
+                added.push({ id: t, name: f.name, type, mutable: false });
+                temps.push({ kind: "varDecl", localId: t, init: rewriteExpr(f.value), loc: s.loc });
+                values.set(f.name, varRef(t, type, s.loc));
+            }
+            return [...temps, ...[...map].map(([name, fid]) => store(fid, values.get(name)))];
+        }
+        return rewriteNested(s);
+    };
+    const rewriteNested = (s) => {
+        switch (s.kind) {
+            case "if":
+                return [
+                    {
+                        ...s,
+                        cond: rewriteExpr(s.cond),
+                        then: rewriteList(s.then),
+                        else_: s.else_ === null ? null : rewriteList(s.else_),
+                    },
+                ];
+            case "while":
+                return [{ ...s, cond: rewriteExpr(s.cond), body: rewriteList(s.body) }];
+            case "doWhile":
+                return [{ ...s, cond: rewriteExpr(s.cond), body: rewriteList(s.body) }];
+            case "for":
+                return [
+                    {
+                        ...s,
+                        init: s.init === null ? null : (rewriteStmt(s.init)[0] ?? null),
+                        cond: s.cond === null ? null : rewriteExpr(s.cond),
+                        update: s.update === null ? null : (rewriteStmt(s.update)[0] ?? null),
+                        body: rewriteList(s.body),
+                    },
+                ];
+            case "block":
+                return [{ ...s, body: rewriteList(s.body) }];
+            default: {
+                const [x] = transformStmtList([s], {
+                    stmt: (y) => y,
+                    expr: (y) => {
+                        if (y.kind === "recordGet" && y.obj.kind === "varRef") {
+                            const id = fields.get(y.obj.localId)?.get(y.field);
+                            if (id)
+                                return { kind: "varRef", localId: id, type: y.type, loc: y.loc };
+                        }
+                        return y;
+                    },
+                });
+                return [x];
+            }
+        }
+    };
+    fn.body = rewriteList(fn.body);
+    fn.locals = [...fn.locals.filter((l) => !fields.has(l.id)), ...added];
+}
+//# sourceMappingURL=array-pipelines.js.map