@msb235/blits 0.4.0 → 0.5.0

package/dist/fold.js

@@ -0,0 +1,475 @@
+import { heldTime, passAt, phaseAt, silent } from './clock.js';
+import { copy as copyValue } from './clone.js';
+import { recordHost, remember } from './history.js';
+import { stateful } from './hosts.js';
+import { locusScratch } from './locus.js';
+import { readKeys } from './patch.js';
+import { reading } from './reading.js';
+// V8 reads a local const as a constant, where it reads an import from its module on every call.
+const copy = copyValue;
+/** A record's band state, made when a rest-less channel first asks. */
+function bandsFor(held, n) {
+    const bands = new Uint8Array(n);
+    held.bands = bands;
+    return bands;
+}
+export function near(a, b) {
+    if (typeof a === 'number' && typeof b === 'number')
+        return Math.abs(a - b) < 1e-9;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((v, i) => near(v, b[i]));
+    return a === b;
+}
+/**
+ * `merge(acc, b)`, where a result that is `b` itself, as `last()` gives, is copied into `acc` or a
+ * new array: `b` belongs to a patch or the mix's scratch, and a host may edit the pose. `acc` is a
+ * value this fold made.
+ */
+function merged(channel, acc, b) {
+    const r = channel.merge(acc, b);
+    if (r !== b || !Array.isArray(r))
+        return r;
+    if (!Array.isArray(acc) || acc.length !== r.length)
+        return [...r];
+    for (let i = 0; i < r.length; i++)
+        acc[i] = r[i];
+    return acc;
+}
+/**
+ * One live voice's delta for one subject this frame, through its record for the subject, or null
+ * when it does not reach. Its weight is left in `w`.
+ */
+export function influence(voice, subject, now, held) {
+    held.weight = 0;
+    if (!held.reaches)
+        return null;
+    if (voice.out?.rest && held.rested)
+        return null;
+    const raw = voice.elapsedAt(now) - held.delay;
+    if (raw < 0 && !voice.holdsBefore)
+        return null;
+    const elapsed = heldTime(raw, voice.holdsBefore, voice.holdsAfter, voice.span);
+    // A held subject's clock stands still at the edge it holds: -1 before, 1 after, 0 playing.
+    const still = raw < 0 ? -1 : voice.holdsAfter && raw > voice.span ? 1 : 0;
+    const duration = voice.duration;
+    const phase = phaseAt(elapsed, duration, voice.passes);
+    const pass = passAt(elapsed, duration, voice.passes);
+    this.prime(voice, held, now, elapsed, pass);
+    const setting = voice.setting;
+    // A signal that keeps state makes its voice stateful, as a patch that does: a lane would call
+    // it for subjects no probe asked about.
+    const keptAtWeigh = reading.kept;
+    const weight = this.weigh(voice, subject, now, held);
+    if (reading.kept !== keptAtWeigh && !voice.keeping)
+        stateful(this, voice);
+    setting.weight = weight;
+    held.weight = weight;
+    if (held.probed === now && held.delta && held.seeks === voice.seeks) {
+        if (voice.holder !== held && voice.scratch.length > 0)
+            this.keyed(voice, subject, held);
+        this.w = weight;
+        return held.delta;
+    }
+    const keptBefore = reading.kept;
+    const history = this.opts.history;
+    if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
+        recordHost(this, now);
+    reading.horizon = this.horizonFor(voice, held.delay, now);
+    const tick = this.opts.stepMs;
+    if (voice.patch.step && held.probed !== now && still >= 0) {
+        // Held after, it steps once more to where its last pass ended, and no further.
+        const to = still === 1 ? voice.timeAt(held.delay + voice.span) : now;
+        if (tick !== undefined && tick > 0 && !this.reducedNow)
+            this.tick(voice, subject, held, tick, to);
+        else if (still === 0 ? now !== held.stepped : to > held.stepped) {
+            if (still === 1)
+                setting.dt = this.capped(to - held.stepped);
+            voice.patch.step(held.state, setting.dt, subject, setting);
+            held.stepped = to;
+        }
+    }
+    let delta = null;
+    // Keys read even when silent: a `from: 'current'` voice takes its base on its first read.
+    if (voice.built) {
+        held.phase = phase;
+        delta = this.keyed(voice, subject, held);
+    }
+    else if (!silent(voice, weight)) {
+        delta = voice.patch.at(phase, subject, setting);
+    }
+    held.delta = delta;
+    held.probed = now;
+    held.seeks = voice.seeks;
+    if (history !== undefined)
+        remember(this, voice, held);
+    if (reading.kept !== keptBefore && !voice.keeping)
+        stateful(this, voice);
+    if (delta === null)
+        return null;
+    if (voice.out?.rest && this.isRest(delta)) {
+        held.weight = 0;
+        held.rested = true;
+        voice.restedCount++;
+        return null;
+    }
+    this.w = weight;
+    return delta;
+}
+/** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
+export function keyed(voice, subject, held) {
+    let base;
+    if (voice.spec.from === 'current') {
+        if (held.base === undefined) {
+            held.base = this.baseFor(voice, subject);
+            held.slope = this.slopeFor(voice, subject);
+        }
+        base = held.base;
+    }
+    const delta = readKeys(voice.built, held.phase, held.delta ?? {}, base, voice.lerps, held.slope, voice.intos, voice.scratch);
+    held.delta = delta;
+    if (voice.scratch.length > 0)
+        voice.holder = held;
+    return delta;
+}
+/**
+ * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
+ * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
+ * rather than adding keeps the grid where it is however many samples it is reached through.
+ */
+export function tick(voice, subject, held, tick, to) {
+    const now = this.now;
+    const setting = voice.setting;
+    const frameDt = setting.dt;
+    let n = held.ticks;
+    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
+    const due = Math.floor((to - held.since) / tick + 1e-9);
+    const cap = this.opts.maxDt;
+    if (cap !== undefined) {
+        const most = Math.floor(cap / tick);
+        if (due - n > most)
+            n = due - most;
+    }
+    const step = voice.patch.step;
+    setting.dt = tick;
+    for (n++; n <= due; n++) {
+        setting.timestamp = held.since + n * tick;
+        step(held.state, tick, subject, setting);
+    }
+    held.ticks = due > held.ticks ? due : held.ticks;
+    held.stepped = held.since + held.ticks * tick;
+    setting.timestamp = now;
+    setting.dt = frameDt;
+}
+/**
+ * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
+ * With no such frame on record — a voice cued before the subject was ever probed, or a host that
+ * samples into its own object — it is this frame's pose with every other voice folded in.
+ */
+export function baseFor(voice, subject) {
+    let prior = this.pose.get(subject)?.pose;
+    if (prior === undefined && !this.folding.has(voice.id)) {
+        this.folding.add(voice.id);
+        try {
+            prior = this.fold(subject, undefined, false, voice.id);
+        }
+        finally {
+            this.folding.delete(voice.id);
+        }
+    }
+    const base = {};
+    for (const key of voice.patch.writes) {
+        const channel = this.kit[key];
+        const value = prior?.[key];
+        const fallback = channel.rest;
+        if (value !== undefined)
+            base[key] = copy(value);
+        else if (fallback !== undefined)
+            base[key] = copy(fallback);
+    }
+    return base;
+}
+/**
+ * How fast each numeric channel this voice writes was moving, from the subject's last two probed
+ * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
+ */
+export function slopeFor(voice, subject) {
+    const rec = this.pose.get(subject);
+    if (rec?.prev === undefined || !(rec.at > rec.prevAt))
+        return undefined;
+    const dt = rec.at - rec.prevAt;
+    const now = rec.pose;
+    const before = rec.prev;
+    const slope = {};
+    for (const key of voice.patch.writes) {
+        const a = before[key];
+        const b = now[key];
+        if (typeof a === 'number' && typeof b === 'number')
+            slope[key] = (b - a) / dt;
+        else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length)
+            slope[key] = b.map((v, i) => (v - a[i]) / dt);
+    }
+    return slope;
+}
+export function isRest(delta) {
+    for (const key of Object.keys(delta)) {
+        if (delta[key] === undefined)
+            continue;
+        const channel = this.kit[key];
+        if (channel.rest === undefined)
+            return false;
+        if (!near(delta[key], channel.rest))
+            return false;
+    }
+    return true;
+}
+/** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
+export function passes(was, w) {
+    const { on, off } = this.band;
+    return w >= on ? true : w <= off ? false : (was ?? w >= on);
+}
+/** Folds one voice's delta into the pose, its band state kept on the subject's record. */
+export function apply(pose, voice, held, delta, weight) {
+    const slots = voice.slots;
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
+        const key = this.names[slot];
+        const value = delta[key];
+        if (value === undefined)
+            continue;
+        const channel = this.channels[slot];
+        if (channel.rest !== undefined && channel.scale) {
+            // pose[key] is the copy of rest this fold made, so it is ours to write into.
+            pose[key] = channel.fold
+                ? channel.fold(pose[key], value, weight)
+                : merged(channel, pose[key], channel.scale(value, weight));
+            continue;
+        }
+        const bands = held.bands ?? bandsFor(held, slots.length);
+        const band = bands[i];
+        const on = this.passes(band === 0 ? undefined : band === 1, weight);
+        bands[i] = on ? 1 : 2;
+        if (on)
+            pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);
+    }
+}
+/** Clamps every bounded channel of a folded pose into its range, in place. */
+export function clamp(pose) {
+    for (const slot of this.bounded) {
+        const [lo, hi] = this.channels[slot].bounds;
+        const key = this.names[slot];
+        const v = pose[key];
+        if (typeof v === 'number')
+            pose[key] = v < lo ? lo : v > hi ? hi : v;
+        else if (Array.isArray(v))
+            for (let i = 0; i < v.length; i++) {
+                const x = v[i];
+                v[i] = x < lo ? lo : x > hi ? hi : x;
+            }
+    }
+    return pose;
+}
+export function fold(subject, out, dry = false, except) {
+    const pose = this.folded(subject, out, dry, except);
+    return (this.bounded.length === 0 ? pose : this.clamp(pose));
+}
+export function folded(subject, out, dry = false, except) {
+    const head = this.linked(subject);
+    return this.foldWith(subject, out ?? {}, head, this.linkedLaned, dry, except);
+}
+/**
+ * A subject's chain, linked for this frame, and in `linkedLaned` whether its lanes answer for the
+ * voices on them; a subject numbered since the frame's fill folds every voice, laned ones included.
+ */
+export function linked(subject) {
+    const now = this.now;
+    const head = Number.isNaN(now) ? null : this.chain(subject, now);
+    this.linkedLaned =
+        head !== null && this.lanes?.prepare(head.slot, subject, now, this.version, head) === true;
+    return head;
+}
+/** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
+export function foldWith(subject, out, head, laned, dry, except) {
+    const now = this.now;
+    const pose = out;
+    const lanes = this.lanes;
+    const skip = laned ? lanes.copies : null;
+    for (let i = 0; i < this.names.length; i++) {
+        if (skip?.[i])
+            continue;
+        const rest = this.channels[i].rest;
+        const key = this.names[i];
+        // Never `delete`: it drops a reused out object into dictionary mode for good.
+        if (rest !== undefined)
+            pose[key] = copy(rest);
+        else if (pose[key] !== undefined)
+            pose[key] = undefined;
+    }
+    if (head === null)
+        return pose;
+    // A subject owing lanes it just met folds those voices here, after the lanes' values.
+    let owed = -1;
+    if (laned) {
+        const l = lanes;
+        l.copy(head.slot, pose);
+        if (l.owes(head.slot))
+            owed = head.slot;
+        else if (l.whole)
+            return pose;
+    }
+    if (this.loci === 0) {
+        for (let held = head; held !== null; held = held.next) {
+            const voice = held.voice;
+            if (voice === null || (laned && voice.laned && !this.owedBy(owed, voice)))
+                continue;
+            if (voice.id === except || voice.state === 'done')
+                continue;
+            const delta = this.read(voice, subject, now, dry, held);
+            if (owed >= 0 && voice.laned)
+                lanes.paid(voice.id, owed, held.weight);
+            if (delta === null || this.w <= 0)
+                continue;
+            this.apply(pose, voice, held, delta, this.w);
+        }
+        return pose;
+    }
+    return this.foldLoci(subject, pose, head, laned, dry, except, owed);
+}
+/** Whether the subject numbered `owed` reads laned `voice` from the general path this fill. */
+export function owedBy(owed, voice) {
+    return owed >= 0 && this.lanes.owesVoice(owed, voice.id);
+}
+/** `foldWith`'s voices with a locus in play: each locus folds at its first member's place. */
+export function foldLoci(subject, pose, head, laned, dry, except, owed) {
+    const now = this.now;
+    // A patch reading the pose can fold again from inside this one, so each depth has its own.
+    let k = this.locusScratch[this.locusDepth];
+    if (k === undefined) {
+        k = locusScratch(this.channels.length);
+        this.locusScratch[this.locusDepth] = k;
+    }
+    this.locusDepth++;
+    try {
+        k.n = 0;
+        k.m = 0;
+        k.names.length = 0;
+        for (let held = head; held !== null; held = held.next) {
+            const voice = held.voice;
+            if (voice === null || (laned && voice.laned && !this.owedBy(owed, voice)))
+                continue;
+            if (voice.id === except || voice.state === 'done')
+                continue;
+            const delta = this.read(voice, subject, now, dry, held);
+            if (owed >= 0 && voice.laned)
+                this.lanes.paid(voice.id, owed, held.weight);
+            if (delta === null)
+                continue;
+            const locus = voice.spec.locus;
+            let group = -1;
+            if (locus !== undefined) {
+                group = k.names.indexOf(locus);
+                const m = k.m++;
+                k.mVoices[m] = voice;
+                k.mDeltas[m] = delta;
+                k.mWeights[m] = this.w;
+                if (group >= 0) {
+                    k.mGroups[m] = group;
+                    continue;
+                }
+                group = k.names.length;
+                k.names.push(locus);
+                k.mGroups[m] = group;
+            }
+            const n = k.n++;
+            k.voices[n] = voice;
+            k.helds[n] = held;
+            k.deltas[n] = delta;
+            k.weights[n] = locus === undefined ? this.w : 0;
+            k.groups[n] = group;
+        }
+        let bands = head.loci;
+        if (bands === null) {
+            bands = new Map();
+            head.loci = bands;
+        }
+        for (let n = 0; n < k.n; n++) {
+            const group = k.groups[n];
+            if (group < 0) {
+                const weight = k.weights[n];
+                if (weight > 0)
+                    this.apply(pose, k.voices[n], k.helds[n], k.deltas[n], weight);
+                continue;
+            }
+            const weight = this.foldLocus(k, group);
+            if (weight <= 0)
+                continue;
+            const name = k.names[group];
+            let on = bands.get(name);
+            if (on === undefined) {
+                on = new Uint8Array(this.channels.length);
+                bands.set(name, on);
+            }
+            for (let t = 0; t < k.touched.length; t++) {
+                const slot = k.touched[t];
+                const value = k.values[slot];
+                k.values[slot] = undefined;
+                const key = this.names[slot];
+                const channel = this.channels[slot];
+                if (channel.rest !== undefined && channel.scale) {
+                    // pose[key] is the copy of rest this fold made, so it is ours to write into.
+                    pose[key] = channel.fold
+                        ? channel.fold(pose[key], value, weight)
+                        : merged(channel, pose[key], channel.scale(value, weight));
+                    continue;
+                }
+                const band = on[slot];
+                const passes = this.passes(band === 0 ? undefined : band === 1, weight);
+                on[slot] = passes ? 1 : 2;
+                if (passes)
+                    pose[key] = pose[key] === undefined ? copy(value) : merged(channel, pose[key], value);
+            }
+        }
+        return pose;
+    }
+    finally {
+        for (let n = 0; n < k.n; n++) {
+            k.voices[n] = null;
+            k.helds[n] = null;
+            k.deltas[n] = null;
+        }
+        for (let m = 0; m < k.m; m++) {
+            k.mVoices[m] = null;
+            k.mDeltas[m] = null;
+        }
+        // Left set only where a channel's lerp threw partway, which the next fold must not inherit.
+        for (let t = 0; t < k.touched.length; t++) {
+            const slot = k.touched[t];
+            k.met[slot] = 0;
+            k.values[slot] = undefined;
+        }
+        k.touched.length = 0;
+        this.locusDepth--;
+    }
+}
+/** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
+export function read(voice, subject, now, dry, held) {
+    if (dry) {
+        if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
+            const setting = voice.setting;
+            // The setting the probe that read the delta had, but for `dt`: a dry read advances nothing.
+            const elapsed = heldTime(voice.elapsedAt(now) - held.delay, voice.holdsBefore, voice.holdsAfter, voice.span);
+            setting.timestamp = now;
+            setting.dt = 0;
+            setting.elapsed = elapsed;
+            setting.pass = passAt(elapsed, voice.duration, voice.passes);
+            setting.weight = 0;
+            setting.state = held.state;
+            voice.keepOn = held;
+            this.w = this.weigh(voice, subject, now, held);
+            held.weight = this.w;
+            if (voice.holder !== held && voice.scratch.length > 0)
+                this.keyed(voice, subject, held);
+            return held.delta;
+        }
+    }
+    return this.influence(voice, subject, now, held);
+}

package/dist/gather.d.ts

@@ -0,0 +1,24 @@
+import { type Lane, type Laned, type Locus } from './lane.js';
+import type { Lanes } from './lanes.js';
+/**
+ * Every member of a locus, in voice order, gathered rather than folded: a member's delta for a
+ * subject is lerped into what the members before it left there by its share of the weight
+ * taken, as the general path's `foldLocus` does, so each subject's locus can fold in at its
+ * first member's place in the order.
+ */
+export declare function gatherLocus<I, O>(lanes: Lanes<I, O>, g: Locus<I, O>): void;
+/** A locus member's turn in the order: each subject it was the first member of takes the locus. */
+export declare function foldLocus<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, g: Locus<I, O>): void;
+/** For a keys voice: the delta's value for each channel it writes, read once per phase. */
+export declare function gather<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, delta: Record<string, unknown>): void;
+/** Folds what `gather` read into a subject's laned values. */
+export declare function fold<I, O>(this: Lanes<I, O>, lane: Lane<I, O>, slot: number, w: number): void;
+/**
+ * Folds a delta a patch returned into a subject's laned values. The first few channels are read
+ * at a site of their own, which in most mixes sees one channel name and stays fast, where one
+ * site reading every name in turn slows every read.
+ */
+export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned[], slot: number, delta: Record<string, unknown>, w: number): void;
+/** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
+export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array, w: number): void;
+export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown, w: number): void;

package/dist/gather.js

@@ -0,0 +1,186 @@
+import { foldNumber, lerpNumber } from './channels.js';
+/** `xs`, or a copy at least `n` long where it is shorter. */
+function sized(xs, n) {
+    if (xs.length >= n)
+        return xs;
+    const grown = new Float64Array(n);
+    grown.set(xs);
+    return grown;
+}
+/**
+ * Every member of a locus, in voice order, gathered rather than folded: a member's delta for a
+ * subject is lerped into what the members before it left there by its share of the weight
+ * taken, as the general path's `foldLocus` does, so each subject's locus can fold in at its
+ * first member's place in the order.
+ */
+export function gatherLocus(lanes, g) {
+    const cap = lanes.cap;
+    if (g.met.length < cap) {
+        g.met = sized(g.met, cap);
+        g.first = sized(g.first, cap);
+        g.sum = sized(g.sum, cap);
+    }
+    for (let k = 0; k < g.values.length; k++) {
+        const values = g.values[k];
+        const taken = g.taken[k];
+        const axes = lanes.laned[k].axes;
+        if (values !== undefined)
+            g.values[k] = sized(values, cap * axes);
+        if (taken !== undefined)
+            g.taken[k] = sized(taken, cap);
+    }
+    lanes.into = g;
+    try {
+        for (const lane of g.members) {
+            const voice = lane.voice;
+            if (lane.idle || voice.state === 'pending' || voice.state === 'done')
+                continue;
+            lanes.intoId = voice.id;
+            lanes.reset(lane);
+            const elapsed = voice.elapsedAt(lanes.now);
+            const duration = voice.duration;
+            const passes = voice.passes;
+            const list = lane.list;
+            for (let p = 0; p < list.length; p++) {
+                const slot = list[p];
+                if (lanes.one(lane, p, slot, elapsed, duration, passes)) {
+                    meetLocus(lanes, g, slot);
+                    g.sum[slot] =
+                        g.sum[slot] + lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */];
+                }
+                if (voice.keeping)
+                    break;
+            }
+        }
+    }
+    finally {
+        lanes.into = null;
+    }
+}
+/** The first a fill hears of a subject in a locus: from the member now gathering. */
+function meetLocus(lanes, g, slot) {
+    if (g.met[slot] === lanes.fills)
+        return;
+    g.met[slot] = lanes.fills;
+    g.first[slot] = lanes.intoId;
+    g.sum[slot] = 0;
+    for (const taken of g.taken)
+        if (taken !== undefined)
+            taken[slot] = 0;
+}
+/** A member's value for one channel of a subject, lerped into its locus: `foldLocus`'s step. */
+function gatherInto(lanes, g, ch, slot, value, w) {
+    meetLocus(lanes, g, slot);
+    const k = ch.index;
+    let values = g.values[k];
+    let takenAt = g.taken[k];
+    if (values === undefined || takenAt === undefined) {
+        values = new Float64Array(lanes.cap * ch.axes);
+        takenAt = new Float64Array(lanes.cap);
+        g.values[k] = values;
+        g.taken[k] = takenAt;
+    }
+    const taken = takenAt[slot];
+    const total = taken + w;
+    const u = w / total;
+    if (ch.scalar) {
+        values[slot] =
+            taken === 0 ? value : lerpNumber(values[slot], value, u);
+    }
+    else {
+        // Read past its end as the rest, as `vec`'s lerp and fold both read an array.
+        const arr = Array.isArray(value) || ArrayBuffer.isView(value) ? value : null;
+        const base = slot * ch.axes;
+        for (let a = 0; a < ch.axes; a++) {
+            const v = arr === null ? ch.rest : (arr[a] ?? ch.rest);
+            values[base + a] = taken === 0 ? v : lerpNumber(values[base + a], v, u);
+        }
+    }
+    takenAt[slot] = total;
+}
+/** A locus member's turn in the order: each subject it was the first member of takes the locus. */
+export function foldLocus(lanes, lane, g) {
+    const id = lane.voice.id;
+    const fills = lanes.fills;
+    const list = lane.list;
+    for (let p = 0; p < list.length; p++) {
+        const slot = list[p];
+        if (g.met[slot] !== fills || g.first[slot] !== id)
+            continue;
+        const sum = g.sum[slot];
+        if (sum <= 0)
+            continue;
+        const w = sum > 1 ? 1 : sum;
+        for (let k = 0; k < g.values.length; k++) {
+            const takenAt = g.taken[k];
+            if (takenAt === undefined || !(takenAt[slot] > 0))
+                continue;
+            const ch = lanes.laned[k];
+            const values = g.values[k];
+            const into = ch.values;
+            const base = slot * ch.axes;
+            for (let a = 0; a < ch.axes; a++)
+                into[base + a] = foldNumber(ch.op, into[base + a], values[base + a], w);
+        }
+    }
+}
+/** For a keys voice: the delta's value for each channel it writes, read once per phase. */
+export function gather(lane, delta) {
+    const chans = lane.chans;
+    for (let i = 0; i < chans.length; i++)
+        lane.values[i] = delta[chans[i].name];
+}
+/** Folds what `gather` read into a subject's laned values. */
+export function fold(lane, slot, w) {
+    const chans = lane.chans;
+    for (let i = 0; i < chans.length; i++)
+        this.foldInto(chans[i], slot, lane.values[i], w);
+}
+/**
+ * Folds a delta a patch returned into a subject's laned values. The first few channels are read
+ * at a site of their own, which in most mixes sees one channel name and stays fast, where one
+ * site reading every name in turn slows every read.
+ */
+export function foldDelta(chans, slot, delta, w) {
+    const n = chans.length;
+    let ch = chans[0];
+    if (n > 0)
+        this.foldInto(ch, slot, delta[ch.name], w);
+    ch = chans[1];
+    if (n > 1)
+        this.foldInto(ch, slot, delta[ch.name], w);
+    ch = chans[2];
+    if (n > 2)
+        this.foldInto(ch, slot, delta[ch.name], w);
+    for (let i = 3; i < n; i++) {
+        ch = chans[i];
+        this.foldInto(ch, slot, delta[ch.name], w);
+    }
+}
+/** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
+export function foldRun(ch, slot, xs, w) {
+    const values = ch.values;
+    const base = slot * ch.axes;
+    for (let a = 0; a < ch.axes; a++)
+        values[base + a] = foldNumber(ch.op, values[base + a], xs[a], w);
+}
+export function foldInto(ch, slot, value, w) {
+    if (value === undefined)
+        return;
+    if (this.into !== null) {
+        gatherInto(this, this.into, ch, slot, value, w);
+        return;
+    }
+    const values = ch.values;
+    if (ch.scalar) {
+        values[slot] = foldNumber(ch.op, values[slot], value, w);
+        return;
+    }
+    const base = slot * ch.axes;
+    // Indexed as `vec`'s fold indexes it, so a typed array folds as an array does.
+    const arr = Array.isArray(value) || ArrayBuffer.isView(value) ? value : null;
+    for (let a = 0; a < ch.axes; a++) {
+        const v = arr === null ? ch.rest : (arr[a] ?? ch.rest);
+        values[base + a] = foldNumber(ch.op, values[base + a], v, w);
+    }
+}