@msb235/blits 0.3.0 → 0.5.0

package/dist/lanes.js

@@ -1,218 +1,41 @@
-import { foldNumber, numericOf } from './channels.js';
-import { clampWeight, passAt, phaseAt } from './clock.js';
-import { motionOf } from './motion.js';
-import { absent, Numbers } from './numbers.js';
-import { readKeys } from './patch.js';
+import { row } from './crowd.js';
+import { call, fillAll, foldKeys, one, parting, readKeyed, reset, run, signalled, subjectAt, } from './fill.js';
+import { fold, foldDelta, foldInto, foldRun, gather } from './gather.js';
+import { meet, owable, reach } from './meet.js';
+import { Numbers } from './numbers.js';
+import { Owed } from './owed.js';
+import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
-/**
- * Which channels run as lanes and which voices run on them: the fixed point where every voice
- * writing a laned channel fits and writes only laned channels. Only channels some laned voice
- * writes are laned.
- */
-export function qualify(numeric, voices) {
-    const open = numeric.slice();
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const v of voices) {
-            if (v.fits && v.slots.every((s) => open[s]))
-                continue;
-            for (const s of v.slots)
-                if (open[s]) {
-                    open[s] = false;
-                    changed = true;
-                }
-        }
-    }
-    const laned = new Set();
-    const channels = numeric.map(() => false);
-    for (const v of voices) {
-        if (!v.fits || !v.slots.every((s) => open[s]))
-            continue;
-        laned.add(v.id);
-        for (const s of v.slots)
-            channels[s] = true;
-    }
-    return { channels, voices: laned };
-}
-export function clampRun(out, at, n, [lo, hi]) {
-    for (let i = at; i < at + n; i++) {
-        const x = out[i];
-        out[i] = x < lo ? lo : x > hi ? hi : x;
-    }
-}
-const STRIDE = 7;
-const DELAY = 0;
-const SINCE = 1;
-/** The weight the last fill gave the subject. */
-const WEIGHT = 2;
-/** The weight a fill gave it the last time a probe read it from the lane. */
-const PROBED = 3;
-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;
-const SLOT = 6;
-const FILLED = 0;
-const SEEN = 1;
-const IDLE = 2;
-const LANE_PROBE = 3;
-const GENERAL_PROBE = 4;
-const LANE_FILL = 5;
-/**
- * Below what share of its subjects probed last frame a lane stops filling, and above what share it
- * fills again; between the two it keeps doing what it did, so a host near the line does not flip
- * every frame. Measured at 10k and 1k subjects (2026-10-02, one local machine): filling breaks even
- * with probing through the general path at about 19% probed for keys at both sizes, 71-77% for a
- * spring, and 63% (1k) to about 100% (10k) for a stateless fn.
- */
-const SPARSE = { keys: { stop: 0.15, start: 0.25 }, other: { stop: 0.6, start: 0.8 } };
-/** The least prime at least `n`, and 1 below 2. */
-function primeFrom(n) {
-    if (n < 2)
-        return 1;
-    for (let c = n;; c++) {
-        let prime = true;
-        for (let d = 2; d * d <= c; d++)
-            if (c % d === 0) {
-                prime = false;
-                break;
-            }
-        if (prime)
-            return c;
-    }
-}
-/**
- * What one laned voice keeps per subject it reaches, by position in `list`. A subject gets a
- * position when a probe of it first finds the voice playing, which is when the general path first
- * sees it too.
- */
-class Lane {
-    voice;
-    /** The subject number at each position. */
-    list = [];
-    at = new Map();
-    /** Whether too few of its subjects were probed lately to fill it: theirs take the general path. */
-    idle = false;
-    /** The lines it goes idle and busy at, by its patch form. */
-    line;
-    /**
-     * A `fn` or `keys` voice naming one subject, which shares nothing across subjects for a fill to
-     * save, so it stays idle: its subject takes the general path, and the channel stays a lane for
-     * the voices that do share.
-     */
-    solo;
-    /**
-     * When the voice started playing on its lane, in the order lanes did; 0 while it waits. A subject
-     * checked against every lane up to some epoch has met this one if this one's is no later.
-     */
-    epoch = 0;
-    /**
-     * Per position, `STRIDE` numbers side by side, so one subject's are one read from memory: its
-     * delay, its `since`, its weight at the last fill, its weight at the last fill a probe read, a
-     * motion patch's own number for it (-1 until asked), and the fill and seeks of its last sample.
-     */
-    data = new Float64Array(0);
-    records = [];
-    /**
-     * For a motion voice, per position, the delta its last sample made; null where that sample was
-     * kept only in `samples`, until a probe asks for it.
-     */
-    deltas = [];
-    /** For a motion voice, per position, its last sample's value on each of `axes` axes. */
-    samples = new Float64Array(0);
-    axes = 0;
-    /** What a keys read writes into, reused across subjects. */
-    delta = {};
-    /** The arrays keyed reads interpolate into: the lane's own, so a probe mid-fill cannot move them. */
-    scratch = [];
-    /** The laned channel of each channel the voice writes, in `writes` order. */
-    chans = [];
-    /** The value read for each of `chans`, for the subject being folded. */
-    values = [];
-    /**
-     * Within one fill, the last elapsed placed and the last `since` weighed, with what they gave, so
-     * subjects sharing a delay or a start share the arithmetic: the same inputs give the same bits.
-     */
-    placed = false;
-    placedAt = 0;
-    phase = 0;
-    pass = 0;
-    read = false;
-    readAt = 0;
-    weighed = false;
-    weighedSince = 0;
-    fade = 1;
-    /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
-    flat = false;
-    /** A motion patch's state, which the lane samples in place of calling the patch. */
-    motion;
-    constructor(voice) {
-        this.voice = voice;
-        this.motion = motionOf(voice.patch);
-        this.line = voice.built !== null ? SPARSE.keys : SPARSE.other;
-        this.solo = voice.named !== null && voice.named.size === 1 && this.motion === undefined;
-        this.idle = this.solo;
-    }
-    positionOf(slot) {
-        return this.at.get(slot) ?? -1;
-    }
-    /** Gives a subject the voice reaches a position, from what its record fixed on first sight. */
-    add(slot, held) {
-        const p = this.list.length;
-        this.list.push(slot);
-        this.at.set(slot, p);
-        if ((p + 1) * STRIDE > this.data.length) {
-            const data = new Float64Array(Math.max(p + 1, (this.data.length / STRIDE) * 2, 4) * STRIDE);
-            data.set(this.data);
-            this.data = data;
-        }
-        const o = p * STRIDE;
-        this.data[o + DELAY] = held.delay;
-        this.data[o + SINCE] = held.since;
-        this.data[o + WEIGHT] = 0;
-        this.data[o + PROBED] = 0;
-        this.data[o + MSLOT] = -1;
-        this.data[o + SAMPLED] = -1;
-        this.records[p] = held;
-        this.deltas[p] = null;
-    }
-    /** A subject lost its number: the last position moves into its place. */
-    remove(slot) {
-        const p = this.at.get(slot);
-        if (p === undefined)
-            return;
-        const last = this.list.length - 1;
-        if (p !== last) {
-            const moved = this.list[last];
-            this.list[p] = moved;
-            this.at.set(moved, p);
-            this.data.copyWithin(p * STRIDE, last * STRIDE, (last + 1) * STRIDE);
-            this.records[p] = this.records[last];
-            this.deltas[p] = this.deltas[last] ?? null;
-            const n = this.axes;
-            if (n > 0)
-                this.samples.copyWithin(p * n, last * n, (last + 1) * n);
-        }
-        this.list.pop();
-        this.at.delete(slot);
-        this.records[last] = undefined;
-        this.deltas[last] = null;
-    }
-}
+import { reportedRow, unplace } from './rows.js';
 /**
  * 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.
  */
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
 export class Lanes {
     host;
     numbers;
     lanes = [];
-    /** The lanes a fill visits: every lane but the solo ones. */
-    runs = [];
     /** 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();
+    /** Whether two crowds share a channel, so their rows must interleave in voice order. */
+    overlap = false;
+    /** The loci whose voices are on lanes, every member of each on one. */
+    loci = [];
+    /** While a fill gathers a locus: that locus and the member gathering, where folds go instead. */
+    into = null;
+    intoId = 0;
+    lawsByKey = new Map();
+    lastLaw = null;
+    /** The lanes the last `meet` gave a position, and whether it placed a crowd row. */
+    met = [];
+    metCrowd = false;
+    /** By subject number, the laned voices its probes fold on the general path this fill. */
+    owed = new Owed();
     laned = [];
     /** By kit slot, the laned channel there. */
     bySlot = [];
@@ -222,6 +45,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 +77,15 @@ export class Lanes {
      * the general path has to make.
      */
     late = [];
+    /**
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
+     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     */
+    queueSlots = new Int32Array(0);
+    queueRows = new Int32Array(0);
+    queueCounts = new Int32Array(0);
+    queued = 0;
+    queuedFor = null;
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
@@ -270,7 +108,7 @@ export class Lanes {
     qualifiedVersion = Number.NaN;
     constructor(host) {
         this.host = host;
-        this.numbers = new Numbers((slot) => this.forget(slot));
+        this.numbers = new Numbers(this);
     }
     /** A change that may move a voice on or off its lane: qualify again, then fill again. */
     invalidate() {
@@ -281,17 +119,25 @@ 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 + IDLE] = 0;
-        this.per[slot * SLOT + LANE_PROBE] = 0;
-        this.per[slot * SLOT + GENERAL_PROBE] = 0;
-        this.per[slot * SLOT + LANE_FILL] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = -1;
+        this.per[slot * 6 /* Per.SLOT */ + 2 /* Per.IDLE */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 3 /* Per.LANE_PROBE */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 4 /* Per.GENERAL_PROBE */] = 0;
+        this.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] = 0;
         if (this.filling)
             this.late.push(slot);
         return slot;
@@ -299,32 +145,104 @@ 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)
+                reach(this, 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)
+            unplace(this, c, p);
+    }
+    /** 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 * 6 /* Per.SLOT */ + 1 /* Per.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 : reportedRow(this, c, p, slot);
     }
     reported(lane, slot) {
-        const o = slot * SLOT;
-        if (!(this.per[o + LANE_PROBE] > this.per[o + GENERAL_PROBE]))
+        const o = slot * 6 /* Per.SLOT */;
+        if (!(this.per[o + 3 /* Per.LANE_PROBE */] > this.per[o + 4 /* Per.GENERAL_PROBE */]))
             return undefined;
         const p = lane.positionOf(slot);
         if (p < 0)
             return undefined;
-        return lane.data[p * STRIDE + (this.per[o + LANE_FILL] === this.fills ? WEIGHT : PROBED)];
+        return lane.data[p * 8 /* Row.STRIDE */ + (this.per[o + 5 /* Per.LANE_FILL */] === this.fills ? 2 /* Row.WEIGHT */ : 3 /* Row.PROBED */)];
     }
     /**
      * Fills the lanes once a frame, and says whether this probe of a subject reads its values from
      * them. One that a lane has not met yet, newly numbered or newly reached, takes the general path
      * this frame, which is where it is first seen; so does one probed from inside a fill.
      */
-    prepare(slot, subject, now, version) {
+    prepare(slot, subject, now, version, head) {
+        const ready = this.filled(now, version) ? 1 /* Begin.READY */ : this.begin(now, version);
+        if (ready === 0 /* Begin.GENERAL */)
+            return this.general(slot);
+        if (slot < 0)
+            return false;
+        if (!this.probedThisFrame(slot))
+            this.distinct++;
+        const probe = ++this.probes;
+        const per = this.per;
+        const o = slot * 6 /* Per.SLOT */;
+        let lane = per[o + 0 /* Per.FILLED */] === this.fills && per[o + 2 /* Per.IDLE */] === 0;
+        if (per[o + 1 /* Per.SEEN */] < this.wide && meet(this, slot, subject, head)) {
+            // The fill ran before the subject had these positions. Where every voice it just met folds
+            // after every other laned voice, the general path folds just those onto the lanes' values;
+            // otherwise it reads the general path all frame.
+            if (lane && per[o + 2 /* Per.IDLE */] === 0 && owable(this, slot))
+                this.owed.owe(slot, this.met);
+            else {
+                per[o + 0 /* Per.FILLED */] = 0;
+                lane = false;
+            }
+        }
+        if (lane) {
+            per[o + 3 /* Per.LANE_PROBE */] = probe;
+            per[o + 5 /* Per.LANE_FILL */] = this.fills;
+            this.subjects[slot] = subject;
+            this.holding = true;
+        }
+        else
+            per[o + 4 /* Per.GENERAL_PROBE */] = probe;
+        return lane;
+    }
+    /** 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 or the lanes are filled.
+     */
+    begin(now, version) {
         if (now !== this.frameAt) {
             this.lastFrom = this.frameProbes;
             this.lastTo = this.probes;
@@ -335,87 +253,79 @@ export class Lanes {
             this.fresh = true;
         }
         if (this.filling)
-            return this.general(slot);
-        if (this.qualifiedVersion !== version)
-            this.requalify(version);
-        if (this.laned.length === 0)
-            return this.general(slot);
-        // 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);
+            return 0 /* Begin.GENERAL */;
+        // The mix's version moves only when a voice over every subject comes, goes, starts or stops
+        // waiting, each of which touches it, so a version past a qualify that stands is a set of touches.
+        if (this.qualifiedVersion !== version) {
+            if (!Number.isNaN(this.qualifiedVersion) && this.touched.length > 0 && retouch(this))
+                this.qualifiedVersion = version;
+            else
+                requalify(this, version);
         }
-        if (slot >= 0 && !this.probedThisFrame(slot))
-            this.distinct++;
+        else if (this.touched.length > 0 && !retouch(this))
+            requalify(this, version);
+        if (this.laned.length === 0)
+            return 0 /* Begin.GENERAL */;
         if (this.filledAt !== now || this.filledVersion !== version || this.moved !== reading.moved) {
-            this.fillAll(now, version);
+            fillAll(this, 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);
+                requalify(this, version);
                 if (this.laned.length === 0)
-                    return this.general(slot);
-                this.fillAll(now, version);
+                    return 0 /* Begin.GENERAL */;
+                fillAll(this, 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 1 /* Begin.READY */;
     }
     general(slot) {
         if (slot >= 0)
-            this.per[slot * SLOT + GENERAL_PROBE] = ++this.probes;
+            this.per[slot * 6 /* Per.SLOT */ + 4 /* Per.GENERAL_PROBE */] = ++this.probes;
         return false;
     }
     /** Whether a probe has read the subject since the frame began, on either path. */
     probedThisFrame(slot) {
         const from = this.frameProbes;
-        const o = slot * SLOT;
-        return (this.per[o + LANE_PROBE] > from || this.per[o + GENERAL_PROBE] > from);
+        const o = slot * 6 /* Per.SLOT */;
+        return (this.per[o + 3 /* Per.LANE_PROBE */] > from ||
+            this.per[o + 4 /* Per.GENERAL_PROBE */] > from);
+    }
+    /** Whether the subject at `slot` reads some laned voice from the general path this fill. */
+    owes(slot) {
+        return this.owed.owes(slot);
+    }
+    /** Whether the subject at `slot` reads laned voice `id` from the general path this fill. */
+    owesVoice(slot, id) {
+        return this.owed.owesVoice(slot, id);
+    }
+    /** The weight the general path gave a voice the subject at `slot` owes, as `weightOf` reports. */
+    paid(id, slot, w) {
+        const lane = this.byId.get(id);
+        const p = lane === undefined ? -1 : lane.positionOf(slot);
+        if (p >= 0)
+            lane.data[p * 8 /* Row.STRIDE */ + 2 /* Row.WEIGHT */] = w;
     }
     /**
-     * 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.
+     * Whether a subject's laned values are at their channels' rest, as `atRest` reads the pose `copy`
+     * would write: each number within 1e-9 of its rest.
      */
-    write(slot, columns, n) {
-        const bySlot = this.bySlot;
-        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];
-            if (ch === undefined) {
-                for (let a = 0; a < axes; a++)
-                    out[at + a] = c.rest[a];
+    rests(slot) {
+        for (const ch of this.laned) {
+            const values = ch.values;
+            if (ch.scalar) {
+                if (!(Math.abs(values[slot] - ch.rest) < 1e-9))
+                    return false;
                 continue;
             }
-            const values = ch.values;
-            const base = slot * axes;
-            for (let a = 0; a < axes; a++)
-                out[at + a] = values[base + a];
-            if (c.bounds !== undefined)
-                clampRun(out, at, axes, c.bounds);
+            // `copy` lengthens a rest shorter than the channel's axes, and a longer array is never near it.
+            if (ch.start.length < ch.axes)
+                return false;
+            const base = slot * ch.axes;
+            for (let a = 0; a < ch.axes; a++)
+                if (!(Math.abs(values[base + a] - ch.start[a]) < 1e-9))
+                    return false;
         }
+        return true;
     }
     /** Writes a subject's laned values into a pose, each array channel into a new array. */
     copy(slot, pose) {
@@ -423,7 +333,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;
             }
@@ -435,60 +345,27 @@ export class Lanes {
             pose[ch.name] = arr;
         }
     }
-    /**
-     * Gives a probed subject a position on every lane that started playing since the subject was last
-     * 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];
-        this.per[slot * SLOT + SEEN] = this.epochs;
-        let met = false;
-        const dense = this.dense;
-        for (let i = dense.length - 1; i >= 0; i--) {
-            const lane = dense[i];
-            if (lane.epoch <= from)
-                break;
-            const held = this.host.meet(lane.voice, subject);
-            if (!held.reaches)
-                continue;
-            lane.add(slot, held);
-            if (lane.idle)
-                this.reach(slot, 1);
-            met = true;
-        }
-        const naming = this.host.naming(subject);
-        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)
-                    continue;
-                lane.add(slot, this.host.meet(voice, subject));
-                if (lane.idle)
-                    this.reach(slot, 1);
-                met = true;
-            }
-        return met;
-    }
-    /** Counts an idle lane more or fewer reaching a subject. */
-    reach(slot, by) {
-        const i = slot * SLOT + IDLE;
-        this.per[i] = this.per[i] + by;
-    }
     forget(slot) {
+        this.host.forgot(slot);
         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)
+                    unplace(this, c, p);
         if (slot < this.cap)
-            this.per[slot * SLOT + FILLED] = 0;
+            this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = 0;
         this.subjects[slot] = undefined;
     }
     grow(size) {
         if (size <= this.cap)
             return;
         const cap = Math.max(size, this.cap * 2, 64);
-        const per = new Float64Array(cap * SLOT);
+        const per = new Float64Array(cap * 6 /* Per.SLOT */);
         per.set(this.per);
         this.per = per;
+        this.owed.grow(cap);
         for (const ch of this.laned) {
             const values = new Float64Array(cap * ch.axes);
             values.set(ch.values);
@@ -496,433 +373,50 @@ export class Lanes {
         }
         this.cap = cap;
     }
-    requalify(version) {
-        const host = this.host;
-        this.qualifiedVersion = version;
-        this.filledVersion = Number.NaN;
-        const present = host.voices.filter((v) => v.state !== 'done');
-        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.
-        present.map((v) => ({ id: v.id, fits: v.slots.length > 0 && host.fits(v), slots: v.slots })));
-        for (const lane of this.lanes)
-            if (!voices.has(lane.voice.id))
-                this.leave(lane);
-        const kept = [];
-        for (const v of present) {
-            if (!voices.has(v.id))
-                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;
-            kept.push(lane);
-        }
-        this.lanes = kept;
-        this.runs = kept.filter((l) => !l.solo);
-        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.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)
-            this.subjects = [];
-        this.laned = [];
-        this.bySlot = host.channels.map(() => undefined);
-        channels.forEach((on, slot) => {
-            if (!on)
-                return;
-            const channel = host.channels[slot];
-            const n = numericOf(channel);
-            const rest = channel.rest;
-            const ch = {
-                name: host.names[slot],
-                op: n.op,
-                rest: typeof rest === 'number' ? rest : rest[0],
-                axes: n.axes,
-                values: new Float64Array(this.cap * n.axes),
-                start: typeof rest === 'number' ? [] : rest,
-            };
-            this.laned.push(ch);
-            this.bySlot[slot] = ch;
-        });
-        this.copies.length = 0;
-        for (const ch of this.bySlot)
-            this.copies.push(ch !== undefined);
-        for (const lane of kept) {
-            lane.chans = lane.voice.slots.map((s) => this.bySlot[s]);
-            lane.values = lane.chans.map(() => undefined);
-        }
-    }
-    /** Hands a voice back to the general path, with the weights `weightOf` reports kept on its records. */
-    leave(lane) {
-        if (lane.idle)
-            this.wake(lane);
-        for (let p = 0; p < lane.list.length; p++) {
-            const rec = lane.records[p];
-            const slot = lane.list[p];
-            const w = this.reported(lane, slot);
-            if (rec !== undefined && w !== undefined)
-                rec.weight = w;
-            if (rec !== undefined && lane.motion !== undefined)
-                this.settle(lane, p, slot, rec);
-        }
-        lane.voice.laned = false;
-    }
-    fillAll(now, version) {
-        const host = this.host;
-        this.filling = true;
-        try {
-            this.fills++;
-            this.now = now;
-            this.filledAt = now;
-            this.filledVersion = version;
-            const size = this.numbers.size;
-            this.keeps = host.keeps;
-            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.
-            let busy = false;
-            for (const lane of this.runs) {
-                if (decide) {
-                    // A lane with few subjects, such as one naming its own, goes by the share of all probed;
-                    // one with a single subject shares nothing a fill could save, as a solo lane does not.
-                    const line = lane.line;
-                    const n = lane.list.length;
-                    if (n >= 64)
-                        this.pace(lane);
-                    else if (n === 1 && lane.motion === undefined) {
-                        if (!lane.idle)
-                            this.rest(lane);
-                    }
-                    else if (lane.idle ? share >= line.start : share < line.stop)
-                        this.flip(lane);
-                }
-                if (lane.idle)
-                    continue;
-                if (!busy) {
-                    busy = true;
-                    for (const ch of this.laned)
-                        ch.values.fill(ch.rest, 0, size * ch.axes);
-                }
-                this.run(lane);
-            }
-            // With every lane idle there was nothing to fill, and no subject reads a lane this frame.
-            if (busy)
-                for (let s = 0; s < size; s++)
-                    this.per[s * SLOT + FILLED] = this.fills;
-            for (const slot of this.late)
-                this.per[slot * SLOT + FILLED] = 0;
-            if (this.holding) {
-                this.subjects.fill(undefined, 0, size);
-                this.holding = false;
-            }
-            this.moved = reading.moved;
-        }
-        finally {
-            this.filling = false;
-            this.late.length = 0;
-        }
-    }
     /**
-     * Sets a lane idle or busy by the share of its subjects probed in the last frame that had a probe,
-     * read from about 256 of them a prime stride apart, from an offset that moves each frame, so a host
-     * probing every second or third subject is not read as probing all or none. Both paths give the
-     * same values, so this only picks the cheaper.
+     * A laned voice's patch is about to change subject `s`'s stretch: a crowd copies it again at the
+     * next fill, and a lane keeps the sample the old one gave.
      */
-    pace(lane) {
-        const list = lane.list;
-        const line = lane.line;
-        const from = this.lastFrom;
-        const to = this.lastTo;
-        const step = primeFrom(Math.floor(list.length / 256));
-        let looked = 0;
-        let probed = 0;
-        for (let p = this.fills % step; p < list.length; p += step) {
-            const slot = list[p];
-            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;
-        if (lane.idle ? share >= line.start : share < line.stop)
-            this.flip(lane);
-    }
-    flip(lane) {
-        if (lane.idle)
-            this.wake(lane);
-        else
-            this.rest(lane);
-    }
-    /** Leaves a lane's subjects to the general path until it wakes, keeping what `weightOf` reports. */
-    rest(lane) {
-        lane.idle = true;
-        const list = lane.list;
-        const data = lane.data;
-        for (let p = 0; p < list.length; p++) {
-            const slot = list[p];
-            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) {
-                const o = p * STRIDE;
-                data[o + PROBED] = data[o + WEIGHT];
-            }
-        }
-    }
-    wake(lane) {
-        lane.idle = false;
-        for (const slot of lane.list)
-            this.reach(slot, -1);
-    }
-    subjectAt(slot) {
-        let subject = this.subjects[slot];
-        if (subject === undefined) {
-            subject = this.numbers.subject(slot);
-            this.subjects[slot] = subject;
-            this.holding = true;
-        }
-        return subject;
-    }
-    /** One voice's contribution to every subject it plays on. */
-    run(lane) {
-        const voice = lane.voice;
-        if (voice.state !== 'live' && voice.state !== 'fading')
+    stretchChanged(id, s) {
+        const c = this.crowdOf.get(id);
+        const p = c?.rowOf.get(id);
+        if (c !== undefined && p !== undefined) {
+            c.restale(p, c.hot[p * c.stride + 0 /* Hot.FLAGS */]);
             return;
-        lane.placed = false;
-        lane.read = false;
-        lane.weighed = false;
-        // 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;
-        const elapsed = voice.elapsedAt(this.now);
-        const period = voice.patch.period;
-        const passes = voice.passes;
-        const list = lane.list;
-        for (let p = 0; p < list.length; p++) {
-            this.one(lane, p, list[p], elapsed, period, passes);
-            // Its patch just made kept state: no further call this fill, the general path makes them.
-            if (voice.keeping)
-                return;
         }
-    }
-    one(lane, p, slot, elapsedNow, period, passes) {
-        const host = this.host;
-        const voice = lane.voice;
-        const data = lane.data;
-        const o = p * STRIDE;
-        // A probe read this subject from the last fill: keep the weight it read for `weightOf`.
-        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) {
-            data[o + WEIGHT] = 0;
-            return;
-        }
-        if (!lane.placed || !Object.is(elapsed, lane.placedAt)) {
-            lane.placed = true;
-            lane.placedAt = elapsed;
-            lane.phase = phaseAt(elapsed, period, passes);
-            lane.pass = passAt(elapsed, period, passes);
-        }
-        const since = data[o + SINCE];
-        if (!lane.flat && (!lane.weighed || !Object.is(since, lane.weighedSince))) {
-            lane.fade = host.envelope(voice, since);
-            lane.weighed = true;
-            lane.weighedSince = since;
-        }
-        const w = clampWeight(voice.weight * lane.fade);
-        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);
-                lane.read = true;
-                lane.readAt = elapsed;
-                this.gather(lane, lane.delta);
-            }
-            if (w > 0)
-                this.fold(lane, slot, w);
-            return;
-        }
-        const subject = this.subjectAt(slot);
-        if (subject === absent)
-            return;
-        const held = 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)) {
-            this.late.push(slot);
-            return;
-        }
-        if (lane.motion !== undefined) {
-            this.move(lane, lane.motion, p, slot, subject, held, elapsed, delay, w);
-            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 (w > 0)
-                this.foldDelta(lane, slot, held.delta, w);
-            return;
-        }
-        const kept = reading.kept;
-        host.ready(voice, subject, held, elapsed, lane.pass, w);
-        host.horizon(voice, delay);
-        const delta = voice.patch.at(lane.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;
-        if (this.keeps)
-            host.after(voice, held);
-        if (reading.kept !== kept && !voice.keeping)
-            host.kept(voice);
-        if (w > 0)
-            this.foldDelta(lane, slot, delta, w);
-    }
-    /**
-     * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
-     * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
-     * 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;
-        const data = lane.data;
-        const o = p * STRIDE;
-        const ch = lane.chans[0];
-        this.settle(lane, p, slot, held);
-        const delta = held.delta;
-        if (delta === null ||
-            held.probed !== this.now ||
-            held.seeks !== voice.seeks ||
-            !this.probedThisFrame(slot)) {
-            let ms = data[o + MSLOT];
-            if (ms < 0) {
-                ms = run.slot(subject);
-                data[o + MSLOT] = ms;
-            }
-            this.host.horizon(voice, delay);
-            if (!run.quiet(ms, elapsed)) {
-                this.late.push(slot);
-                return;
-            }
-            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.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))
-                this.foldRun(ch, slot, run.xs, w);
-            else
-                this.foldInto(ch, slot, run.value(ms, run.xs), w);
-            return;
-        }
-        lane.deltas[p] = delta;
-        data[o + SAMPLED] = this.fills;
-        data[o + SEEKS] = voice.seeks;
-        if (w > 0)
-            this.foldInto(ch, slot, delta[ch.name], w);
-    }
-    /** 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 ms = lane.data[p * STRIDE + MSLOT];
-        const delta = { [lane.chans[0].name]: run.value(ms, run.xs) };
-        lane.deltas[p] = delta;
-        return delta;
-    }
-    /**
-     * A probe this frame read a motion voice's value for the subject from an earlier fill: write onto
-     * its record what the general path's sample would have, so a later read this frame reuses it.
-     */
-    settle(lane, p, slot, held) {
-        const o = p * STRIDE;
-        if ((held.probed === this.now && held.seeks === lane.data[o + SEEKS]) ||
-            !(this.per[slot * SLOT + LANE_PROBE] > this.frameProbes) ||
-            lane.data[o + SAMPLED] !== this.per[slot * SLOT + LANE_FILL])
-            return;
-        held.delta = lane.deltas[p] ?? this.sampled(lane, p);
-        held.probed = this.now;
-        held.seeks = lane.data[o + SEEKS];
-    }
-    /** For a keys voice: the delta's value for each channel it writes, read once per phase. */
-    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. */
-    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.
-     */
-    foldDelta(lane, slot, delta, w) {
-        const chans = lane.chans;
-        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. */
-    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);
-    }
-    foldInto(ch, slot, value, w) {
-        if (value === undefined)
-            return;
-        const values = ch.values;
-        if (ch.axes === 1) {
-            values[slot] = foldNumber(ch.op, values[slot], value, w);
+        const lane = this.byId.get(id);
+        const q = lane === undefined ? -1 : lane.positionOfMotion(s);
+        if (q >= 0)
+            lane.fix(q);
+    }
+    /** 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 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);
-        }
+        const f = p * c.stride + 0 /* Hot.FLAGS */;
+        c.hot[f] = c.hot[f] | 64 /* Flag.VOICE */;
     }
 }
+// A fill's per-subject path is methods, installed here from the modules that own them: as
+// functions called directly they made fills 5-8% slower (bench/ab.sh on teitou, 2026-10-05).
+const methods = {
+    row,
+    signalled,
+    parting,
+    subjectAt,
+    reset,
+    run,
+    one,
+    foldKeys,
+    readKeyed,
+    call,
+    gather,
+    fold,
+    foldDelta,
+    foldRun,
+    foldInto,
+};
+for (const [name, value] of Object.entries(methods))
+    Object.defineProperty(Lanes.prototype, name, { value, writable: true, configurable: true });