@msb235/blits 0.3.0 → 0.4.0

package/dist/lanes.js

@@ -1,6 +1,6 @@
 import { foldNumber, numericOf } from './channels.js';
 import { clampWeight, passAt, phaseAt } from './clock.js';
-import { motionOf } from './motion.js';
+import { closed, motionOf, noTouch } from './motion.js';
 import { absent, Numbers } from './numbers.js';
 import { readKeys } from './patch.js';
 import { reading } from './reading.js';
@@ -41,7 +41,7 @@ export function clampRun(out, at, n, [lo, hi]) {
         out[i] = x < lo ? lo : x > hi ? hi : x;
     }
 }
-const STRIDE = 7;
+const STRIDE = 8;
 const DELAY = 0;
 const SINCE = 1;
 /** The weight the last fill gave the subject. */
@@ -52,8 +52,18 @@ const MSLOT = 4;
 /** For a motion voice, the last fill that sampled the subject, and the voice's seeks then. */
 const SAMPLED = 5;
 const SEEKS = 6;
+/** 1 once the general path has made the voice's first call for the subject, which never undoes. */
+const MET = 7;
+/** What `begin` found: the general path, only solo lanes, or lanes filled. */
+const GENERAL = 0;
+const SOLO = 1;
+const READY = 2;
 const SLOT = 6;
 const FILLED = 0;
+/**
+ * The latest epoch a probe has checked the subject against; or, as `-1 - e`, that a voice naming
+ * it started after epoch `e`, so its next probe checks it against everything since `e`.
+ */
 const SEEN = 1;
 const IDLE = 2;
 const LANE_PROBE = 3;
@@ -147,6 +157,30 @@ class Lane {
     flat = false;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
     motion;
+    voiceAt() {
+        return this.voice;
+    }
+    keep(p, xs, n) {
+        if (this.axes !== n) {
+            this.axes = n;
+            this.samples = new Float64Array(0);
+        }
+        if ((p + 1) * n > this.samples.length) {
+            const grown = new Float64Array(Math.max(p + 1, (this.samples.length / n) * 2, 4) * n);
+            grown.set(this.samples);
+            this.samples = grown;
+        }
+        for (let a = 0; a < n; a++)
+            this.samples[p * n + a] = xs[a];
+    }
+    kept(p, xs) {
+        const n = this.axes;
+        for (let a = 0; a < n; a++)
+            xs[a] = this.samples[p * n + a];
+    }
+    motionAt() {
+        return this.motion;
+    }
     constructor(voice) {
         this.voice = voice;
         this.motion = motionOf(voice.patch);
@@ -169,11 +203,12 @@ class Lane {
         }
         const o = p * STRIDE;
         this.data[o + DELAY] = held.delay;
-        this.data[o + SINCE] = held.since;
+        this.data[o + SINCE] = held.shown;
         this.data[o + WEIGHT] = 0;
         this.data[o + PROBED] = 0;
         this.data[o + MSLOT] = -1;
         this.data[o + SAMPLED] = -1;
+        this.data[o + MET] = 0;
         this.records[p] = held;
         this.deltas[p] = null;
     }
@@ -200,6 +235,144 @@ class Lane {
         this.deltas[last] = null;
     }
 }
+/** Whether a laned voice belongs in a crowd: one naming a single subject and writing one channel. */
+function crowdable(v) {
+    return v.named !== null && v.named.size === 1 && v.slots.length === 1;
+}
+/**
+ * A subject's voice time once its voice's holds apply: held at 0 before it starts and at the end of
+ * its passes after, and NaN where it shows nothing.
+ */
+function held(voice, elapsed) {
+    if (elapsed < 0)
+        return voice.holdsBefore ? 0 : Number.NaN;
+    return voice.holdsAfter && elapsed > voice.span ? voice.span : elapsed;
+}
+/** The law of a row that has none, a keys or fn voice's. */
+const none = new Float64Array(0);
+/** Per row of a crowd's `hot`: what the fill reads of the row's voice and its current stretch. */
+const H_FLAGS = 0;
+const H_NOW = 1;
+const H_ELAPSED = 2;
+const H_RATE = 3;
+/** The voice's weight, held to 0..1. */
+const H_WEIGHT = 4;
+const H_SEEKS = 5;
+const H_EPOCH = 6;
+const H_ID = 7;
+const H_AT = 8;
+const H_MS = 9;
+/** `x0`, `v0` and `to`, `axes` numbers each. */
+const H_X0 = 10;
+/** The voice is playing: live, held or fading. */
+const F_PLAYING = 1;
+/** Its weight and clock are `hot`'s: no fade in or out, rate ramp, subject ramp or kept state. */
+const F_FAST = 2;
+/** Its stretch changed since `hot` copied it. */
+const F_STALE = 4;
+/** `hot` holds its stretch, with nothing pending and no earlier stretch kept. */
+const F_BARE = 8;
+/** A probe has met its subject, so its per-subject numbers are set. */
+const F_PLACED = 16;
+/** Its samples fold as the channel's axes, a number for a number and an array for an array. */
+const F_FOLDS = 32;
+/** Something on the voice changed since `hot` copied it. */
+const F_VOICE = 64;
+/** The row's voice is a motion voice; otherwise its patch is keys or a stateless fn. */
+const F_MOTION = 128;
+/** The voice holds before or after, so its clock is read from the voice. */
+const F_HOLDS = 256;
+/**
+ * Every laned voice on one channel that reaches a single subject, a row each, in voice order: the
+ * per-subject numbers a lane keeps, and a copy of what a fill reads of the voice and, for a motion
+ * voice, its patch, so a fill over 100k of them reads a few flat arrays instead of 100k voices,
+ * lanes and patch buffers. Each copy is written when its source changes: the voice's by
+ * `voiceChanged`, the stretch through the patch's `touched`.
+ */
+class Crowd {
+    chans;
+    axes;
+    /** The subject number at each row. */
+    list = [];
+    /** `STRIDE` numbers per row, laid out as a lane's. */
+    data = new Float64Array(0);
+    hot = new Float64Array(0);
+    stride;
+    samples = new Float64Array(0);
+    deltas = [];
+    records = [];
+    voices = [];
+    motions = [];
+    eases = [];
+    /** Each row's patch law, one array shared by every row whose law is the same. */
+    laws = [];
+    touches = [];
+    rowOf = new Map();
+    idle = false;
+    line = SPARSE.other;
+    /** Where the fill now under way has reached. */
+    cursor = 0;
+    /** Rows whose voices have left, kept in place until the crowds are next rebuilt. */
+    dead = 0;
+    xs;
+    vs;
+    /** What a keys row reads into, folded before the next row reads. */
+    delta = {};
+    scratch = [];
+    constructor(chans, axes) {
+        this.chans = chans;
+        this.axes = axes;
+        this.stride = H_X0 + 3 * axes;
+        this.xs = new Float64Array(axes);
+        this.vs = new Float64Array(axes);
+    }
+    voiceAt(p) {
+        return this.voices[p];
+    }
+    /** Samples of another width than the channel's, which `samples` cannot hold, by row. */
+    odd = null;
+    keep(p, xs, n) {
+        if (n === this.axes) {
+            for (let a = 0; a < n; a++)
+                this.samples[p * n + a] = xs[a];
+            this.odd?.delete(p);
+            return;
+        }
+        this.odd ??= new Map();
+        this.odd.set(p, xs.slice(0, n));
+    }
+    kept(p, xs) {
+        const odd = this.odd?.get(p);
+        if (odd !== undefined) {
+            xs.set(odd);
+            return;
+        }
+        const n = this.axes;
+        for (let a = 0; a < n; a++)
+            xs[a] = this.samples[p * n + a];
+    }
+    motionAt(p) {
+        return this.motions[p];
+    }
+    get size() {
+        return this.list.length;
+    }
+    /** Makes room for `rows` rows. */
+    reserve(rows) {
+        if (rows * STRIDE <= this.data.length)
+            return;
+        const cap = Math.max(rows, (this.data.length / STRIDE) * 2, 16);
+        const data = new Float64Array(cap * STRIDE);
+        data.set(this.data);
+        this.data = data;
+        const hot = new Float64Array(cap * this.stride);
+        hot.set(this.hot);
+        this.hot = hot;
+        const samples = new Float64Array(cap * this.axes);
+        samples.set(this.samples);
+        this.samples = samples;
+    }
+}
 /**
  * The lanes of one mix: subject numbers, which channels and voices run on lanes, and the values a
  * frame's fill leaves for probes to copy.
@@ -213,6 +386,10 @@ export class Lanes {
     /** The lanes over every subject that have started playing, by epoch. */
     dense = [];
     byId = new Map();
+    /** The crowds of single-subject motion voices, one per channel, and which holds each voice. */
+    crowds = [];
+    crowdOf = new Map();
+    lawsByKey = new Map();
     laned = [];
     /** By kit slot, the laned channel there. */
     bySlot = [];
@@ -222,6 +399,12 @@ export class Lanes {
     whole = false;
     cap = 0;
     epochs = 0;
+    /** The latest epoch of a lane over every subject, which every subject meets on its next probe. */
+    wide = 0;
+    /** Voices that joined, started or left since the last qualify, settled at the next probe. */
+    touched = [];
+    /** The highest voice id the last qualify or settling of `touched` considered. */
+    known = 0;
     /**
      * Per subject number, `SLOT` numbers side by side, so a probe reads one place in memory: which
      * fill last wrote it (0 for none); the latest lane epoch a probe of it has checked it against;
@@ -248,6 +431,12 @@ export class Lanes {
      * the general path has to make.
      */
     late = [];
+    /** What `writeLater` has queued: lane slots and the rows they go to, for one set of columns. */
+    queueSlots = new Int32Array(0);
+    queueRows = new Int32Array(0);
+    queued = 0;
+    inOrder = true;
+    queuedFor = null;
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
@@ -281,13 +470,21 @@ export class Lanes {
     refill() {
         this.filledVersion = Number.NaN;
     }
+    /**
+     * A voice joined, started playing or left: the next probe takes it on or off its crowd where it
+     * can, and qualifies again where it cannot.
+     */
+    touch(voice) {
+        this.touched.push(voice);
+        this.filledVersion = Number.NaN;
+    }
     /** Numbers a subject the mix sees for the first time. */
     number(subject) {
         const slot = this.numbers.take(subject);
         this.live++;
         this.grow(slot + 1);
         this.per[slot * SLOT + FILLED] = 0;
-        this.per[slot * SLOT + SEEN] = 0;
+        this.per[slot * SLOT + SEEN] = -1;
         this.per[slot * SLOT + IDLE] = 0;
         this.per[slot * SLOT + LANE_PROBE] = 0;
         this.per[slot * SLOT + GENERAL_PROBE] = 0;
@@ -299,16 +496,56 @@ export class Lanes {
     release(slot) {
         this.numbers.release(slot);
     }
+    /** A voice faded a subject out of itself alone: its lane lets the subject's position go. */
+    part(id, slot) {
+        const lane = this.byId.get(id);
+        if (lane !== undefined) {
+            if (lane.positionOf(slot) < 0)
+                return;
+            if (lane.idle)
+                this.reach(slot, -1);
+            lane.remove(slot);
+            return;
+        }
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        if (c !== undefined && p !== undefined && c.list[p] === slot)
+            this.unplace(c, p);
+    }
+    /** Takes a crowd row off its subject, to be placed again if a probe meets it again. */
+    unplace(c, p) {
+        const slot = c.list[p];
+        if (c.idle && slot >= 0)
+            this.reach(slot, -1);
+        c.list[p] = -1;
+        c.records[p] = undefined;
+        c.deltas[p] = null;
+        const f = p * c.stride + H_FLAGS;
+        c.hot[f] = c.hot[f] & ~F_PLACED;
+        const o = p * STRIDE;
+        c.data[o + MSLOT] = -1;
+        c.data[o + SAMPLED] = -1;
+        c.data[o + MET] = 0;
+    }
+    /** A voice brought a subject back: its next probe meets every lane again, as it met them first. */
+    rejoin(slot) {
+        if (slot < this.cap)
+            this.per[slot * SLOT + SEEN] = -1;
+    }
     /**
      * A laned voice's weight for a subject at the last frame a probe read it from the lane; undefined
      * where the subject's record holds it instead, because its last probe took the general path or
      * the voice is not on a lane.
      */
     weightOf(id, slot) {
-        const lane = this.byId.get(id);
-        if (lane === undefined || slot < 0)
+        if (slot < 0)
             return undefined;
-        return this.reported(lane, slot);
+        const lane = this.byId.get(id);
+        if (lane !== undefined)
+            return this.reported(lane, slot);
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        return c === undefined || p === undefined ? undefined : this.reportedRow(c, p, slot);
     }
     reported(lane, slot) {
         const o = slot * SLOT;
@@ -325,6 +562,91 @@ export class Lanes {
      * this frame, which is where it is first seen; so does one probed from inside a fill.
      */
     prepare(slot, subject, now, version) {
+        const ready = this.filled(now, version) ? READY : this.begin(now, version);
+        if (ready === GENERAL)
+            return this.general(slot);
+        if (slot < 0)
+            return false;
+        if (ready === SOLO) {
+            if (this.per[slot * SLOT + SEEN] < this.wide)
+                this.meet(slot, subject);
+            return this.general(slot);
+        }
+        if (!this.probedThisFrame(slot))
+            this.distinct++;
+        const probe = ++this.probes;
+        const per = this.per;
+        const o = slot * SLOT;
+        let lane = per[o + FILLED] === this.fills && per[o + IDLE] === 0;
+        if (per[o + SEEN] < this.wide && this.meet(slot, subject)) {
+            // The fill ran before the subject had these positions, so it reads the general path all frame.
+            per[o + FILLED] = 0;
+            lane = false;
+        }
+        if (lane) {
+            per[o + LANE_PROBE] = probe;
+            per[o + LANE_FILL] = this.fills;
+            this.subjects[slot] = subject;
+            this.holding = true;
+        }
+        else
+            per[o + GENERAL_PROBE] = probe;
+        return lane;
+    }
+    /**
+     * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
+     * `heads` holds each position's remembered chain head unless all are known current: what
+     * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
+     * from the lanes; returns the first position that does not, or the list's length.
+     */
+    pullRun(slots, list, was, heads, from, columns, now, version) {
+        const ready = this.filled(now, version) ? READY : this.begin(now, version);
+        if (ready !== READY || !this.whole)
+            return from;
+        const per = this.per;
+        const fills = this.fills;
+        const wide = this.wide;
+        const frame = this.frameProbes;
+        const subjects = this.subjects;
+        let n = from;
+        for (; n < list.length; n++) {
+            const subject = list[n];
+            if (was[n] !== subject || (heads !== null && heads[n]?.version !== version))
+                break;
+            const slot = slots[n];
+            const o = slot * SLOT;
+            if (slot < 0 ||
+                per[o + FILLED] !== fills ||
+                per[o + IDLE] !== 0 ||
+                per[o + SEEN] < wide)
+                break;
+            if (!(per[o + LANE_PROBE] > frame || per[o + GENERAL_PROBE] > frame))
+                this.distinct++;
+            per[o + LANE_PROBE] = ++this.probes;
+            per[o + LANE_FILL] = fills;
+            subjects[slot] = subject;
+            this.writeLater(slot, columns, n);
+        }
+        if (n > from)
+            this.holding = true;
+        return n;
+    }
+    /** Whether this frame's lanes are filled and nothing since asks `begin` to look again. */
+    filled(now, version) {
+        return (this.filledAt === now &&
+            this.frameAt === now &&
+            this.filledVersion === version &&
+            this.qualifiedVersion === version &&
+            this.moved === reading.moved &&
+            this.touched.length === 0 &&
+            !this.filling);
+    }
+    /**
+     * What a probe does before its subject, once a frame's lanes are settled: qualifies and fills as
+     * needed. Says whether the subject takes the general path, whether only solo lanes exist, so
+     * there is nothing to fill, or whether the lanes are filled.
+     */
+    begin(now, version) {
         if (now !== this.frameAt) {
             this.lastFrom = this.frameProbes;
             this.lastTo = this.probes;
@@ -335,51 +657,27 @@ export class Lanes {
             this.fresh = true;
         }
         if (this.filling)
-            return this.general(slot);
+            return GENERAL;
         if (this.qualifiedVersion !== version)
             this.requalify(version);
+        else if (this.touched.length > 0 && !this.retouch())
+            this.requalify(version);
         if (this.laned.length === 0)
-            return this.general(slot);
+            return GENERAL;
         // Only solo lanes: nothing to fill, and every subject takes the general path.
-        if (this.runs.length === 0) {
-            if (slot < 0)
-                return false;
-            if (this.per[slot * SLOT + SEEN] < this.epochs)
-                this.meet(slot, subject);
-            return this.general(slot);
-        }
-        if (slot >= 0 && !this.probedThisFrame(slot))
-            this.distinct++;
+        if (this.runs.length === 0 && this.crowds.length === 0)
+            return SOLO;
         if (this.filledAt !== now || this.filledVersion !== version || this.moved !== reading.moved) {
             this.fillAll(now, version);
             // A patch call in that fill made kept state, which took its voice off its lane: fill without it.
             if (this.qualifiedVersion !== version) {
                 this.requalify(version);
                 if (this.laned.length === 0)
-                    return this.general(slot);
+                    return GENERAL;
                 this.fillAll(now, version);
             }
         }
-        if (slot < 0)
-            return false;
-        const probe = ++this.probes;
-        const per = this.per;
-        const o = slot * SLOT;
-        let lane = per[o + FILLED] === this.fills && per[o + IDLE] === 0;
-        if (per[o + SEEN] < this.epochs && this.meet(slot, subject)) {
-            // The fill ran before the subject had these positions, so it reads the general path all frame.
-            per[o + FILLED] = 0;
-            lane = false;
-        }
-        if (lane) {
-            per[o + LANE_PROBE] = probe;
-            per[o + LANE_FILL] = this.fills;
-            this.subjects[slot] = subject;
-            this.holding = true;
-        }
-        else
-            per[o + GENERAL_PROBE] = probe;
-        return lane;
+        return READY;
     }
     general(slot) {
         if (slot >= 0)
@@ -393,28 +691,75 @@ export class Lanes {
         return (this.per[o + LANE_PROBE] > from || this.per[o + GENERAL_PROBE] > from);
     }
     /**
-     * Writes a subject's values into each column at subject `n`'s places, for a probe that reads from
-     * the lanes while every voice is on one: a channel no lane holds is at rest.
+     * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
+     * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A
+     * channel no lane holds is at rest. Anything queued is written before the lanes fill again.
      */
-    write(slot, columns, n) {
-        const bySlot = this.bySlot;
+    writeLater(slot, columns, n) {
+        if (columns !== this.queuedFor) {
+            this.flush();
+            this.queuedFor = columns;
+        }
+        const k = this.queued;
+        if (k === this.queueSlots.length) {
+            const slots = new Int32Array(Math.max(64, k * 2));
+            slots.set(this.queueSlots);
+            this.queueSlots = slots;
+            const rows = new Int32Array(slots.length);
+            rows.set(this.queueRows);
+            this.queueRows = rows;
+        }
+        this.queueSlots[k] = slot;
+        this.queueRows[k] = n;
+        if (k > 0 &&
+            (slot !== this.queueSlots[k - 1] + 1 ||
+                n !== this.queueRows[k - 1] + 1))
+            this.inOrder = false;
+        this.queued = k + 1;
+    }
+    flush() {
+        const count = this.queued;
+        const columns = this.queuedFor;
+        if (count === 0 || columns === null)
+            return;
+        this.queued = 0;
+        // Subjects numbered in the order the host lists them: each column is one block.
+        const block = this.inOrder;
+        this.inOrder = true;
+        const slots = this.queueSlots;
+        const rows = this.queueRows;
         for (let k = 0; k < columns.length; k++) {
             const c = columns[k];
             const axes = c.axes;
             const out = c.out;
-            const at = n * axes;
-            const ch = bySlot[c.slot];
+            const ch = this.bySlot[c.slot];
             if (ch === undefined) {
-                for (let a = 0; a < axes; a++)
-                    out[at + a] = c.rest[a];
+                for (let i = 0; i < count; i++) {
+                    const at = rows[i] * axes;
+                    for (let a = 0; a < axes; a++)
+                        out[at + a] = c.rest[a];
+                }
                 continue;
             }
             const values = ch.values;
-            const base = slot * axes;
-            for (let a = 0; a < axes; a++)
-                out[at + a] = values[base + a];
+            if (block) {
+                const s0 = slots[0] * axes;
+                out.set(values.subarray(s0, s0 + count * axes), rows[0] * axes);
+            }
+            else if (axes === 1) {
+                for (let i = 0; i < count; i++)
+                    out[rows[i]] = values[slots[i]];
+            }
+            else
+                for (let i = 0; i < count; i++) {
+                    const at = rows[i] * axes;
+                    const base = slots[i] * axes;
+                    for (let a = 0; a < axes; a++)
+                        out[at + a] = values[base + a];
+                }
             if (c.bounds !== undefined)
-                clampRun(out, at, axes, c.bounds);
+                for (let i = 0; i < count; i++)
+                    clampRun(out, rows[i] * axes, axes, c.bounds);
         }
     }
     /** Writes a subject's laned values into a pose, each array channel into a new array. */
@@ -423,7 +768,7 @@ export class Lanes {
         for (let c = 0; c < laned.length; c++) {
             const ch = laned[c];
             const axes = ch.axes;
-            if (axes === 1) {
+            if (ch.scalar) {
                 pose[ch.name] = ch.values[slot];
                 continue;
             }
@@ -440,7 +785,8 @@ export class Lanes {
      * checked and that reaches it. True when any did, so the probe takes the general path.
      */
     meet(slot, subject) {
-        const from = this.per[slot * SLOT + SEEN];
+        const seen = this.per[slot * SLOT + SEEN];
+        const from = seen < 0 ? -1 - seen : seen;
         this.per[slot * SLOT + SEEN] = this.epochs;
         let met = false;
         const dense = this.dense;
@@ -448,6 +794,8 @@ export class Lanes {
             const lane = dense[i];
             if (lane.epoch <= from)
                 break;
+            if (lane.positionOf(slot) >= 0)
+                continue;
             const held = this.host.meet(lane.voice, subject);
             if (!held.reaches)
                 continue;
@@ -460,15 +808,52 @@ export class Lanes {
         if (naming !== undefined)
             for (const voice of naming) {
                 const lane = this.byId.get(voice.id);
-                if (lane === undefined || lane.epoch <= from || lane.positionOf(slot) >= 0)
+                if (lane === undefined) {
+                    if (this.place(voice, slot, subject, from))
+                        met = true;
+                    continue;
+                }
+                if (lane.epoch <= from || lane.positionOf(slot) >= 0)
                     continue;
-                lane.add(slot, this.host.meet(voice, subject));
+                const held = this.host.meet(voice, subject);
+                if (!held.reaches)
+                    continue;
+                lane.add(slot, held);
                 if (lane.idle)
                     this.reach(slot, 1);
                 met = true;
             }
         return met;
     }
+    /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
+    place(voice, slot, subject, from) {
+        const c = this.crowdOf.get(voice.id);
+        const p = c?.rowOf.get(voice.id);
+        if (c === undefined || p === undefined)
+            return false;
+        const h = p * c.stride;
+        const flags = c.hot[h + H_FLAGS];
+        if (c.hot[h + H_EPOCH] <= from || (flags & F_PLACED) !== 0)
+            return false;
+        const held = this.host.meet(voice, subject);
+        if (!held.reaches)
+            return false;
+        const o = p * STRIDE;
+        c.list[p] = slot;
+        c.data[o + DELAY] = held.delay;
+        c.data[o + SINCE] = held.shown;
+        c.data[o + WEIGHT] = 0;
+        c.data[o + PROBED] = 0;
+        c.data[o + MSLOT] = -1;
+        c.data[o + SAMPLED] = -1;
+        c.data[o + MET] = 0;
+        c.records[p] = held;
+        c.deltas[p] = null;
+        c.hot[h + H_FLAGS] = flags | F_PLACED | F_STALE;
+        if (c.idle)
+            this.reach(slot, 1);
+        return true;
+    }
     /** Counts an idle lane more or fewer reaching a subject. */
     reach(slot, by) {
         const i = slot * SLOT + IDLE;
@@ -478,6 +863,10 @@ export class Lanes {
         this.live--;
         for (const lane of this.lanes)
             lane.remove(slot);
+        for (const c of this.crowds)
+            for (let p = 0; p < c.size; p++)
+                if (c.list[p] === slot)
+                    this.unplace(c, p);
         if (slot < this.cap)
             this.per[slot * SLOT + FILLED] = 0;
         this.subjects[slot] = undefined;
@@ -497,10 +886,15 @@ export class Lanes {
         this.cap = cap;
     }
     requalify(version) {
+        this.flush();
         const host = this.host;
         this.qualifiedVersion = version;
         this.filledVersion = Number.NaN;
+        this.touched.length = 0;
         const present = host.voices.filter((v) => v.state !== 'done');
+        for (const v of present)
+            if (v.id > this.known)
+                this.known = v.id;
         const numeric = host.channels.map((c) => numericOf(c) !== undefined);
         const { channels, voices } = qualify(numeric, 
         // A voice writing nothing has no lane to fill, so it stays where its calls are made.
@@ -509,13 +903,18 @@ export class Lanes {
             if (!voices.has(lane.voice.id))
                 this.leave(lane);
         const kept = [];
+        let crowded = 0;
         for (const v of present) {
             if (!voices.has(v.id))
                 continue;
+            if (crowdable(v)) {
+                crowded++;
+                continue;
+            }
             const lane = this.byId.get(v.id) ?? new Lane(v);
             v.laned = true;
-            if (lane.epoch === 0 && (v.state === 'live' || v.state === 'fading'))
-                lane.epoch = ++this.epochs;
+            if (lane.epoch === 0 && v.state !== 'pending')
+                lane.epoch = this.open(v);
             kept.push(lane);
         }
         this.lanes = kept;
@@ -523,12 +922,12 @@ export class Lanes {
         this.dense = kept
             .filter((l) => l.voice.named === null && l.epoch > 0)
             .sort((a, b) => a.epoch - b.epoch);
-        this.whole = kept.length === present.length;
+        this.whole = kept.length + crowded === present.length;
         this.byId.clear();
         for (const lane of kept)
             this.byId.set(lane.voice.id, lane);
         // With no lane left no fill comes to let go of the subjects the last probes held.
-        if (kept.length === 0)
+        if (kept.length === 0 && crowded === 0)
             this.subjects = [];
         this.laned = [];
         this.bySlot = host.channels.map(() => undefined);
@@ -541,6 +940,7 @@ export class Lanes {
             const ch = {
                 name: host.names[slot],
                 op: n.op,
+                scalar: typeof rest === 'number',
                 rest: typeof rest === 'number' ? rest : rest[0],
                 axes: n.axes,
                 values: new Float64Array(this.cap * n.axes),
@@ -556,6 +956,240 @@ export class Lanes {
             lane.chans = lane.voice.slots.map((s) => this.bySlot[s]);
             lane.values = lane.chans.map(() => undefined);
         }
+        this.regroup(present.filter((v) => voices.has(v.id) && crowdable(v)));
+    }
+    /**
+     * Rebuilds the crowds from the voices that belong in one, in voice order: a voice already in a
+     * crowd keeps its row's numbers, a new one gets a row a probe will place, and a voice no longer in
+     * one is handed back to the general path, as a lane's voice is when it leaves.
+     */
+    regroup(members) {
+        const keep = new Set(members.map((v) => v.id));
+        for (const c of this.crowds)
+            for (let p = 0; p < c.size; p++) {
+                const v = c.voices[p];
+                if (!keep.has(v.id) || v.state === 'done')
+                    this.leaveCrowd(c, p);
+            }
+        const old = this.crowds;
+        const was = new Map(this.crowdOf);
+        this.crowds = [];
+        this.crowdOf.clear();
+        for (const v of members) {
+            const from = was.get(v.id);
+            this.join(v, from, from?.rowOf.get(v.id), old);
+        }
+        if (this.crowds.length === 0)
+            this.lawsByKey.clear();
+    }
+    /**
+     * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+     * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
+     * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+     */
+    join(v, from, at, old) {
+        const ch = this.bySlot[v.slots[0]];
+        let c = this.crowds.find((o) => o.chans[0] === ch);
+        if (c === undefined) {
+            c = new Crowd([ch], ch.axes);
+            const was = old.find((o) => o.chans[0]?.name === ch.name);
+            if (was !== undefined)
+                c.idle = was.idle;
+            this.crowds.push(c);
+        }
+        const p = c.size;
+        c.reserve(p + 1);
+        if (from !== undefined && at !== undefined)
+            this.copyRow(from, at, c, p);
+        else
+            this.newRow(c, p, v);
+        if (c.hot[p * c.stride + H_EPOCH] === 0 && v.state !== 'pending')
+            c.hot[p * c.stride + H_EPOCH] = this.open(v);
+        c.rowOf.set(v.id, p);
+        this.crowdOf.set(v.id, c);
+        v.laned = true;
+    }
+    /**
+     * A voice starts playing on a lane or crowd: its epoch. Every subject meets a voice over all of
+     * them on its next probe; a voice naming its subjects marks only those.
+     */
+    open(v) {
+        const epoch = ++this.epochs;
+        if (v.named === null) {
+            this.wide = epoch;
+            return epoch;
+        }
+        for (const subject of v.named) {
+            const slot = this.host.slotOf(subject);
+            if (slot < 0 || slot >= this.cap)
+                continue;
+            const i = slot * SLOT + SEEN;
+            const seen = this.per[i];
+            const from = seen < 0 ? -1 - seen : seen;
+            this.per[i] = -1 - Math.min(from, epoch - 1);
+        }
+        return epoch;
+    }
+    /**
+     * Takes the voices `touch` named on or off their crowds, each as it now stands; false at the
+     * first that cannot be, which needs a qualify: one that leaves a lane or the general path, which
+     * may open a channel, or one that joins anything but a crowd on a laned channel. Neither a voice
+     * that fits joining laned channels nor a laned one leaving moves the fixed point `qualify` finds.
+     * False too once a crowd is more than half empty rows, which a qualify rebuilds without.
+     */
+    retouch() {
+        const touched = [...new Set(this.touched)].sort((a, b) => a.id - b.id);
+        this.touched.length = 0;
+        for (const v of touched) {
+            const known = v.id <= this.known;
+            if (v.id > this.known)
+                this.known = v.id;
+            const c = this.crowdOf.get(v.id);
+            const p = c?.rowOf.get(v.id);
+            if (c !== undefined && p !== undefined) {
+                if (v.state === 'done') {
+                    this.bury(c, p);
+                    continue;
+                }
+                const h = p * c.stride;
+                if (c.hot[h + H_EPOCH] === 0 && v.state !== 'pending')
+                    c.hot[h + H_EPOCH] = this.open(v);
+                c.hot[h + H_FLAGS] = c.hot[h + H_FLAGS] | F_VOICE;
+                continue;
+            }
+            if (v.state === 'done' && !known)
+                continue;
+            if (v.state === 'done' || this.byId.has(v.id))
+                return false;
+            const laned = v.slots.some((slot) => this.bySlot[slot] !== undefined);
+            const fits = v.slots.length > 0 && this.host.fits(v);
+            if (!laned && !fits) {
+                this.whole = false;
+                continue;
+            }
+            if (known ||
+                !fits ||
+                !laned ||
+                !crowdable(v) ||
+                this.bySlot[v.slots[0]] === undefined)
+                return false;
+            this.join(v, undefined, undefined, this.crowds);
+        }
+        return !this.crowds.some((c) => c.dead > 64 && c.dead * 2 > c.size);
+    }
+    /** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+    bury(c, p) {
+        const v = c.voices[p];
+        this.leaveCrowd(c, p);
+        c.list[p] = -1;
+        c.records[p] = undefined;
+        c.deltas[p] = null;
+        c.motions[p] = undefined;
+        c.hot[p * c.stride + H_FLAGS] = 0;
+        c.rowOf.delete(v.id);
+        this.crowdOf.delete(v.id);
+        c.dead++;
+    }
+    copyRow(from, p, to, q) {
+        to.list[q] = from.list[p];
+        to.data.set(from.data.subarray(p * STRIDE, (p + 1) * STRIDE), q * STRIDE);
+        to.hot.set(from.hot.subarray(p * from.stride, (p + 1) * from.stride), q * to.stride);
+        to.samples.set(from.samples.subarray(p * from.axes, (p + 1) * from.axes), q * to.axes);
+        to.deltas[q] = from.deltas[p] ?? null;
+        to.records[q] = from.records[p];
+        to.voices[q] = from.voices[p];
+        to.motions[q] = from.motions[p];
+        to.eases[q] = from.eases[p];
+        to.laws[q] = from.laws[p];
+        to.touches[q] = from.touches[p];
+        const odd = from.odd?.get(p);
+        if (odd !== undefined) {
+            to.odd ??= new Map();
+            to.odd.set(q, odd);
+        }
+    }
+    newRow(c, p, v) {
+        const run = motionOf(v.patch);
+        const h = p * c.stride;
+        c.hot.fill(0, h, h + c.stride);
+        c.hot[h + H_FLAGS] = F_VOICE | F_STALE | (run === undefined ? 0 : F_MOTION);
+        c.hot[h + H_ID] = v.id;
+        c.list[p] = -1;
+        const o = p * STRIDE;
+        c.data.fill(0, o, o + STRIDE);
+        c.data[o + MSLOT] = -1;
+        c.data[o + SAMPLED] = -1;
+        c.deltas[p] = null;
+        c.records[p] = undefined;
+        c.voices[p] = v;
+        c.motions[p] = run;
+        if (run === undefined) {
+            c.laws[p] = none;
+            c.eases[p] = undefined;
+            c.touches[p] = noTouch;
+            return;
+        }
+        c.laws[p] = this.lawOf(run);
+        c.eases[p] = run.ease;
+        const id = v.id;
+        const touch = () => this.touchedCrowd(id);
+        run.touched = touch;
+        c.touches[p] = touch;
+    }
+    /** A patch's law, as the one array every crowd row with the same law shares. */
+    lawOf(run) {
+        const law = run.law();
+        const key = law.join(' ');
+        const known = this.lawsByKey.get(key);
+        if (known !== undefined)
+            return known;
+        this.lawsByKey.set(key, law);
+        return law;
+    }
+    /** A crowd voice's patch changed a stretch: its copy is read again at the next fill. */
+    touchedCrowd(id) {
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        if (c === undefined || p === undefined)
+            return;
+        const f = p * c.stride + H_FLAGS;
+        c.hot[f] = c.hot[f] | F_STALE;
+    }
+    /** Something on a voice changed: a crowd copies it again at the next fill. */
+    voiceChanged(id) {
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        if (c === undefined || p === undefined)
+            return;
+        const f = p * c.stride + H_FLAGS;
+        c.hot[f] = c.hot[f] | F_VOICE;
+    }
+    /** Hands a crowd voice back to the general path, as `leave` does a lane's. */
+    leaveCrowd(c, p) {
+        const slot = c.list[p];
+        const rec = c.records[p];
+        if (slot >= 0) {
+            if (c.idle)
+                this.reach(slot, -1);
+            const w = this.reportedRow(c, p, slot);
+            if (rec !== undefined && w !== undefined)
+                rec.weight = w;
+            if (rec !== undefined && c.motions[p] !== undefined)
+                this.settle(c, p, slot, rec);
+        }
+        const run = c.motions[p];
+        if (run !== undefined && run.touched === c.touches[p])
+            run.touched = noTouch;
+        c.voices[p].laned = false;
+    }
+    /** A crowd row's weight as `reported` reads a lane position's. */
+    reportedRow(c, p, slot) {
+        const o = slot * SLOT;
+        if (!(this.per[o + LANE_PROBE] > this.per[o + GENERAL_PROBE]))
+            return undefined;
+        if (c.list[p] !== slot)
+            return undefined;
+        return c.data[p * STRIDE + (this.per[o + LANE_FILL] === this.fills ? WEIGHT : PROBED)];
     }
     /** Hands a voice back to the general path, with the weights `weightOf` reports kept on its records. */
     leave(lane) {
@@ -573,6 +1207,7 @@ export class Lanes {
         lane.voice.laned = false;
     }
     fillAll(now, version) {
+        this.flush();
         const host = this.host;
         this.filling = true;
         try {
@@ -585,7 +1220,9 @@ export class Lanes {
             const decide = this.fresh;
             this.fresh = false;
             const share = this.live > 0 ? this.lastDistinct / this.live : 1;
-            // One pass, deciding and running each lane, since a mix of many small lanes pays per visit.
+            // Deciding which lanes and crowds go idle first, then running them, in voice order: a crowd's
+            // rows are folded between the lanes on either side of their voices, as the general path
+            // folds every voice in order.
             let busy = false;
             for (const lane of this.runs) {
                 if (decide) {
@@ -602,14 +1239,32 @@ export class Lanes {
                     else if (lane.idle ? share >= line.start : share < line.stop)
                         this.flip(lane);
                 }
-                if (lane.idle)
-                    continue;
-                if (!busy) {
+                if (!lane.idle)
                     busy = true;
-                    for (const ch of this.laned)
-                        ch.values.fill(ch.rest, 0, size * ch.axes);
+            }
+            for (const c of this.crowds) {
+                if (decide) {
+                    if (c.size >= 64)
+                        this.pace(c);
+                    else if (c.idle ? share >= c.line.start : share < c.line.stop)
+                        this.flip(c);
                 }
-                this.run(lane);
+                c.cursor = 0;
+                if (!c.idle && c.size > 0)
+                    busy = true;
+            }
+            if (busy) {
+                for (const ch of this.laned)
+                    ch.values.fill(ch.rest, 0, size * ch.axes);
+                for (const lane of this.runs) {
+                    if (lane.idle)
+                        continue;
+                    if (this.crowds.length > 0)
+                        this.crowdsUpTo(lane.voice.id);
+                    this.run(lane);
+                }
+                if (this.crowds.length > 0)
+                    this.crowdsUpTo(Number.POSITIVE_INFINITY);
             }
             // With every lane idle there was nothing to fill, and no subject reads a lane this frame.
             if (busy)
@@ -644,13 +1299,15 @@ export class Lanes {
         let probed = 0;
         for (let p = this.fills % step; p < list.length; p += step) {
             const slot = list[p];
+            if (slot < 0)
+                continue;
             const a = this.per[slot * SLOT + LANE_PROBE];
             const b = this.per[slot * SLOT + GENERAL_PROBE];
             if ((a > from && a <= to) || (b > from && b <= to))
                 probed++;
             looked++;
         }
-        const share = probed / looked;
+        const share = looked > 0 ? probed / looked : 1;
         if (lane.idle ? share >= line.start : share < line.stop)
             this.flip(lane);
     }
@@ -667,6 +1324,8 @@ export class Lanes {
         const data = lane.data;
         for (let p = 0; p < list.length; p++) {
             const slot = list[p];
+            if (slot < 0)
+                continue;
             this.reach(slot, 1);
             // A probe read this subject from the last fill, which this lane's weight stays from.
             if (this.per[slot * SLOT + LANE_FILL] === this.fills - 1) {
@@ -678,7 +1337,8 @@ export class Lanes {
     wake(lane) {
         lane.idle = false;
         for (const slot of lane.list)
-            this.reach(slot, -1);
+            if (slot >= 0)
+                this.reach(slot, -1);
     }
     subjectAt(slot) {
         let subject = this.subjects[slot];
@@ -692,7 +1352,7 @@ export class Lanes {
     /** One voice's contribution to every subject it plays on. */
     run(lane) {
         const voice = lane.voice;
-        if (voice.state !== 'live' && voice.state !== 'fading')
+        if (voice.state === 'pending' || voice.state === 'done')
             return;
         lane.placed = false;
         lane.read = false;
@@ -700,6 +1360,10 @@ export class Lanes {
         // With no fade in or out the envelope is 1 for every subject, which is what it would return.
         lane.flat = !((voice.fade.in ?? 0) > 0) && voice.out === null;
         lane.fade = 1;
+        if (lane.motion !== undefined && !voice.keeping) {
+            this.runMotion(lane, lane.motion);
+            return;
+        }
         const elapsed = voice.elapsedAt(this.now);
         const period = voice.patch.period;
         const passes = voice.passes;
@@ -720,8 +1384,8 @@ export class Lanes {
         if (this.per[slot * SLOT + LANE_FILL] === this.fills - 1)
             data[o + PROBED] = data[o + WEIGHT];
         const delay = data[o + DELAY];
-        const elapsed = elapsedNow - delay;
-        if (elapsed < 0) {
+        const elapsed = held(voice, elapsedNow - delay);
+        if (!(elapsed >= 0)) {
             data[o + WEIGHT] = 0;
             return;
         }
@@ -737,11 +1401,16 @@ export class Lanes {
             lane.weighed = true;
             lane.weighedSince = since;
         }
-        const w = clampWeight(voice.weight * lane.fade);
+        let w = clampWeight(voice.weight * lane.fade);
+        if (voice.parts !== null) {
+            const subject = this.subjectAt(slot);
+            if (subject !== absent)
+                w *= host.parting(voice, subject);
+        }
         data[o + WEIGHT] = w;
         if (voice.built !== null) {
             if (!lane.read || !Object.is(elapsed, lane.readAt)) {
-                readKeys(voice.built, lane.phase, lane.delta, undefined, voice.lerps, undefined, voice.intos, lane.scratch);
+                this.readKeyed(voice, lane.phase, lane.delta, lane.scratch);
                 lane.read = true;
                 lane.readAt = elapsed;
                 this.gather(lane, lane.delta);
@@ -750,39 +1419,302 @@ export class Lanes {
                 this.fold(lane, slot, w);
             return;
         }
-        const subject = this.subjectAt(slot);
-        if (subject === absent)
-            return;
-        const held = lane.records[p];
+        const rec = lane.records[p];
         // The general path makes a voice's first call for a subject, where it first sees it play.
-        if (Number.isNaN(held.probed)) {
+        if (Number.isNaN(rec.probed)) {
             this.late.push(slot);
             return;
         }
+        // A motion patch needs the subject only to number it, so the lookup waits until then.
         if (lane.motion !== undefined) {
-            this.move(lane, lane.motion, p, slot, subject, held, elapsed, delay, w);
+            this.move(lane, lane.motion, p, slot, rec, elapsed, delay, w);
             return;
         }
+        this.call(voice, lane.chans, rec, slot, elapsed, lane.phase, lane.pass, delay, w);
+    }
+    /** Reads a keys voice's stops at `phase` into `delta`, interpolating into the reader's `scratch`. */
+    readKeyed(voice, phase, delta, scratch) {
+        readKeys(voice.built, phase, delta, undefined, voice.lerps, undefined, voice.intos, scratch);
+    }
+    /** Calls a stateless fn voice's patch for a subject its general path has met, and folds the delta. */
+    call(voice, chans, rec, slot, elapsed, phase, pass, delay, w) {
+        const host = this.host;
+        const subject = this.subjectAt(slot);
+        if (subject === absent)
+            return;
         // Called already this frame, by the general path or a fill before a refill: reuse, as a probe does.
-        if (held.probed === this.now && held.delta !== null && held.seeks === voice.seeks) {
+        if (rec.probed === this.now && rec.delta !== null && rec.seeks === voice.seeks) {
             if (w > 0)
-                this.foldDelta(lane, slot, held.delta, w);
+                this.foldDelta(chans, slot, rec.delta, w);
             return;
         }
         const kept = reading.kept;
-        host.ready(voice, subject, held, elapsed, lane.pass, w);
+        host.ready(voice, subject, rec, elapsed, pass, w);
         host.horizon(voice, delay);
-        const delta = voice.patch.at(lane.phase, subject, voice.setting);
+        const delta = voice.patch.at(phase, subject, voice.setting);
         // What `influence` leaves on the record, so a probe on the general path this frame reuses it.
-        held.delta = delta;
-        held.probed = this.now;
-        held.seeks = voice.seeks;
+        rec.delta = delta;
+        rec.probed = this.now;
+        rec.seeks = voice.seeks;
         if (this.keeps)
-            host.after(voice, held);
+            host.after(voice, rec);
         if (reading.kept !== kept && !voice.keeping)
             host.kept(voice);
         if (w > 0)
-            this.foldDelta(lane, slot, delta, w);
+            this.foldDelta(chans, slot, delta, w);
+    }
+    /** Runs every crowd's rows whose voices come before voice `id`, from where each crowd reached. */
+    crowdsUpTo(id) {
+        for (const c of this.crowds)
+            if (!c.idle && c.cursor < c.size)
+                this.runCrowd(c, id);
+    }
+    /**
+     * A crowd's rows from its cursor up to voice `id`: what `runMotion` does for a lane's subjects,
+     * reading each row's voice and stretch from `hot`, and through `move` for whatever `hot` cannot
+     * answer, as `runMotion` does.
+     */
+    runCrowd(c, id) {
+        const data = c.data;
+        const hot = c.hot;
+        const H = c.stride;
+        const per = this.per;
+        const list = c.list;
+        const ch = c.chans[0];
+        const n = c.axes;
+        const fills = this.fills;
+        const from = this.frameProbes;
+        const probed = this.probes !== from;
+        const now = this.now;
+        const xs = c.xs;
+        const vs = c.vs;
+        const samples = c.samples;
+        let p = c.cursor;
+        for (; p < list.length; p++) {
+            const h = p * H;
+            if (hot[h + H_ID] >= id)
+                break;
+            let f = hot[h + H_FLAGS];
+            if ((f & F_VOICE) !== 0)
+                f = this.copyVoice(c, p);
+            if ((f & F_PLAYING) === 0 || (f & F_PLACED) === 0)
+                continue;
+            const slot = list[p];
+            const o = p * STRIDE;
+            const q = slot * SLOT;
+            if (per[q + LANE_FILL] === fills - 1)
+                data[o + PROBED] = data[o + WEIGHT];
+            const delay = data[o + DELAY];
+            const fast = (f & F_FAST) !== 0;
+            const voice = c.voices[p];
+            const elapsedNow = fast
+                ? hot[h + H_ELAPSED] +
+                    (now - hot[h + H_NOW]) * hot[h + H_RATE]
+                : voice.elapsedAt(now);
+            let elapsed = elapsedNow - delay;
+            if ((f & F_HOLDS) !== 0)
+                elapsed = held(voice, elapsed);
+            if (!(elapsed >= 0)) {
+                data[o + WEIGHT] = 0;
+                continue;
+            }
+            let w;
+            if (fast)
+                w = hot[h + H_WEIGHT];
+            else {
+                w = clampWeight(voice.weight * this.host.envelope(voice, data[o + SINCE]));
+                if (voice.parts !== null) {
+                    const subject = this.subjectAt(slot);
+                    if (subject !== absent)
+                        w *= this.host.parting(voice, subject);
+                }
+            }
+            data[o + WEIGHT] = w;
+            if ((f & F_MOTION) === 0) {
+                this.row(c, p, voice, slot, elapsed, delay, w);
+                continue;
+            }
+            if (data[o + MET] === 0) {
+                if (Number.isNaN(c.records[p].probed)) {
+                    this.late.push(slot);
+                    continue;
+                }
+                data[o + MET] = 1;
+            }
+            const ms = data[o + MSLOT];
+            if ((f & F_STALE) !== 0 && ms >= 0)
+                f = this.copyStretch(c, p, ms);
+            if (ms < 0 ||
+                (f & F_BARE) === 0 ||
+                (probed &&
+                    (per[q + LANE_PROBE] > from || per[q + GENERAL_PROBE] > from))) {
+                const run = c.motions[p];
+                this.move(c, run, p, slot, c.records[p], elapsed, delay, w);
+                // The first sample numbered the subject in the patch: copy its stretch from the next fill.
+                if (ms < 0)
+                    hot[h + H_FLAGS] = hot[h + H_FLAGS] | F_STALE;
+                continue;
+            }
+            closed(c.laws[p], c.eases[p], n, hot[h + H_AT], hot[h + H_MS], hot, h + H_X0, hot, h + H_X0 + n, hot, h + H_X0 + 2 * n, elapsed, xs, vs);
+            for (let a = 0; a < n; a++)
+                samples[p * n + a] = xs[a];
+            if (c.deltas[p] !== null)
+                c.deltas[p] = null;
+            data[o + SAMPLED] = fills;
+            data[o + SEEKS] = hot[h + H_SEEKS];
+            if (w <= 0)
+                continue;
+            if ((f & F_FOLDS) !== 0)
+                this.foldRun(ch, slot, xs, w);
+            else
+                this.foldInto(ch, slot, c.motions[p].value(ms, xs), w);
+        }
+        c.cursor = p;
+    }
+    /** A keys or fn row's contribution, as `one` makes a lane position's. */
+    row(c, p, voice, slot, elapsed, delay, w) {
+        const period = voice.patch.period;
+        const phase = phaseAt(elapsed, period, voice.passes);
+        if (voice.built !== null) {
+            if (w > 0) {
+                this.readKeyed(voice, phase, c.delta, c.scratch);
+                this.foldDelta(c.chans, slot, c.delta, w);
+            }
+            return;
+        }
+        const rec = c.records[p];
+        if (Number.isNaN(rec.probed)) {
+            this.late.push(slot);
+            return;
+        }
+        this.call(voice, c.chans, rec, slot, elapsed, phase, passAt(elapsed, period, voice.passes), delay, w);
+    }
+    /** Copies what a fill reads of a crowd row's voice into `hot`; returns the row's flags. */
+    copyVoice(c, p) {
+        const v = c.voices[p];
+        const h = p * c.stride;
+        let f = c.hot[h + H_FLAGS] & ~(F_VOICE | F_PLAYING | F_FAST | F_HOLDS);
+        if (v.state === 'live' || v.state === 'held' || v.state === 'fading')
+            f |= F_PLAYING;
+        if (v.holdsBefore || v.holdsAfter)
+            f |= F_HOLDS;
+        if (v.ramp === null &&
+            !((v.fade.in ?? 0) > 0) &&
+            v.out === null &&
+            v.parts === null &&
+            !v.keeping)
+            f |= F_FAST;
+        c.hot[h + H_NOW] = v.anchorNow;
+        c.hot[h + H_ELAPSED] = v.anchorElapsed;
+        c.hot[h + H_RATE] = v.rate;
+        c.hot[h + H_WEIGHT] = clampWeight(v.weight);
+        c.hot[h + H_SEEKS] = v.seeks;
+        c.hot[h + H_FLAGS] = f;
+        return f;
+    }
+    /** Copies a crowd row's current stretch from its patch into `hot`; returns the row's flags. */
+    copyStretch(c, p, ms) {
+        const run = c.motions[p];
+        const h = p * c.stride;
+        let f = c.hot[h + H_FLAGS] & ~(F_STALE | F_BARE | F_FOLDS);
+        const ch = c.chans[0];
+        if (run.n === c.axes && run.stretchInto(ms, c.hot, h + H_AT)) {
+            f |= F_BARE;
+            if (run.scalar(ms) === ch.scalar)
+                f |= F_FOLDS;
+        }
+        c.hot[h + H_FLAGS] = f;
+        return f;
+    }
+    /**
+     * A motion voice's fill: what `one` and `move` do for each subject, in one loop for the common
+     * case, a subject not yet probed this frame with nothing pending, and through `move` for the rest.
+     */
+    runMotion(lane, run) {
+        const voice = lane.voice;
+        const data = lane.data;
+        const per = this.per;
+        const list = lane.list;
+        const records = lane.records;
+        const ch = lane.chans[0];
+        const fills = this.fills;
+        const from = this.frameProbes;
+        const seeks = voice.seeks;
+        const elapsedNow = voice.elapsedAt(this.now);
+        const flat = lane.flat;
+        const parts = voice.parts !== null;
+        // On a frame's first fill no probe has read a subject yet, so none needs `move` for that.
+        const probed = this.probes !== from;
+        const whole = clampWeight(voice.weight);
+        const n = run.n;
+        if (n > 0) {
+            if (lane.axes !== n) {
+                lane.axes = n;
+                lane.samples = new Float64Array(0);
+            }
+            if (list.length * n > lane.samples.length) {
+                const grown = new Float64Array(Math.max(list.length, (lane.samples.length / n) * 2, 4) * n);
+                grown.set(lane.samples);
+                lane.samples = grown;
+            }
+        }
+        const samples = lane.samples;
+        const xs = run.xs;
+        for (let p = 0; p < list.length; p++) {
+            const slot = list[p];
+            const o = p * STRIDE;
+            const q = slot * SLOT;
+            if (per[q + LANE_FILL] === fills - 1)
+                data[o + PROBED] = data[o + WEIGHT];
+            const delay = data[o + DELAY];
+            const elapsed = elapsedNow - delay;
+            if (elapsed < 0) {
+                data[o + WEIGHT] = 0;
+                continue;
+            }
+            if (!flat) {
+                const since = data[o + SINCE];
+                if (!lane.weighed || !Object.is(since, lane.weighedSince)) {
+                    lane.fade = this.host.envelope(voice, since);
+                    lane.weighed = true;
+                    lane.weighedSince = since;
+                }
+            }
+            let w = flat ? whole : clampWeight(voice.weight * lane.fade);
+            if (parts) {
+                const subject = this.subjectAt(slot);
+                if (subject !== absent)
+                    w *= this.host.parting(voice, subject);
+            }
+            data[o + WEIGHT] = w;
+            if (data[o + MET] === 0) {
+                if (Number.isNaN(records[p].probed)) {
+                    this.late.push(slot);
+                    continue;
+                }
+                data[o + MET] = 1;
+            }
+            const ms = data[o + MSLOT];
+            if (ms < 0 ||
+                (probed &&
+                    (per[q + LANE_PROBE] > from || per[q + GENERAL_PROBE] > from)) ||
+                !run.sampleBare(ms, elapsed, xs, run.vs)) {
+                this.move(lane, run, p, slot, records[p], elapsed, delay, w);
+                continue;
+            }
+            for (let a = 0; a < n; a++)
+                samples[p * n + a] = xs[a];
+            if (lane.deltas[p] !== null)
+                lane.deltas[p] = null;
+            data[o + SAMPLED] = fills;
+            data[o + SEEKS] = seeks;
+            if (w <= 0)
+                continue;
+            if (n === ch.axes && run.scalar(ms) === ch.scalar)
+                this.foldRun(ch, slot, xs, w);
+            else
+                this.foldInto(ch, slot, run.value(ms, xs), w);
+        }
     }
     /**
      * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
@@ -790,8 +1722,8 @@ export class Lanes {
      * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
      * this frame already read keeps the value it read, as the general path's record would.
      */
-    move(lane, run, p, slot, subject, held, elapsed, delay, w) {
-        const voice = lane.voice;
+    move(lane, run, p, slot, held, elapsed, delay, w) {
+        const voice = lane.voiceAt(p);
         const data = lane.data;
         const o = p * STRIDE;
         const ch = lane.chans[0];
@@ -803,6 +1735,9 @@ export class Lanes {
             !this.probedThisFrame(slot)) {
             let ms = data[o + MSLOT];
             if (ms < 0) {
+                const subject = this.subjectAt(slot);
+                if (subject === absent)
+                    return;
                 ms = run.slot(subject);
                 data[o + MSLOT] = ms;
             }
@@ -814,24 +1749,14 @@ export class Lanes {
             run.sample(ms, elapsed, run.xs, run.vs);
             // Kept as numbers, not a delta: one is built only if a probe this frame asks for it.
             const n = run.n;
-            if (lane.axes !== n) {
-                lane.axes = n;
-                lane.samples = new Float64Array(0);
-            }
-            if ((p + 1) * n > lane.samples.length) {
-                const grown = new Float64Array(Math.max(p + 1, (lane.samples.length / n) * 2, 4) * n);
-                grown.set(lane.samples);
-                lane.samples = grown;
-            }
-            for (let a = 0; a < n; a++)
-                lane.samples[p * n + a] = run.xs[a];
+            lane.keep(p, run.xs, n);
             lane.deltas[p] = null;
             data[o + SAMPLED] = this.fills;
             data[o + SEEKS] = voice.seeks;
             if (w <= 0)
                 return;
             // A sample of other axes than the channel's folds as the general path folds it.
-            if (n === ch.axes && run.scalar(ms) === (ch.axes === 1))
+            if (n === ch.axes && run.scalar(ms) === ch.scalar)
                 this.foldRun(ch, slot, run.xs, w);
             else
                 this.foldInto(ch, slot, run.value(ms, run.xs), w);
@@ -845,10 +1770,8 @@ export class Lanes {
     }
     /** The delta a motion voice's last sample for position `p` made, built from `samples`. */
     sampled(lane, p) {
-        const run = lane.motion;
-        const n = lane.axes;
-        for (let a = 0; a < n; a++)
-            run.xs[a] = lane.samples[p * n + a];
+        const run = lane.motionAt(p);
+        lane.kept(p, run.xs);
         const ms = lane.data[p * STRIDE + MSLOT];
         const delta = { [lane.chans[0].name]: run.value(ms, run.xs) };
         lane.deltas[p] = delta;
@@ -885,8 +1808,7 @@ export class Lanes {
      * 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.
      */
-    foldDelta(lane, slot, delta, w) {
-        const chans = lane.chans;
+    foldDelta(chans, slot, delta, w) {
         const n = chans.length;
         let ch = chans[0];
         if (n > 0)
@@ -913,7 +1835,7 @@ export class Lanes {
         if (value === undefined)
             return;
         const values = ch.values;
-        if (ch.axes === 1) {
+        if (ch.scalar) {
             values[slot] = foldNumber(ch.op, values[slot], value, w);
             return;
         }