@msb235/blits 0.2.1 → 0.4.0

package/dist/mixer.js

@@ -1,5 +1,9 @@
+import { clampWeight, envelope, passAt, passesOf, phaseAt } from './clock.js';
 import { curve } from './easing.js';
-import { builtOf, readKeys } from './patch.js';
+import { clampRun, Lanes } from './lanes.js';
+import { motionOf, noFrame, noRevive } from './motion.js';
+import { builtOf, intosOf, readKeys } from './patch.js';
+import { reading } from './reading.js';
 import { Store } from './store.js';
 const none = Object.freeze([]);
 const keeper = (kept) => function keep(owner, init) {
@@ -7,8 +11,87 @@ const keeper = (kept) => function keep(owner, init) {
         return kept.get(owner);
     const made = init();
     kept.set(owner, made);
+    reading.kept++;
     return made;
 };
+/** The first record of a subject no live voice reaches, so a probe of it still makes one lookup. */
+function stub() {
+    const kept = new Map();
+    return {
+        reaches: false,
+        delay: 0,
+        since: 0,
+        shown: 0,
+        weight: 0,
+        rested: false,
+        bands: new Uint8Array(0),
+        state: undefined,
+        stepped: 0,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        kept,
+        keep: keeper(kept),
+        voice: null,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+    };
+}
+function elapsedWith(c, now) {
+    const dt = now - c.anchorNow;
+    const r = c.ramp;
+    if (r === null)
+        return c.anchorElapsed + dt * c.rate;
+    if (dt <= 0)
+        return c.anchorElapsed + dt * r.from;
+    const d = r.to - r.from;
+    if (dt <= r.over)
+        return c.anchorElapsed + r.from * dt + (d * dt * dt) / (2 * r.over);
+    return c.anchorElapsed + r.from * r.over + (d * r.over) / 2 + r.to * (dt - r.over);
+}
+/**
+ * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
+ * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
+ * it did live.
+ */
+function last(list, t, inclusive) {
+    let lo = 0;
+    let hi = list.length - 1;
+    let found;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const e = list[mid];
+        if (e.at < t || (e.at === t && (typeof inclusive === 'function' ? inclusive(e) : inclusive))) {
+            found = e;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return found;
+}
+/** A store that fills a missing entry from `make` on first ask. */
+class Filled extends Store {
+    make;
+    constructor(make) {
+        super();
+        this.make = make;
+    }
+    get(key) {
+        let v = super.get(key);
+        if (v === undefined) {
+            v = this.make(key);
+            if (v !== undefined)
+                super.set(key, v);
+        }
+        return v;
+    }
+}
+const noSend = () => { };
 const near = (a, b) => {
     if (typeof a === 'number' && typeof b === 'number')
         return Math.abs(a - b) < 1e-9;
@@ -17,7 +100,35 @@ const near = (a, b) => {
     return a === b;
 };
 const copy = (v) => (Array.isArray(v) ? [...v] : v);
-class Voice {
+/** Writes a folded pose's value into subject `n`'s places in a column. */
+function writeValue(c, v, n) {
+    const at = n * c.axes;
+    if (typeof v === 'number' && c.axes === 1)
+        c.out[at] = v;
+    else if (Array.isArray(v) && v.length === c.axes)
+        for (let a = 0; a < c.axes; a++)
+            c.out[at + a] = v[a];
+    else if (v === undefined)
+        c.out.fill(Number.NaN, at, at + c.axes);
+    else
+        throw new TypeError(`blits: pull reads ${c.key} as ${c.axes === 1 ? 'a number' : `${c.axes} numbers`} a subject, and the pose has ${String(v)}`);
+}
+/** Deep equality over plain data, for telling whether a host field changed. */
+function same(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    for (const k of ka)
+        if (!same(a[k], b[k]))
+            return false;
+    return true;
+}
+export class Voice {
     id;
     spec;
     patch;
@@ -36,13 +147,53 @@ class Voice {
     ramp = null;
     out = null;
     subjects = new Store();
+    /** The subjects its spec names, or null where it names none. */
+    named;
     /** Kit slot of each channel the patch writes, in `writes` order. */
     slots;
     /** The stops built ahead of time, for a `keys` patch. */
     built;
     /** The kit's `lerp` for each channel the patch writes, which keyed stops interpolate through. */
     lerps;
+    /** Per keyed channel, the in-place form of the lerp its stops take, where it has one. */
+    intos;
+    /**
+     * The arrays keyed reads interpolate into: one set for the voice, not one per subject, since 10k
+     * subjects' worth of long-lived arrays costs more in cache misses than allocating them did.
+     */
+    scratch = [];
+    /** The record whose delta holds `scratch`'s arrays; any other's must be read again to be handed out. */
+    holder = null;
+    /** Whether its channels run as lanes this frame, so the general fold passes it by. */
+    laned = false;
+    /** How many times it has been sought, so a delta read before a seek is not handed out after it. */
+    seeks = 0;
+    /** Whether its patch has kept state on a record through `setting.keep`, which makes it stateful. */
+    keeping = false;
+    /** For a motion patch, the hook it was given to ask the mix for its subjects' voice time. */
+    frame = null;
+    /** For a motion patch, the hook it was given to bring a subject faded out of this voice back. */
+    revive = null;
+    /** Subjects fading out of this voice alone, by the ramp each started; null while none are. */
+    parts = null;
+    /** Subjects faded out of this voice, by the mix time each left at; null while none have. */
+    parted = null;
     ease;
+    /** How many passes its `loop` plays, worked out once. */
+    passes;
+    /** Voice ms its passes last, Infinity for an aperiodic patch or a loop for good. */
+    span;
+    /** The state behind a motion patch, undefined for any other. */
+    motion;
+    /** Its `hold`, for a patch it applies to: motion holds its target already. */
+    holdsBefore;
+    holdsAfter;
+    /** The mix time it first showed: when it was cued, or the first sync after. */
+    opened = Number.NaN;
+    /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */
+    dueToken = 0;
+    /** Records made while it was pending, whose `since` its start may since have moved. */
+    early = null;
     /** Reused for every call this voice makes, so it is valid only during the call. */
     setting;
     /** Every subject this voice has been asked about, so a handover knows when it is finished. */
@@ -50,8 +201,20 @@ class Voice {
     /** The longest stagger of any subject seen, so a finite loop waits for the last of them. */
     latest = 0;
     restedCount = 0;
+    /** The mix time it was cued at; -Infinity before the first sync. */
+    cuedAt = Number.NEGATIVE_INFINITY;
+    /** The mix time it left at. */
+    doneAt = Number.POSITIVE_INFINITY;
+    /** Under `history`, its controls after each change, oldest first. */
+    log = null;
+    /** Where an anchored `out` or `end` puts its fade's start, mix time; Infinity until known. */
+    outAt = Number.POSITIVE_INFINITY;
+    /** Whether its start is still to be fixed by an anchor, so it waits pending. */
+    placing = false;
     resolve;
     done;
+    play;
+    played;
     constructor(id, spec, patch, fade, now, start, slotOf, channels, host, send) {
         this.id = id;
         this.spec = spec;
@@ -59,9 +222,22 @@ class Voice {
         this.fade = fade;
         this.start = start;
         this.slots = patch.writes.map((k) => slotOf.get(k));
+        this.named = spec.subjects ? new Set(spec.subjects) : null;
         this.built = patch.form === 'keys' && patch.keys ? builtOf(patch) : null;
         this.lerps = this.slots.map((slot) => channels[slot].lerp);
+        this.intos = this.built
+            ? intosOf(this.built, this.slots.map((slot) => channels[slot]))
+            : undefined;
         this.ease = fade.ease === undefined ? undefined : curve(fade.ease);
+        this.passes = passesOf(spec.loop);
+        this.span =
+            patch.period > 0 && Number.isFinite(this.passes)
+                ? patch.period * this.passes
+                : Number.POSITIVE_INFINITY;
+        this.motion = motionOf(patch);
+        const holds = this.motion === undefined ? spec.hold : undefined;
+        this.holdsBefore = holds === 'before' || holds === 'both';
+        this.holdsAfter = holds === 'after' || holds === 'both';
         this.setting = {
             timestamp: 0,
             dt: 0,
@@ -79,20 +255,81 @@ class Voice {
         this.done = new Promise((r) => {
             this.resolve = r;
         });
+        this.played = new Promise((r) => {
+            this.play = r;
+        });
         if (now >= start)
             this.state = 'live';
     }
     elapsedAt(now) {
-        const dt = now - this.anchorNow;
+        return elapsedWith(this, now);
+    }
+    /** The mix time its clock reads `elapsed`, inverting `elapsedAt`; Infinity where it never will. */
+    timeAt(elapsed) {
+        const e0 = this.anchorElapsed;
         const r = this.ramp;
-        if (r === null)
-            return this.anchorElapsed + dt * this.rate;
-        if (dt <= 0)
-            return this.anchorElapsed + dt * r.from;
-        const d = r.to - r.from;
-        if (dt <= r.over)
-            return this.anchorElapsed + r.from * dt + (d * dt * dt) / (2 * r.over);
-        return this.anchorElapsed + r.from * r.over + (d * r.over) / 2 + r.to * (dt - r.over);
+        if (r === null) {
+            if (this.rate > 0)
+                return this.anchorNow + (elapsed - e0) / this.rate;
+            return elapsed <= e0 ? this.anchorNow : Number.POSITIVE_INFINITY;
+        }
+        if (elapsed <= e0)
+            return r.from > 0 ? this.anchorNow + (elapsed - e0) / r.from : this.anchorNow;
+        const a = (r.to - r.from) / (2 * r.over);
+        const atEnd = e0 + r.from * r.over + a * r.over * r.over;
+        if (elapsed <= atEnd) {
+            const c = e0 - elapsed;
+            const dt = Math.abs(a) < 1e-12
+                ? -c / r.from
+                : (-r.from + Math.sqrt(Math.max(0, r.from * r.from - 4 * a * c))) / (2 * a);
+            return this.anchorNow + dt;
+        }
+        if (r.to <= 0)
+            return Number.POSITIVE_INFINITY;
+        return this.anchorNow + r.over + (elapsed - atEnd) / r.to;
+    }
+    /** Records this voice's controls as they stand, from mix time `at`. */
+    note(at, sync = false) {
+        this.log?.push({
+            at,
+            sync,
+            anchorNow: this.anchorNow,
+            anchorElapsed: this.anchorElapsed,
+            rate: this.rate,
+            ramp: this.ramp,
+            weight: this.weight,
+            out: this.out,
+            start: this.start,
+            outAt: this.outAt,
+        });
+    }
+    /**
+     * A copy for a projection: its own setting, which sends nothing, and its own per-subject records,
+     * filled from `fill`. With `controls` it takes those, as the voice stood at an earlier time.
+     */
+    copy(fill, controls) {
+        const v = Object.assign(Object.create(Voice.prototype), this);
+        const w = v;
+        w.subjects = new Filled(fill);
+        w.setting = { ...this.setting, keep: keeper(new Map()), send: noSend };
+        v.scratch = [];
+        v.holder = null;
+        v.laned = false;
+        v.log = null;
+        v.early = null;
+        if (controls) {
+            v.anchorNow = controls.anchorNow;
+            v.anchorElapsed = controls.anchorElapsed;
+            v.rate = controls.rate;
+            v.ramp = controls.ramp;
+            v.weight = controls.weight;
+            v.out = controls.out;
+            v.start = controls.start;
+            v.outAt = controls.outAt;
+        }
+        v.resolve = noSend;
+        v.play = noSend;
+        return v;
     }
     rateAt(now) {
         const r = this.ramp;
@@ -117,6 +354,25 @@ class Mixer {
     kit;
     opts;
     voices = [];
+    /** Under `history`, voices that have left but that a read back may still reach. */
+    gone = [];
+    /** Set on a projection's own mixer: it sends nothing, keeps no history, and reads without committing. */
+    projecting = false;
+    /** Set on a projection reading back: a subject it has nothing on starts from its voice's start. */
+    backward = false;
+    /** True during a sync, so a control change it makes is recorded as showing in that frame. */
+    moving = false;
+    /**
+     * Under `history` with `inputs`, the host fields patches read, copied each frame they changed. In
+     * a projection reading back, the copy in force then.
+     */
+    hostLog = [];
+    /**
+     * Marks the host announced on a score: mix time, NaN until the next sync for one announced as
+     * now before any sync; `made` is when it was announced, for a read back to know what was known.
+     */
+    announced = [];
+    hostThen;
     /** Each subject's last two poses and when they were probed, for `from: 'current'`. */
     pose = new Store();
     nextId = 1;
@@ -126,19 +382,55 @@ class Mixer {
     last = Number.NaN;
     rebasing = false;
     wantsPose = false;
+    /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
+    scratch;
+    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
+    /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
+    due = [];
+    /** Voices retired since `moveTo` last pruned them. */
+    retired = 0;
+    /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
+    walkAll = false;
+    pulled = [];
+    pulledHeads = [];
+    /** Each remembered head's lane slot, and the `version` and `relinks` they were all current at. */
+    pulledSlots = new Int32Array(0);
+    pulledVersion = Number.NaN;
+    pulledRelinks = -1;
+    /** Counts chains made stale one subject at a time, which `version` does not. */
+    relinks = 0;
     /** Read once a sync, so a `reduce` function is not called per voice per subject. */
     reducedNow = false;
+    /** Something was changed since the last sync, so the next frame may differ from this one. */
+    stirred = false;
     /**
-     * Per subject, the voices that may reach it, in voice order, so a probe walks those rather than
-     * every voice: a voice targeted at one subject is asked about that subject alone. Rebuilt when
-     * `version` moves, which is whenever the list or a voice's pending state changes.
+     * Per subject, the first record of the chain through every live voice that reaches it, or a stub
+     * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
+     * state changes.
      */
-    reach = new Store();
+    chains = new Store();
     version = 0;
-    /** How many voices in the list carry a `target`; with none, every voice reaches every subject. */
-    targeted = 0;
+    /** Per subject, the voices whose `subjects` name it, in voice order. */
+    named = new Store();
+    /** Voices a subject has been faded out of, which `drop` looks in besides those that reach it. */
+    parters = new Set();
+    /**
+     * Motion patches that may hold state for a subject no voice still reaching it plays, which `drop`
+     * frees besides those voices' own: per subject, a patch a voice naming it left while another
+     * voice plays on, or that the host retargeted it on; and any patch a voice over every subject
+     * left while another plays on. How many live voices play each motion patch says which.
+     */
+    strays = new Store();
+    strayAll = new Set();
+    playing = new Map();
+    /** How many voices in the list carry `subjects`. */
+    naming = 0;
+    /** The voices in the list that name no subjects, in voice order. */
+    general = [];
     /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
     loci = 0;
+    /** How many voices in the list are anchored, so a sync with none skips placing them. */
+    anchored = 0;
     /** Events sent since the last drain, and who is being probed, so `send` knows whose they are. */
     sent = [];
     sending = {
@@ -147,7 +439,7 @@ class Mixer {
     };
     send = (event) => {
         const { voice, subject } = this.sending;
-        if (voice === null)
+        if (voice === null || this.projecting)
             return;
         this.sent.push({
             timestamp: voice.setting.timestamp,
@@ -157,14 +449,14 @@ class Mixer {
             event,
         });
     };
-    /** What `influence` and `peek` found besides the delta, read by the caller at once. */
+    /** The weight `influence` found besides the delta, read by the caller at once. */
     w = 0;
-    h = null;
     names;
     channels;
     /** Slots of the channels that declare bounds, clamped after every fold. */
     bounded;
     slotOf = new Map();
+    lanes;
     constructor(kit, opts) {
         this.kit = kit;
         this.opts = opts;
@@ -174,6 +466,7 @@ class Mixer {
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
+        this.lanes = opts.lanes === false ? null : new Lanes(this.laneHost());
     }
     get reduced() {
         const r = this.opts.reduce;
@@ -203,16 +496,56 @@ class Mixer {
         }
         if (spec.from === 'current' && patch.form !== 'keys')
             throw new Error("blits: from: 'current' needs a keys patch");
-        const start = spec.start !== undefined ? spec.start - this.offset : Number.isNaN(this.now) ? 0 : this.now;
+        if (spec.subjects !== undefined && spec.target !== undefined)
+            throw new Error('blits: a voice takes target or subjects, not both');
+        const anchor = spec.anchor;
+        if (anchor)
+            this.checkPlacement(spec, anchor);
+        const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
+        const start = anchored
+            ? Number.POSITIVE_INFINITY
+            : spec.start !== undefined
+                ? spec.start - this.offset
+                : Number.isNaN(this.now)
+                    ? 0
+                    : this.now;
         const voice = new Voice(this.nextId++, spec, patch, spec.fade ?? {}, this.now, start, this.slotOf, this.channels, this.opts.host, this.send);
+        if (!Number.isNaN(this.now)) {
+            voice.cuedAt = this.now;
+            voice.opened = this.now;
+        }
+        voice.placing = anchored;
+        const motion = voice.motion;
+        if (motion !== undefined) {
+            this.playing.set(motion, (this.playing.get(motion) ?? 0) + 1);
+            voice.frame = Mixer.frameHook(new WeakRef(this), new WeakRef(voice));
+            motion.frame = voice.frame;
+            voice.revive = Mixer.reviveHook(new WeakRef(this), new WeakRef(voice));
+            motion.revive = voice.revive;
+        }
         this.voices.push(voice);
-        this.version++;
-        if (spec.target !== undefined)
-            this.targeted++;
+        this.index(voice);
+        this.changed(voice);
+        this.stirred = true;
         if (spec.locus !== undefined)
             this.loci++;
         if (spec.from === 'current')
             this.wantsPose = true;
+        if (anchor) {
+            this.anchored++;
+            this.place();
+            if (!Number.isNaN(this.now) && voice.state === 'pending' && this.now >= voice.start) {
+                voice.state = 'live';
+                this.started(voice);
+                this.changed(voice);
+            }
+        }
+        // After placing, so the controls it starts with are where its anchors put it at the cue.
+        if (this.opts.history) {
+            voice.log = [];
+            voice.note(Number.NEGATIVE_INFINITY);
+        }
+        this.schedule(voice);
         return this.handle(voice);
     }
     blend(patches, by, spec = {}) {
@@ -236,49 +569,225 @@ class Mixer {
         const now = timestamp - this.offset;
         if (now === this.now)
             return;
+        this.move(now);
+    }
+    /** Moves the mix clock to `now`: voices start, finite loops end, and fades finish. */
+    move(now) {
+        this.moving = true;
+        try {
+            this.moveTo(now);
+        }
+        finally {
+            this.moving = false;
+        }
+    }
+    moveTo(now) {
         this.now = now;
         this.reducedNow = this.reduced;
-        for (const voice of this.voices) {
+        for (const a of this.announced)
+            if (Number.isNaN(a.at))
+                a.at = now;
+        if (this.anchored > 0)
+            this.place();
+        if (this.announced.length > 0) {
+            // Kept while still ahead, or while history reaches it; anchors waiting on one were placed above.
+            const reach = now - (this.opts.history?.ms ?? 0);
+            this.announced = this.announced.filter((a) => a.at >= reach);
+        }
+        // A live mix visits only the voices due by now; a projection, which copies few, visits all.
+        const visit = this.projecting || this.walkAll ? this.voices : this.popDue(now);
+        for (const voice of visit) {
             if (voice.state === 'done')
                 continue;
+            if (Number.isNaN(voice.opened))
+                voice.opened = now;
+            if ((voice.state === 'live' || voice.state === 'held') && voice.outAt <= now)
+                this.beginFade(voice, {}, Math.max(voice.start, voice.outAt));
             if (voice.state === 'pending' && now >= voice.start) {
                 voice.state = 'live';
-                this.version++;
+                this.started(voice);
+                this.changed(voice);
             }
-            const period = voice.patch.period;
-            const loop = voice.spec.loop ?? true;
-            const passes = loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : loop;
-            if (voice.state === 'live' && period > 0 && Number.isFinite(passes)) {
-                if (voice.elapsedAt(now) >= period * passes + voice.latest)
-                    this.beginFade(voice, {});
+            if (voice.state !== 'pending' && Number.isFinite(voice.span)) {
+                const end = voice.span + voice.latest;
+                if (voice.elapsedAt(now) >= end) {
+                    voice.play(true);
+                    // The fade starts when the last pass ended, not at the frame that noticed, so it plays
+                    // the same at any frame rate and a read at another time can find it.
+                    if (voice.state === 'live') {
+                        if (voice.holdsAfter)
+                            voice.state = 'held';
+                        else
+                            this.beginFade(voice, {}, Math.max(voice.start, Math.min(now, voice.timeAt(end))));
+                    }
+                }
+                else if (voice.state === 'held')
+                    voice.state = 'live';
             }
+            // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
+            if (voice.parts !== null && !this.projecting)
+                for (const [subject, r] of voice.parts)
+                    if (now - r.at >= r.over)
+                        this.part(voice, subject, r.at + r.over);
             if (voice.state === 'fading' && voice.out) {
                 const { at, over, rest, deadline } = voice.out;
                 const spent = now - at;
                 if (rest) {
                     const out = deadline !== undefined && spent >= deadline;
                     const settled = voice.seen > 0 && voice.restedCount >= voice.seen;
-                    if (out || settled)
+                    if (out)
+                        this.retire(voice, at + deadline);
+                    else if (settled)
                         this.retire(voice);
                 }
                 else if (spent >= over)
-                    this.retire(voice);
+                    this.retire(voice, at + over);
             }
+            if (!this.projecting)
+                this.schedule(voice);
         }
-        for (let i = this.voices.length - 1; i >= 0; i--) {
-            const voice = this.voices[i];
-            if (voice.state === 'done') {
-                this.voices.splice(i, 1);
-                this.version++;
-                if (voice.spec.target !== undefined)
-                    this.targeted--;
-                if (voice.spec.locus !== undefined)
-                    this.loci--;
+        this.stirred = false;
+        if (this.retired === 0) {
+            this.forget(now);
+            return;
+        }
+        this.retired = 0;
+        let pruned = false;
+        let kept = 0;
+        const voices = this.voices;
+        for (let i = 0; i < voices.length; i++) {
+            const voice = voices[i];
+            if (voice.state !== 'done') {
+                voices[kept++] = voice;
+                continue;
             }
+            if (this.opts.history)
+                this.gone.push(voice);
+            else
+                this.parters.delete(voice);
+            this.unplay(voice);
+            this.changed(voice);
+            if (voice.named === null)
+                pruned = true;
+            else
+                this.unindex(voice);
+            if (voice.spec.locus !== undefined)
+                this.loci--;
+            if (voice.spec.anchor !== undefined)
+                this.anchored--;
+        }
+        voices.length = kept;
+        if (pruned)
+            this.general = this.general.filter((v) => v.state !== 'done');
+        this.forget(now);
+    }
+    /** Lets go of the voices that have left and that history no longer reaches. */
+    forget(now) {
+        const history = this.opts.history;
+        if (history && this.gone.length > 0) {
+            const reach = now - history.ms;
+            this.gone = this.gone.filter((v) => v.doneAt >= reach);
         }
     }
+    /**
+     * The earliest mix time `moveTo` would change a voice: its start, its anchored out, the end of
+     * its last pass, the end of its fade or of a subject's ramp out; -Infinity where it must be
+     * visited every frame, Infinity where nothing will happen until a handle or anchor changes it.
+     * Early is safe, since a visit that finds nothing due schedules again; late is not, so anything
+     * that can bring it earlier calls `schedule`.
+     */
+    dueOf(voice) {
+        if (voice.state === 'done')
+            return Number.POSITIVE_INFINITY;
+        if (Number.isNaN(voice.opened))
+            return Number.NEGATIVE_INFINITY;
+        let due = Number.POSITIVE_INFINITY;
+        if (voice.parts !== null)
+            for (const r of voice.parts.values())
+                due = Math.min(due, r.at + r.over);
+        if (voice.state === 'pending')
+            return Math.min(due, Number.isNaN(voice.start) ? due : voice.start);
+        if (voice.state === 'fading') {
+            const out = voice.out;
+            if (out === null || out.rest)
+                return Number.NEGATIVE_INFINITY;
+            return Math.min(due, out.at + out.over);
+        }
+        due = Math.min(due, voice.outAt);
+        if (Number.isFinite(voice.span)) {
+            const end = voice.span + voice.latest;
+            // A held voice goes live again once its clock is back before its end: by a seek, by a
+            // subject staggered later than any before, or by running backwards, which is checked each
+            // frame while it can.
+            if (voice.state === 'held') {
+                if (voice.rate <= 0 || voice.ramp !== null)
+                    return Number.NEGATIVE_INFINITY;
+                if (!Number.isNaN(this.now) && voice.elapsedAt(this.now) < end)
+                    return Number.NEGATIVE_INFINITY;
+            }
+            if (voice.state === 'live')
+                due = Math.min(due, voice.timeAt(end));
+        }
+        return due;
+    }
+    /** Files a voice in the due queue at its current due, replacing any entry it had. */
+    schedule(voice) {
+        if (this.projecting)
+            return;
+        this.lanes?.voiceChanged(voice.id);
+        const token = ++voice.dueToken;
+        const due = this.dueOf(voice);
+        if (due === Number.POSITIVE_INFINITY)
+            return;
+        const heap = this.due;
+        heap.push({ at: Number.isNaN(due) ? Number.NEGATIVE_INFINITY : due, voice, token });
+        let i = heap.length - 1;
+        while (i > 0) {
+            const up = (i - 1) >> 1;
+            if (heap[up].at <= heap[i].at)
+                break;
+            [heap[up], heap[i]] = [heap[i], heap[up]];
+            i = up;
+        }
+    }
+    /** Takes every current entry due by `now` off the queue, in cue order. */
+    popDue(now) {
+        const heap = this.due;
+        const at = (k) => k < heap.length ? heap[k].at : Number.POSITIVE_INFINITY;
+        const out = [];
+        while (heap.length > 0 && heap[0].at <= now) {
+            const top = heap[0];
+            const last = heap.pop();
+            if (heap.length > 0) {
+                heap[0] = last;
+                let i = 0;
+                for (;;) {
+                    const l = 2 * i + 1;
+                    const r = l + 1;
+                    const m0 = at(l) < at(i) ? l : i;
+                    const m = at(r) < at(m0) ? r : m0;
+                    if (m === i)
+                        break;
+                    [heap[m], heap[i]] = [heap[i], heap[m]];
+                    i = m;
+                }
+            }
+            if (top.token === top.voice.dueToken && top.voice.state !== 'done') {
+                top.voice.dueToken++;
+                out.push(top.voice);
+            }
+        }
+        if (out.length > 1)
+            out.sort((a, b) => a.id - b.id);
+        return out;
+    }
     probe(subject, out) {
         const pose = this.fold(subject, out);
+        this.keep(subject, pose, out);
+        return pose;
+    }
+    /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
+    keep(subject, pose, out) {
         // Keeping last frame's pose is free when the mix allocated it; a host sampling into its own
         // object only pays for the copy once something in the mix has asked to retarget from it.
         let kept;
@@ -305,7 +814,240 @@ class Mixer {
                 rec.at = this.now;
             }
         }
-        return pose;
+    }
+    pull(subjects, into) {
+        const columns = this.columnsOf(into);
+        const lanes = this.lanes;
+        const now = this.now;
+        if (this.scratch === undefined)
+            this.scratch = {};
+        const scratch = this.scratch;
+        let room = Number.POSITIVE_INFINITY;
+        let tightest = '';
+        for (const c of columns) {
+            const fits = Math.floor(c.out.length / c.axes);
+            if (fits < room) {
+                room = fits;
+                tightest = c.key;
+            }
+        }
+        // Any other iterable is read into an array first, no further than one past the room there is.
+        let list;
+        if (Array.isArray(subjects))
+            list = subjects;
+        else {
+            const taken = [];
+            for (const subject of subjects)
+                if (taken.push(subject) > room)
+                    break;
+            list = taken;
+        }
+        if (list.length > room)
+            throw new RangeError(`blits: pull's array for ${tightest} has room for ${room} subjects, and was given more`);
+        const whole = lanes !== null && !this.wantsPose;
+        // An array read again in the same order reuses each position's chain head while it is current:
+        // all of them at once while nothing has relinked since the last pull, else one by one.
+        const was = this.pulled;
+        const heads = this.pulledHeads;
+        was.length = list.length;
+        heads.length = list.length;
+        if (this.pulledSlots.length < list.length) {
+            const slots = new Int32Array(Math.max(64, list.length));
+            slots.set(this.pulledSlots);
+            this.pulledSlots = slots;
+        }
+        const slots = this.pulledSlots;
+        const version = this.version;
+        const relinks = this.relinks;
+        const live = !Number.isNaN(now);
+        const current = live && this.pulledVersion === version && this.pulledRelinks === relinks;
+        // Every subject read from the lanes, at the positions it had last time, goes in one run.
+        const runs = live && whole;
+        try {
+            for (let n = 0; n < list.length; n++) {
+                if (runs) {
+                    n = lanes.pullRun(slots, list, was, current ? null : heads, n, columns, now, this.version);
+                    if (n === list.length)
+                        break;
+                }
+                const subject = list[n];
+                let slot = -1;
+                if (live) {
+                    if (current && was[n] === subject)
+                        slot = slots[n];
+                    else {
+                        const kept = heads[n];
+                        const head = was[n] === subject && kept !== undefined && kept.version === version
+                            ? kept
+                            : this.chain(subject, now);
+                        was[n] = subject;
+                        heads[n] = head;
+                        slot = head.slot;
+                        slots[n] = slot;
+                    }
+                }
+                const laned = live && lanes?.prepare(slot, subject, now, this.version) === true;
+                if (laned && whole && lanes.whole) {
+                    lanes.writeLater(slot, columns, n);
+                    continue;
+                }
+                const head = live ? heads[n] : null;
+                const folded = this.foldWith(subject, scratch, head, laned, false);
+                const pose = (this.bounded.length === 0 ? folded : this.clamp(folded));
+                this.keep(subject, pose, scratch);
+                for (const c of columns)
+                    writeValue(c, pose[c.key], n);
+            }
+        }
+        finally {
+            lanes?.flush();
+        }
+        // Every head is current only if nothing relinked or changed version while they were read.
+        const unchanged = live && this.version === version && this.relinks === relinks;
+        this.pulledVersion = unchanged ? version : Number.NaN;
+        this.pulledRelinks = relinks;
+    }
+    /** The kit slot, width, rest and bounds of every channel `pull` was handed an array for. */
+    columnsOf(into) {
+        const columns = [];
+        for (const key of Object.keys(into)) {
+            const out = into[key];
+            if (out === undefined)
+                continue;
+            const slot = this.slotOf.get(key);
+            if (slot === undefined)
+                throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
+            const channel = this.channels[slot];
+            const rest = channel.rest;
+            const axes = Array.isArray(rest) ? rest.length : 1;
+            const bounds = channel.bounds;
+            const at = new Float64Array(axes).fill(Number.NaN);
+            if (typeof rest === 'number')
+                at[0] = rest;
+            else if (Array.isArray(rest))
+                at.set(rest);
+            if (bounds !== undefined)
+                clampRun(at, 0, axes, bounds);
+            columns.push({ key, slot, axes, out, rest: at, bounds });
+        }
+        return columns;
+    }
+    project(timestamp) {
+        const t = timestamp - this.offset;
+        const c = new Mixer(this.kit, { ...this.opts, history: undefined, lanes: false });
+        c.projecting = true;
+        c.pose = this.pose;
+        c.offset = this.offset;
+        c.wantsPose = this.wantsPose;
+        c.nextId = this.nextId;
+        c.reducedNow = this.reducedNow;
+        if (Number.isNaN(this.now) || t >= this.now) {
+            c.now = this.now;
+            c.voices = this.voices
+                .filter((v) => v.state !== 'done')
+                .map((v) => v.copy((subject) => this.carry(v, subject)));
+            c.announced = this.announced.map((a) => ({ ...a }));
+            c.count();
+            c.move(t);
+        }
+        else {
+            const history = this.opts.history;
+            if (!history)
+                throw new Error('blits: reading back needs a mix made with history');
+            if (t < this.now - history.ms)
+                throw new Error(`blits: ${timestamp} is older than this mix's history reaches`);
+            c.now = t;
+            c.backward = true;
+            const was = last(this.hostLog, t, true);
+            const host = this.opts.host;
+            const then = was && typeof host === 'object' && host !== null
+                ? Object.assign(Object.create(host), was.fields)
+                : undefined;
+            if (was)
+                c.hostThen = was;
+            c.announced = this.announced.filter((a) => a.made < t).map((a) => ({ ...a }));
+            c.voices = [...this.voices, ...this.gone]
+                .filter((v) => v.cuedAt <= t && v.doneAt > t)
+                .sort((a, b) => a.id - b.id)
+                .map((v) => {
+                const log = v.log;
+                const copy = v.copy((subject) => this.recall(v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
+                copy.state =
+                    t < v.start
+                        ? 'pending'
+                        : copy.out && copy.out.at <= t
+                            ? 'fading'
+                            : copy.holdsAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                                ? 'held'
+                                : 'live';
+                if (then !== undefined)
+                    copy.setting.host = then;
+                return copy;
+            });
+            c.count();
+        }
+        const read = (f) => {
+            reading.live = false;
+            try {
+                return f();
+            }
+            finally {
+                reading.live = true;
+            }
+        };
+        return {
+            timestamp,
+            probe: (subject, out) => read(() => c.fold(subject, out)),
+            assess: (subject) => read(() => {
+                c.fold(subject);
+                return c.doubts(subject);
+            }),
+        };
+    }
+    announce(name, opts = {}) {
+        const at = opts.at !== undefined ? opts.at - this.offset : this.now;
+        this.announced.push({
+            name,
+            score: opts.score,
+            tags: opts.tags ?? none,
+            at,
+            made: Number.isNaN(this.now) ? Number.NEGATIVE_INFINITY : this.now,
+            order: this.nextId++,
+        });
+    }
+    marks(from, to) {
+        const lo = from - this.offset;
+        const hi = to - this.offset;
+        const out = [];
+        for (const a of this.announced)
+            if (a.at >= lo && a.at <= hi)
+                out.push({
+                    timestamp: a.at + this.offset,
+                    mark: undefined,
+                    voice: undefined,
+                    score: a.score,
+                    name: a.name,
+                    tags: a.tags,
+                    order: a.order,
+                });
+        for (const voice of [...this.voices, ...this.gone]) {
+            for (const mark of ['start', 'in', 'out', 'end']) {
+                const t = this.markOf(voice, mark);
+                if (t === undefined || t < lo || t > hi)
+                    continue;
+                out.push({
+                    timestamp: t + this.offset,
+                    mark,
+                    voice: voice.id,
+                    score: voice.spec.score,
+                    name: voice.spec.name,
+                    tags: voice.spec.tags ?? none,
+                    order: voice.id,
+                });
+            }
+        }
+        out.sort((a, b) => a.timestamp - b.timestamp || a.order - b.order);
+        return out.map(({ order: _, ...m }) => m);
     }
     atRest(subject) {
         const pose = this.fold(subject, undefined, true);
@@ -327,15 +1069,99 @@ class Mixer {
     get live() {
         return this.voices.some((v) => v.state !== 'done');
     }
+    get inert() {
+        return !this.stirred && this.voices.every((v) => this.still(v, this.now));
+    }
+    /** Whether a voice will change no pose from `now` on, short of a change made to it. */
+    still(voice, now) {
+        if (voice.state === 'done')
+            return true;
+        if (voice.state !== 'held' && voice.state !== 'live')
+            return false;
+        if (typeof voice.spec.weight === 'function' || voice.parts !== null)
+            return false;
+        const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
+        if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
+            return false;
+        if (voice.state === 'held')
+            return true;
+        const motion = voice.motion;
+        return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
+    }
     mute(opts) {
         for (const voice of this.voices)
             this.beginFade(voice, { over: opts?.over });
     }
     drop(subject) {
+        const head = this.chains.get(subject);
+        // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
+        if (head !== undefined) {
+            head.version = Number.NaN;
+            this.relinks++;
+        }
+        if (head !== undefined && head.slot >= 0 && this.lanes !== null)
+            this.lanes.release(head.slot);
         this.pose.delete(subject);
-        this.reach.delete(subject);
-        for (const voice of this.voices)
+        this.chains.delete(subject);
+        this.stirred = true;
+        // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
+        // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
+        const forget = (voice) => {
             voice.subjects.delete(subject);
+            voice.motion?.release(subject);
+            voice.parts?.delete(subject);
+            voice.parted?.delete(subject);
+        };
+        for (const voice of this.general)
+            forget(voice);
+        const named = this.named.get(subject);
+        if (named !== undefined)
+            for (const voice of [...named])
+                forget(voice);
+        for (const voice of this.gone)
+            forget(voice);
+        for (const voice of this.parters) {
+            forget(voice);
+            if (voice.parts?.size === 0)
+                voice.parts = null;
+            if (voice.parted?.size === 0)
+                voice.parted = null;
+            if (voice.parts === null && voice.parted === null)
+                this.parters.delete(voice);
+        }
+        const strays = this.strays.get(subject);
+        if (strays !== undefined)
+            for (const motion of strays)
+                motion.release(subject);
+        this.strays.delete(subject);
+        for (const motion of this.strayAll)
+            motion.release(subject);
+    }
+    /** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
+    stray(motion, subject) {
+        const list = this.strays.get(subject);
+        if (list === undefined)
+            this.strays.set(subject, [motion]);
+        else if (!list.includes(motion))
+            list.push(motion);
+    }
+    /** A motion voice left the list: if its patch plays on, its subjects' state there may stray. */
+    unplay(voice) {
+        const motion = voice.motion;
+        if (motion === undefined)
+            return;
+        const left = (this.playing.get(motion) ?? 1) - 1;
+        if (left <= 0) {
+            this.playing.delete(motion);
+            this.strayAll.delete(motion);
+            return;
+        }
+        this.playing.set(motion, left);
+        if (voice.named === null)
+            this.strayAll.add(motion);
+        else
+            for (const subject of voice.named)
+                this.stray(motion, subject);
     }
     drain(tag) {
         const all = this.sent;
@@ -353,7 +1179,533 @@ class Mixer {
         }
         return out.sort((a, b) => a.timestamp - b.timestamp);
     }
+    laneHost() {
+        const mix = this;
+        return {
+            get voices() {
+                return mix.voices;
+            },
+            channels: this.channels,
+            names: this.names,
+            fits: (voice) => mix.fits(voice),
+            meet: (voice, subject) => mix.held(voice, subject, mix.now),
+            naming: (subject) => (mix.naming === 0 ? undefined : mix.named.get(subject)),
+            slotOf: (subject) => mix.chains.get(subject)?.slot ?? -1,
+            envelope: (voice, since) => mix.envelope(voice, mix.now, since),
+            parting: (voice, subject) => mix.parting(voice, subject, mix.now),
+            ready: (voice, subject, held, elapsed, pass, weight) => {
+                mix.prime(voice, held, mix.now, elapsed, pass);
+                voice.setting.weight = weight;
+                mix.sending.voice = voice;
+                mix.sending.subject = subject;
+            },
+            horizon: (voice, delay) => {
+                reading.horizon = mix.horizonFor(voice, delay, mix.now);
+            },
+            keeps: this.opts.history !== undefined,
+            after: (voice, held) => mix.remember(voice, held),
+            kept: (voice) => mix.stateful(voice),
+        };
+    }
+    /**
+     * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
+     * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
+     * one that starts keeping partway through may advance that state once for one subject not
+     * probed on the frame it starts, which declaring `state` avoids.
+     */
+    fits(voice) {
+        const spec = voice.spec;
+        const patch = voice.patch;
+        if (voice.keeping)
+            return false;
+        if (voice.state === 'pending' && voice.holdsBefore)
+            return false;
+        if (typeof spec.weight === 'function')
+            return false;
+        if (spec.locus !== undefined || spec.from === 'current')
+            return false;
+        if (voice.out?.rest)
+            return false;
+        if (patch.state !== undefined || patch.step !== undefined)
+            return false;
+        if (this.opts.history?.inputs && patch.reads !== undefined && patch.reads.length > 0)
+            return false;
+        const built = voice.built;
+        return (built === null ||
+            built.tracks.every((t, i) => t.lerp === undefined || t.lerp === voice.lerps[i]));
+    }
+    /** A voice's patch kept state on a record: it is stateful from now on. */
+    stateful(voice) {
+        if (voice.keeping)
+            return;
+        voice.keeping = true;
+        this.lanes?.invalidate();
+    }
+    /**
+     * What a motion patch asks for its subjects' voice time at the latest frame. It holds the mix and
+     * the voice weakly, so a patch the host keeps does not keep a mix it has let go of alive.
+     */
+    static reviveHook(mix, voice) {
+        return (subject) => {
+            const m = mix.deref();
+            if (m === undefined)
+                return;
+            m.stirred = true;
+            const v = voice.deref();
+            if (v === undefined)
+                return;
+            if (v.motion !== undefined && v.named !== null && !v.named.has(subject))
+                m.stray(v.motion, subject);
+            m.unpart(v, subject);
+        };
+    }
+    static frameHook(mix, voice) {
+        return (subject) => {
+            const m = mix.deref();
+            const v = voice.deref();
+            return m === undefined || v === undefined ? Number.NaN : m.frameOf(v, subject);
+        };
+    }
+    /**
+     * A subject's voice time at the latest frame, where a motion patch places an untimed change and a
+     * `read` with no time; NaN until the voice has started and met the subject, and while the
+     * subject's own time is still short of its stagger. A retired voice's patch no longer asks.
+     */
+    frameOf(voice, subject) {
+        if (Number.isNaN(this.now) || voice.state === 'pending')
+            return Number.NaN;
+        const held = voice.subjects.get(subject);
+        if (held === undefined || !held.reaches)
+            return Number.NaN;
+        const t = voice.elapsedAt(this.now) - held.delay;
+        return t < 0 ? Number.NaN : t;
+    }
+    /** Fills a voice's setting for a call to its patch, the weight aside. */
+    prime(voice, held, now, elapsed, pass) {
+        const setting = voice.setting;
+        setting.timestamp = now;
+        setting.dt = this.capped(now - held.stepped);
+        setting.elapsed = elapsed;
+        setting.pass = pass;
+        setting.weight = 0;
+        setting.state = held.state;
+        setting.keep = held.keep;
+    }
+    /** A gap as a `dt`: Infinity under reduced motion, and no more than `maxDt`. */
+    capped(gap) {
+        const cap = this.opts.maxDt;
+        return this.reducedNow ? Number.POSITIVE_INFINITY : cap !== undefined && gap > cap ? cap : gap;
+    }
+    /** The earliest voice time a read may still ask for, for a subject delayed `delay`. */
+    horizonFor(voice, delay, now) {
+        const history = this.opts.history;
+        return history === undefined
+            ? Number.POSITIVE_INFINITY
+            : this.elapsedThen(voice, now - history.ms) - delay;
+    }
     // ── internals ──────────────────────────────────────────────────────────────
+    /** Refuses a placement that names a mark twice on one side, or that waits on itself. */
+    checkPlacement(spec, anchor) {
+        if (anchor.start !== undefined && anchor.in !== undefined)
+            throw new Error('blits: a placement anchors start or in, not both');
+        if (anchor.out !== undefined && anchor.end !== undefined)
+            throw new Error('blits: a placement anchors out or end, not both');
+        if (spec.start !== undefined && (anchor.start !== undefined || anchor.in !== undefined))
+            throw new Error('blits: a voice takes start or an anchored start, not both');
+        const name = spec.name;
+        if (name === undefined)
+            return;
+        // A voice is known by its score and its name; a bare name in an anchor is in the asker's score.
+        const key = (score, n) => `${score ?? ''}\u0000${n}`;
+        const names = (p, score) => [p.start, p.in, p.out, p.end].flatMap((a) => {
+            if (a === undefined || typeof a === 'number')
+                return [];
+            const q = 'of' in a ? a.of : 'after' in a ? a.after : 'with' in a ? a.with : a.before;
+            if (typeof q === 'string')
+                return [key(score, q)];
+            return q.name === undefined ? [] : [key(q.score ?? score, q.name)];
+        });
+        const self = key(spec.score, name);
+        const seen = new Set();
+        const waits = names(anchor, spec.score);
+        while (waits.length > 0) {
+            const n = waits.pop();
+            if (n === self)
+                throw new Error(`blits: ${name}'s placement waits on itself`);
+            if (seen.has(n))
+                continue;
+            seen.add(n);
+            for (const v of this.voices)
+                if (v.spec.name !== undefined && key(v.spec.score, v.spec.name) === n && v.spec.anchor)
+                    waits.push(...names(v.spec.anchor, v.spec.score));
+        }
+    }
+    /**
+     * Fixes every anchored voice's start and out from what its anchors answer now. A start is fixed
+     * while the voice waits and an out until its fade begins; a target that has left keeps the time it
+     * last gave. Repeated so a chain of anchors settles in one sync.
+     */
+    place() {
+        for (let round = 0; round <= this.voices.length; round++) {
+            let moved = false;
+            for (const voice of this.voices) {
+                const anchor = voice.spec.anchor;
+                if (anchor === undefined || voice.state === 'done')
+                    continue;
+                if (voice.placing && voice.state === 'pending') {
+                    const by = anchor.start ?? anchor.in;
+                    const t = by === undefined ? undefined : this.resolve(by, voice);
+                    if (t !== undefined) {
+                        const start = anchor.start !== undefined ? t : t - (voice.fade.in ?? 0);
+                        if (start !== voice.start) {
+                            voice.start = start;
+                            voice.anchorNow = start;
+                            voice.anchorElapsed = 0;
+                            this.noted(voice);
+                            moved = true;
+                        }
+                    }
+                }
+                if (voice.state !== 'fading') {
+                    const by = anchor.out ?? anchor.end;
+                    const t = by === undefined ? undefined : this.resolve(by, voice);
+                    if (t !== undefined) {
+                        const at = anchor.out !== undefined ? t : t - (voice.fade.out ?? 0);
+                        if (at !== voice.outAt) {
+                            voice.outAt = at;
+                            this.noted(voice);
+                            moved = true;
+                        }
+                    }
+                }
+            }
+            if (!moved)
+                return;
+        }
+    }
+    /** The mix time an anchor answers, or undefined while its target has none. */
+    resolve(a, self) {
+        if (typeof a === 'number')
+            return a - this.offset;
+        let query;
+        let mark;
+        let by = a.by ?? 0;
+        if ('of' in a) {
+            query = a.of;
+            mark = a.mark;
+        }
+        else if ('after' in a) {
+            query = a.after;
+            mark = 'end';
+        }
+        else if ('with' in a) {
+            query = a.with;
+            mark = 'start';
+        }
+        else {
+            query = a.before;
+            mark = 'start';
+            by = -by;
+        }
+        const t = this.timeOf(typeof query === 'string' ? { name: query } : query, mark, self);
+        return t === undefined ? undefined : t + by;
+    }
+    /**
+     * The time a query answers: `mark` of the voice it picks, among those cued and those that have
+     * left, never the asker; or a mark the host announced on the score, which is the same time for
+     * any of the four. Undefined while what it picks has no such time.
+     */
+    timeOf(q, mark, self) {
+        const score = q.score ?? self.spec.score;
+        const found = [];
+        for (const v of [...this.gone, ...this.voices])
+            if (v !== self &&
+                v.spec.score === score &&
+                (q.name === undefined || v.spec.name === q.name) &&
+                (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+                (q.writes === undefined || v.patch.writes.includes(q.writes)))
+                found.push({ order: v.id, t: this.markOf(v, mark) });
+        if (q.writes === undefined)
+            for (const a of this.announced)
+                if (a.score === score &&
+                    (q.name === undefined || a.name === q.name) &&
+                    (q.tag === undefined || a.tags.includes(q.tag)))
+                    found.push({ order: a.order, t: Number.isNaN(a.at) ? undefined : a.at });
+        if (found.length === 0)
+            return undefined;
+        found.sort((x, y) => x.order - y.order);
+        const resolver = q.resolver ?? 'last';
+        if (resolver === 'first')
+            return found[0]?.t;
+        if (resolver === 'last')
+            return found[found.length - 1]?.t;
+        const times = found.flatMap((e) => (e.t === undefined ? [] : [e.t])).sort((x, y) => x - y);
+        if (resolver === 'next') {
+            const now = Number.isNaN(this.now) ? Number.NEGATIVE_INFINITY : this.now;
+            return times.find((t) => t >= now);
+        }
+        return resolver === 'earliest' ? times[0] : times[times.length - 1];
+    }
+    /** When a voice reaches a mark, mix time, or undefined while nothing has fixed it. */
+    markOf(voice, mark) {
+        const start = voice.start;
+        if (!Number.isFinite(start))
+            return undefined;
+        if (mark === 'start')
+            return start;
+        if (mark === 'in')
+            return start + (voice.fade.in ?? 0);
+        const out = voice.out;
+        let outAt;
+        if (out !== null)
+            outAt = out.at;
+        else if (Number.isFinite(voice.outAt))
+            outAt = voice.outAt;
+        else if (!voice.holdsAfter && Number.isFinite(voice.span)) {
+            const t = voice.timeAt(voice.span + voice.latest);
+            if (Number.isFinite(t))
+                outAt = Math.max(start, t);
+        }
+        if (mark === 'out')
+            return voice.state === 'done' && outAt === undefined ? voice.doneAt : outAt;
+        if (voice.state === 'done')
+            return voice.doneAt;
+        if (out !== null) {
+            if (out.rest)
+                return out.deadline === undefined ? undefined : out.at + out.deadline;
+            return out.at + out.over;
+        }
+        return outAt === undefined ? undefined : outAt + (this.reduced ? 0 : (voice.fade.out ?? 0));
+    }
+    /** A voice's elapsed at an earlier mix time, by the controls it had then. */
+    elapsedThen(voice, t) {
+        const log = voice.log;
+        const c = log === null ? undefined : last(log, t, true);
+        return elapsedWith(c ?? voice, t);
+    }
+    /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
+    noted(voice) {
+        this.stirred = true;
+        this.schedule(voice);
+        const log = voice.log;
+        if (log === null)
+            return;
+        voice.note(Number.isNaN(this.now) ? Number.NEGATIVE_INFINITY : this.now, this.moving);
+        const reach = this.now - this.opts.history.ms;
+        let drop = 0;
+        while (drop + 1 < log.length && log[drop + 1].at <= reach)
+            drop++;
+        if (drop > 0)
+            log.splice(0, drop);
+    }
+    /** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
+    count() {
+        this.named = new Store();
+        this.naming = 0;
+        this.general = [];
+        for (const voice of this.voices)
+            this.index(voice);
+        this.loci = this.voices.filter((v) => v.spec.locus !== undefined).length;
+        this.anchored = this.voices.filter((v) => v.spec.anchor !== undefined).length;
+        this.version++;
+    }
+    /** A copy of a subject's record that shares nothing a read could change. */
+    copyHeld(voice, h) {
+        const kept = new Map();
+        for (const [owner, value] of h.kept)
+            kept.set(owner, structuredClone(value));
+        const patch = voice.patch;
+        return {
+            ...h,
+            bands: h.bands.slice(),
+            state: h.state === undefined
+                ? undefined
+                : patch.clone
+                    ? patch.clone(h.state)
+                    : structuredClone(h.state),
+            kept,
+            keep: keeper(kept),
+            probed: Number.NaN,
+            delta: null,
+            phase: 0,
+            seeks: 0,
+            base: h.base === undefined ? undefined : structuredClone(h.base),
+            slope: h.slope === undefined ? undefined : structuredClone(h.slope),
+            snaps: undefined,
+            inputs: undefined,
+            next: null,
+            version: Number.NaN,
+            loci: null,
+            slot: -1,
+        };
+    }
+    /** A projection ahead starts each subject from where the live mix holds it. */
+    carry(voice, subject) {
+        const live = voice.subjects.get(subject);
+        if (live === undefined)
+            return undefined;
+        const h = this.copyHeld(voice, live);
+        h.from = h.stepped;
+        return h;
+    }
+    /**
+     * A projection back starts each subject from the latest copy kept at or before `t`, else from its
+     * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
+     */
+    recall(voice, subject, t) {
+        const live = voice.subjects.get(subject);
+        if (live === undefined)
+            return undefined;
+        const snap = live.snaps && last(live.snaps, t, true);
+        if (snap) {
+            const h = this.copyHeld(voice, snap.held);
+            h.from = h.stepped;
+            h.replay = live.inputs;
+            return h;
+        }
+        const kept = new Map();
+        const stepped = live.since < t ? live.since : t;
+        return {
+            reaches: live.reaches,
+            delay: live.delay,
+            since: live.since,
+            shown: live.shown,
+            weight: 0,
+            rested: false,
+            bands: new Uint8Array(voice.slots.length),
+            state: live.reaches && voice.patch.state
+                ? voice.patch.state(subject)
+                : undefined,
+            stepped,
+            ticks: 0,
+            probed: Number.NaN,
+            delta: null,
+            phase: 0,
+            seeks: 0,
+            kept,
+            keep: keeper(kept),
+            voice,
+            next: null,
+            version: Number.NaN,
+            loci: null,
+            slot: -1,
+            from: stepped,
+            unknown: voice.spec.from === 'current',
+            replay: live.inputs,
+        };
+    }
+    /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
+    recordHost(now) {
+        const log = this.hostLog;
+        const prev = log[log.length - 1];
+        if (prev !== undefined && prev.at === now)
+            return;
+        const host = this.opts.host;
+        const fields = {};
+        for (const v of this.voices)
+            for (const f of v.patch.reads ?? none)
+                if (!(f in fields))
+                    fields[f] = structuredClone(host[f]);
+        if (prev !== undefined && same(prev.fields, fields))
+            return;
+        log.push({ at: now, fields });
+        const reach = now - this.opts.history.ms;
+        while (log.length > 1 && log[1].at <= reach)
+            log.shift();
+    }
+    /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
+    record(held, value) {
+        const history = this.opts.history;
+        if (!history?.inputs || this.projecting)
+            return;
+        const inputs = held.inputs ?? [];
+        held.inputs = inputs;
+        const prev = inputs[inputs.length - 1];
+        if (prev !== undefined && (prev.value === value || prev.at === this.now)) {
+            if (prev.at === this.now)
+                prev.value = value;
+            return;
+        }
+        inputs.push({ at: this.now, value });
+        const reach = this.now - history.ms;
+        while (inputs.length > 1 && inputs[1].at <= reach)
+            inputs.shift();
+    }
+    /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
+    remember(voice, held) {
+        const history = this.opts.history;
+        if (!history || this.projecting)
+            return;
+        if (voice.patch.step === undefined && held.kept.size === 0 && held.base === undefined)
+            return;
+        const snaps = held.snaps ?? [];
+        held.snaps = snaps;
+        const prev = snaps[snaps.length - 1];
+        if (prev !== undefined && this.now - prev.at < (history.every ?? 200))
+            return;
+        snaps.push({ at: this.now, held: this.copyHeld(voice, held) });
+        const reach = this.now - history.ms;
+        while (snaps.length > 1 && snaps[1].at <= reach)
+            snaps.shift();
+    }
+    /** Per channel, the least sure voice that fed it this frame. */
+    doubts(subject) {
+        const out = {};
+        for (const name of this.names)
+            out[name] = 'exact';
+        const rank = { exact: 0, stepped: 1, held: 2 };
+        // A voice still waiting on an anchor nothing has answered may yet play, or stop, by now.
+        for (const voice of this.voices) {
+            const anchor = voice.spec.anchor;
+            if (anchor === undefined || voice.state === 'done')
+                continue;
+            const waiting = (voice.state === 'pending' && !Number.isFinite(voice.start)) ||
+                (voice.state !== 'pending' &&
+                    voice.state !== 'fading' &&
+                    (anchor.out !== undefined || anchor.end !== undefined) &&
+                    !Number.isFinite(voice.outAt));
+            if (!waiting || !this.aims(voice, subject))
+                continue;
+            for (const slot of voice.slots)
+                out[this.names[slot]] = 'held';
+        }
+        for (let held = this.chain(subject, this.now); held !== null; held = held.next) {
+            const voice = held.voice;
+            if (voice === null || voice.state === 'done')
+                continue;
+            if (held.weight <= 0)
+                continue;
+            const d = this.doubtOf(voice, held);
+            for (const slot of voice.slots) {
+                const name = this.names[slot];
+                if (rank[d] > rank[out[name]])
+                    out[name] = d;
+            }
+        }
+        return out;
+    }
+    doubtOf(voice, held) {
+        const weight = voice.spec.weight;
+        if (held.unknown)
+            return 'held';
+        // A weight read back from a recording is what the mix used then, so its signal's state is moot.
+        const replayed = held.replay !== undefined && last(held.replay, this.now, true) !== undefined;
+        if (typeof weight === 'function' && weight.input && !replayed)
+            return 'held';
+        const reads = voice.patch.reads;
+        if (reads !== undefined && reads.length > 0) {
+            const then = this.hostThen?.fields;
+            if (then === undefined || !reads.every((f) => f in then))
+                return 'held';
+        }
+        if (this.now > (held.from ?? this.now)) {
+            const tick = this.opts.stepMs;
+            const fixed = tick !== undefined && tick > 0 && !this.reducedNow;
+            if ((voice.patch.step && !fixed) || (held.kept.size > 0 && !replayed))
+                return 'stepped';
+        }
+        return 'exact';
+    }
     handle(voice) {
         const mix = this;
         return {
@@ -361,11 +1713,14 @@ class Mixer {
             get state() {
                 return voice.state;
             },
+            played: voice.played,
             get weight() {
                 return voice.weight;
             },
             set weight(w) {
                 voice.weight = w;
+                mix.noted(voice);
+                mix.lanes?.refill();
             },
             get rate() {
                 return voice.rateAt(Number.isNaN(mix.now) ? voice.start : mix.now);
@@ -374,6 +1729,8 @@ class Mixer {
                 voice.rebase(Number.isNaN(mix.now) ? voice.start : mix.now);
                 voice.ramp = null;
                 voice.rate = r;
+                mix.noted(voice);
+                mix.lanes?.refill();
             },
             ramp(r, over) {
                 const now = Number.isNaN(mix.now) ? voice.start : mix.now;
@@ -381,182 +1738,311 @@ class Mixer {
                 const from = voice.rateAt(now);
                 voice.ramp = over > 0 && r !== from ? { from, to: r, over } : null;
                 voice.rate = r;
+                mix.noted(voice);
+                mix.lanes?.refill();
             },
             seek(elapsed) {
                 voice.rebase(Number.isNaN(mix.now) ? voice.start : mix.now);
                 voice.anchorElapsed = elapsed;
+                voice.seeks++;
+                mix.noted(voice);
+                mix.lanes?.refill();
             },
             fade(opts) {
-                mix.beginFade(voice, opts ?? {});
+                if (opts !== undefined && 'subject' in opts)
+                    mix.fadeSubject(voice, opts.subject, opts.over);
+                else
+                    mix.beginFade(voice, opts ?? {});
             },
             weightOf(subject) {
                 if (voice.state === 'done')
                     return 0;
+                if (voice.laned && mix.lanes !== null) {
+                    const w = mix.lanes.weightOf(voice.id, mix.chains.get(subject)?.slot ?? -1);
+                    if (w !== undefined)
+                        return w;
+                }
                 return voice.subjects.get(subject)?.weight ?? 0;
             },
             done: voice.done,
         };
     }
-    beginFade(voice, opts) {
+    /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
+    fadeSubject(voice, subject, over) {
+        if (voice.state === 'done' || voice.parted?.has(subject) || voice.parts?.has(subject))
+            return;
+        this.stirred = true;
+        const ms = this.reduced ? 0 : (over ?? voice.fade.out ?? 0);
+        const at = Number.isNaN(this.now) ? voice.start : this.now;
+        if (ms === 0) {
+            this.part(voice, subject, at);
+            return;
+        }
+        voice.parts ??= new Map();
+        voice.parts.set(subject, { at, over: ms });
+        this.parters.add(voice);
+        this.schedule(voice);
+        this.lanes?.refill();
+    }
+    /** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+    parting(voice, subject, now) {
+        const r = voice.parts?.get(subject);
+        if (r === undefined)
+            return 1;
+        return envelope(0, { at: r.at, over: r.over, rest: false }, voice.ease, this.reducedNow, now, 0);
+    }
+    /**
+     * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
+     * its lane position and a motion patch's state for it, and reaches it no more.
+     */
+    part(voice, subject, at) {
+        voice.parts?.delete(subject);
+        if (voice.parts?.size === 0)
+            voice.parts = null;
+        voice.parted ??= new Map();
+        voice.parted.set(subject, at);
+        this.parters.add(voice);
+        this.forgetIn(voice, subject);
+        const motion = voice.motion;
+        if (motion !== undefined && motion.frame === voice.frame)
+            motion.release(subject);
+    }
+    /** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
+    unpart(voice, subject) {
+        if (voice.parted?.delete(subject) !== true)
+            return;
+        if (voice.parted.size === 0)
+            voice.parted = null;
+        this.forgetIn(voice, subject);
+        const slot = this.chains.get(subject)?.slot ?? -1;
+        if (slot >= 0)
+            this.lanes?.rejoin(slot);
+    }
+    /** Drops a voice's record of a subject and relinks the subject's chain without it. */
+    forgetIn(voice, subject) {
+        const held = voice.subjects.get(subject);
+        if (held !== undefined) {
+            voice.subjects.delete(subject);
+            if (held.reaches)
+                voice.seen--;
+            if (held.rested)
+                voice.restedCount--;
+            if (voice.holder === held)
+                voice.holder = null;
+        }
+        const head = this.chains.get(subject);
+        if (head === undefined)
+            return;
+        head.version = Number.NaN;
+        this.relinks++;
+        if (voice.laned && head.slot >= 0)
+            this.lanes?.part(voice.id, head.slot);
+        this.lanes?.refill();
+    }
+    beginFade(voice, opts, at) {
         if (voice.state === 'done' || voice.state === 'fading')
             return;
         const over = this.reduced ? 0 : (opts.over ?? voice.fade.out ?? 0);
+        // A voice is linked into its subjects' chains once it plays, and a fading one plays.
+        if (voice.state === 'pending')
+            this.changed(voice);
         voice.state = 'fading';
         voice.out = {
             from: 1,
-            at: Number.isNaN(this.now) ? voice.start : this.now,
+            at: at ?? (Number.isNaN(this.now) ? voice.start : this.now),
             over,
             rest: opts.at === 'rest',
             deadline: opts.deadline,
         };
+        this.noted(voice);
+        if (opts.at === 'rest')
+            this.lanes?.invalidate();
+        else
+            this.lanes?.refill();
         if (over === 0 && opts.at !== 'rest')
-            this.retire(voice);
+            this.retire(voice, voice.out.at);
     }
-    retire(voice) {
+    /** Removes a voice, recording that it left at `at`, default now. */
+    retire(voice, at) {
+        this.lanes?.touch(voice);
+        const motion = voice.motion;
+        if (motion !== undefined && motion.frame === voice.frame)
+            motion.frame = noFrame;
+        if (motion !== undefined && motion.revive === voice.revive)
+            motion.revive = noRevive;
+        voice.frame = null;
+        voice.revive = null;
         voice.state = 'done';
+        this.retired++;
+        voice.doneAt = at ?? (Number.isNaN(this.now) ? Number.NEGATIVE_INFINITY : this.now);
+        voice.play(false);
         voice.resolve();
     }
     /** The ramp a voice's own fade envelope applies this frame, 0..1. */
     envelope(voice, now, since) {
-        const reduced = this.reducedNow;
-        const ease = voice.ease;
-        let w = 1;
-        const fadeIn = voice.fade.in ?? 0;
-        if (fadeIn > 0 && !reduced) {
-            const u = (now - since) / fadeIn;
-            if (u < 1)
-                w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
-        }
-        const out = voice.out;
-        if (out && !out.rest) {
-            if (reduced || out.over === 0)
-                return 0;
-            const u = 1 - (now - out.at) / out.over;
-            const clamped = u < 0 ? 0 : u > 1 ? 1 : u;
-            w *= ease ? ease(clamped) : clamped;
-        }
-        return w;
+        return envelope(voice.fade.in ?? 0, voice.out, voice.ease, this.reducedNow, now, since);
     }
     /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
     held(voice, subject, now) {
         let held = voice.subjects.get(subject);
         if (held !== undefined)
             return held;
-        const reaches = voice.spec.target ? voice.spec.target(subject) : true;
+        const reaches = this.aims(voice, subject);
         const delay = reaches && voice.spec.stagger ? voice.spec.stagger(subject) : 0;
-        // When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
-        // the rate it is ramping to.
-        const since = voice.rate > 0
-            ? voice.anchorNow + (delay - voice.anchorElapsed) / voice.rate
-            : voice.start + delay;
+        const since = this.sinceOf(voice, delay);
         const kept = new Map();
         held = {
             reaches,
             delay,
             since,
+            shown: this.shownOf(voice, since),
             weight: 0,
             rested: false,
             bands: new Uint8Array(voice.slots.length),
             state: reaches && voice.patch.state
                 ? voice.patch.state(subject)
                 : undefined,
-            stepped: now,
+            stepped: this.backward && since < now ? since : now,
             ticks: 0,
             probed: Number.NaN,
             delta: null,
+            phase: 0,
+            seeks: 0,
             kept,
             keep: keeper(kept),
+            voice,
+            next: null,
+            version: Number.NaN,
+            loci: null,
+            slot: -1,
         };
+        if (this.projecting) {
+            held.from = held.stepped;
+            held.unknown = this.backward && voice.spec.from === 'current';
+        }
         voice.subjects.set(subject, held);
+        if (voice.state === 'pending') {
+            voice.early ??= [];
+            voice.early.push(held);
+        }
         if (reaches)
             voice.seen++;
-        if (delay > voice.latest)
+        if (delay > voice.latest) {
             voice.latest = delay;
+            // A later end can take a held voice live again.
+            if (voice.state === 'held')
+                this.schedule(voice);
+        }
         return held;
     }
+    /**
+     * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
+     * the rate it is ramping to.
+     */
+    sinceOf(voice, delay) {
+        return voice.rate > 0
+            ? voice.anchorNow + (delay - voice.anchorElapsed) / voice.rate
+            : voice.start + delay;
+    }
+    shownOf(voice, since) {
+        return voice.holdsBefore && voice.opened < since ? voice.opened : since;
+    }
+    /** A voice has gone live: the records it made while pending count from where it started. */
+    started(voice) {
+        const early = voice.early;
+        if (early === null)
+            return;
+        voice.early = null;
+        for (const held of early) {
+            held.since = this.sinceOf(voice, held.delay);
+            held.shown = this.shownOf(voice, held.since);
+        }
+    }
     /** The weight a voice gives a subject this frame, with the setting already filled in. */
     weigh(voice, subject, now, held) {
         this.sending.voice = voice;
         this.sending.subject = subject;
         const signal = typeof voice.spec.weight === 'function' ? voice.spec.weight : null;
-        const raw = (signal ? signal(subject, voice.setting) : voice.weight) *
-            this.envelope(voice, now, held.since);
-        return raw < 0 ? 0 : raw > 1 ? 1 : raw;
+        let base = voice.weight;
+        if (signal) {
+            const was = held.replay && last(held.replay, now, true);
+            base = was ? was.value : signal(subject, voice.setting);
+            if (signal.input && !was)
+                this.record(held, base);
+        }
+        const fade = this.envelope(voice, now, held.shown);
+        return clampWeight(base * (voice.parts === null ? fade : fade * this.parting(voice, subject, now)));
     }
     /**
-     * One voice's delta for one subject this frame, or null when it does not reach. Its weight and
-     * the subject's record are left in `w` and `h`.
+     * One live voice's delta for one subject this frame, through its record for the subject, or null
+     * when it does not reach. Its weight is left in `w`.
      */
-    influence(voice, subject, now) {
-        if (voice.state === 'pending' || voice.state === 'done')
-            return null;
-        const held = this.held(voice, subject, now);
+    influence(voice, subject, now, held) {
         held.weight = 0;
         if (!held.reaches)
             return null;
         if (voice.out?.rest && held.rested)
             return null;
-        const elapsed = voice.elapsedAt(now) - held.delay;
-        if (elapsed < 0)
-            return null;
-        const period = voice.patch.period;
-        const loop = voice.spec.loop ?? true;
-        const passes = loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : loop;
-        let phase = 0;
-        let pass = 0;
-        if (period > 0) {
-            const done = Number.isFinite(passes) && elapsed >= period * passes;
-            phase = done ? 1 : (elapsed % period) / period;
-            pass = done ? passes - 1 : Math.floor(elapsed / period);
+        let elapsed = voice.elapsedAt(now) - held.delay;
+        // A held subject's clock stands still at the edge it holds: -1 before, 1 after, 0 playing.
+        let still = 0;
+        if (elapsed < 0) {
+            if (!voice.holdsBefore)
+                return null;
+            elapsed = 0;
+            still = -1;
+        }
+        else if (voice.holdsAfter && elapsed > voice.span) {
+            elapsed = voice.span;
+            still = 1;
         }
+        const period = voice.patch.period;
+        const phase = phaseAt(elapsed, period, voice.passes);
+        const pass = passAt(elapsed, period, voice.passes);
+        this.prime(voice, held, now, elapsed, pass);
         const setting = voice.setting;
-        setting.timestamp = now;
-        const gap = now - held.stepped;
-        const cap = this.opts.maxDt;
-        setting.dt = this.reducedNow
-            ? Number.POSITIVE_INFINITY
-            : cap !== undefined && gap > cap
-                ? cap
-                : gap;
-        setting.elapsed = elapsed;
-        setting.pass = pass;
-        setting.weight = 0;
-        setting.state = held.state;
-        setting.keep = held.keep;
         const weight = this.weigh(voice, subject, now, held);
         setting.weight = weight;
         held.weight = weight;
-        if (held.probed === now && held.delta) {
+        if (held.probed === now && held.delta && held.seeks === voice.seeks) {
+            if (voice.holder !== held && voice.scratch.length > 0)
+                this.keyed(voice, subject, held);
             this.w = weight;
-            this.h = held;
             return held.delta;
         }
+        const keptBefore = reading.kept;
+        const history = this.opts.history;
+        if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
+            this.recordHost(now);
+        reading.horizon = this.horizonFor(voice, held.delay, now);
         const tick = this.opts.stepMs;
-        if (voice.patch.step && held.probed !== now) {
+        if (voice.patch.step && held.probed !== now && still >= 0) {
+            // Held after, it steps once more to where its last pass ended, and no further.
+            const to = still === 1 ? voice.timeAt(held.delay + voice.span) : now;
             if (tick !== undefined && tick > 0 && !this.reducedNow)
-                this.tick(voice, subject, held, tick);
-            else if (now !== held.stepped) {
+                this.tick(voice, subject, held, tick, to);
+            else if (still === 0 ? now !== held.stepped : to > held.stepped) {
+                if (still === 1)
+                    setting.dt = this.capped(to - held.stepped);
                 voice.patch.step(held.state, setting.dt, subject, setting);
-                held.stepped = now;
+                held.stepped = to;
             }
         }
         let delta;
         if (voice.built) {
-            let base;
-            if (voice.spec.from === 'current') {
-                if (held.base === undefined) {
-                    held.base = this.baseFor(voice, subject);
-                    held.slope = this.slopeFor(voice, subject);
-                }
-                base = held.base;
-            }
-            delta = readKeys(voice.built, phase, held.delta ?? {}, base, voice.lerps, held.slope);
+            held.phase = phase;
+            delta = this.keyed(voice, subject, held);
         }
         else {
             delta = voice.patch.at(phase, subject, setting);
         }
         held.delta = delta;
         held.probed = now;
+        held.seeks = voice.seeks;
+        if (history !== undefined)
+            this.remember(voice, held);
+        if (reading.kept !== keptBefore && !voice.keeping)
+            this.stateful(voice);
         if (voice.out?.rest && this.isRest(delta)) {
             held.weight = 0;
             held.rested = true;
@@ -564,7 +2050,22 @@ class Mixer {
             return null;
         }
         this.w = weight;
-        this.h = held;
+        return delta;
+    }
+    /** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
+    keyed(voice, subject, held) {
+        let base;
+        if (voice.spec.from === 'current') {
+            if (held.base === undefined) {
+                held.base = this.baseFor(voice, subject);
+                held.slope = this.slopeFor(voice, subject);
+            }
+            base = held.base;
+        }
+        const delta = readKeys(voice.built, held.phase, held.delta ?? {}, base, voice.lerps, held.slope, voice.intos, voice.scratch);
+        held.delta = delta;
+        if (voice.scratch.length > 0)
+            voice.holder = held;
         return delta;
     }
     /**
@@ -572,13 +2073,13 @@ class Mixer {
      * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
      * rather than adding keeps the grid where it is however many samples it is reached through.
      */
-    tick(voice, subject, held, tick) {
+    tick(voice, subject, held, tick, to) {
         const now = this.now;
         const setting = voice.setting;
         const frameDt = setting.dt;
         let n = held.ticks;
         // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
-        const due = Math.floor((now - held.since) / tick + 1e-9);
+        const due = Math.floor((to - held.since) / tick + 1e-9);
         const cap = this.opts.maxDt;
         if (cap !== undefined) {
             const most = Math.floor(cap / tick);
@@ -693,27 +2194,111 @@ class Mixer {
         return w >= on ? true : w <= off ? false : (was ?? w >= on);
     }
     /**
-     * The voices that may reach this subject. A live voice is asked once, through the record it keeps
-     * for the subject anyway; a pending one is kept until it goes live, since `target` is asked on
-     * first sight, and sight only comes once a voice plays.
+     * The first of this subject's records, linked through every live voice that reaches it. A voice
+     * is asked once, through the record it keeps for the subject anyway; a pending one is linked when
+     * it goes live, since `target` is asked on first sight, and sight only comes once a voice plays
+     * or holds before.
      */
-    reaching(subject, now) {
-        if (this.targeted === 0)
-            return this.voices;
-        const held = this.reach.get(subject);
-        if (held !== undefined && held.version === this.version)
-            return held.voices;
-        const voices = [];
-        for (const voice of this.voices) {
-            if (voice.state === 'done')
+    chain(subject, now) {
+        const was = this.chains.get(subject);
+        if (was !== undefined && was.version === this.version)
+            return was;
+        let first = null;
+        let prev = null;
+        const link = (voice) => {
+            const state = voice.state;
+            if (state === 'done' || (state === 'pending' && !voice.holdsBefore))
+                return;
+            const held = this.held(voice, subject, now);
+            if (!held.reaches)
+                return;
+            held.voice = voice;
+            held.next = null;
+            if (prev === null)
+                first = held;
+            else
+                prev.next = held;
+            prev = held;
+        };
+        const named = this.naming === 0 ? undefined : this.named.get(subject);
+        let j = 0;
+        for (const voice of this.general) {
+            while (named !== undefined && j < named.length && named[j].id < voice.id)
+                link(named[j++]);
+            link(voice);
+        }
+        while (named !== undefined && j < named.length)
+            link(named[j++]);
+        const head = first ?? stub();
+        head.version = this.version;
+        if (was !== undefined && was !== head) {
+            head.loci = was.loci;
+            was.loci = null;
+            head.slot = was.slot;
+            was.slot = -1;
+        }
+        else if (was === undefined && this.lanes !== null && head.slot < 0)
+            head.slot = this.lanes.number(subject);
+        if (was !== head)
+            this.chains.set(subject, head);
+        return head;
+    }
+    /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
+    aims(voice, subject) {
+        // A read back to before a subject left still finds it reached.
+        const left = voice.parted?.get(subject);
+        if (left !== undefined && !(this.now < left))
+            return false;
+        if (voice.named !== null)
+            return voice.named.has(subject);
+        return voice.spec.target ? voice.spec.target(subject) : true;
+    }
+    /**
+     * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
+     * are relinked, every subject's for a voice over all of them and only its own for one naming
+     * its subjects, and lanes take it on or off.
+     */
+    changed(voice) {
+        this.lanes?.touch(voice);
+        if (voice.named === null) {
+            this.version++;
+            return;
+        }
+        for (const subject of voice.named) {
+            const head = this.chains.get(subject);
+            if (head !== undefined)
+                head.version = Number.NaN;
+        }
+        this.relinks++;
+    }
+    /** Files a voice under each subject it names, or among the voices that name none. */
+    index(voice) {
+        if (voice.named === null) {
+            this.general.push(voice);
+            return;
+        }
+        this.naming++;
+        for (const subject of voice.named) {
+            const list = this.named.get(subject);
+            if (list === undefined)
+                this.named.set(subject, [voice]);
+            else
+                list.push(voice);
+        }
+    }
+    unindex(voice) {
+        this.naming--;
+        for (const subject of voice.named) {
+            const list = this.named.get(subject);
+            if (list === undefined)
                 continue;
-            if (voice.state === 'pending' || this.held(voice, subject, now).reaches)
-                voices.push(voice);
+            const i = list.indexOf(voice);
+            if (i >= 0)
+                list.splice(i, 1);
+            if (list.length === 0)
+                this.named.delete(subject);
         }
-        this.reach.set(subject, { version: this.version, voices });
-        return voices;
     }
-    locusBands = new Store();
     /** Voices whose stop 0 is mid-computation, so a fold for one cannot re-enter itself. */
     folding = new Set();
     /** Folds one voice's delta into the pose, its band state kept on the subject's record. */
@@ -762,8 +2347,20 @@ class Mixer {
     }
     folded(subject, out, dry = false, except) {
         const now = this.now;
-        const pose = (out ?? {});
+        const head = Number.isNaN(now) ? null : this.chain(subject, now);
+        // A subject numbered since the frame's fill folds every voice here, laned ones included.
+        const laned = head !== null && this.lanes?.prepare(head.slot, subject, now, this.version) === true;
+        return this.foldWith(subject, out ?? {}, head, laned, dry, except);
+    }
+    /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
+    foldWith(subject, out, head, laned, dry, except) {
+        const now = this.now;
+        const pose = out;
+        const lanes = this.lanes;
+        const skip = laned ? lanes.copies : null;
         for (let i = 0; i < this.names.length; i++) {
+            if (skip?.[i])
+                continue;
             const rest = this.channels[i].rest;
             const key = this.names[i];
             // Never `delete`: it drops a reused out object into dictionary mode for good.
@@ -772,32 +2369,42 @@ class Mixer {
             else if (pose[key] !== undefined)
                 pose[key] = undefined;
         }
-        if (Number.isNaN(now))
+        if (head === null)
             return pose;
-        const voices = this.reaching(subject, now);
+        if (laned) {
+            lanes.copy(head.slot, pose);
+            if (lanes.whole)
+                return pose;
+        }
         if (this.loci === 0) {
-            for (const voice of voices) {
-                if (voice.id === except)
+            for (let held = head; held !== null; held = held.next) {
+                const voice = held.voice;
+                if (voice === null || (laned && voice.laned))
                     continue;
-                const delta = this.read(voice, subject, now, dry);
+                if (voice.id === except || voice.state === 'done')
+                    continue;
+                const delta = this.read(voice, subject, now, dry, held);
                 if (delta === null || this.w <= 0)
                     continue;
-                this.apply(pose, voice, this.h, delta, this.w);
+                this.apply(pose, voice, held, delta, this.w);
             }
             return pose;
         }
         const order = [];
         const weights = [];
         const loci = new Map();
-        for (const voice of voices) {
-            if (voice.id === except)
+        for (let held = head; held !== null; held = held.next) {
+            const voice = held.voice;
+            if (voice === null || (laned && voice.laned))
+                continue;
+            if (voice.id === except || voice.state === 'done')
                 continue;
-            const delta = this.read(voice, subject, now, dry);
+            const delta = this.read(voice, subject, now, dry, held);
             if (delta === null)
                 continue;
             const locus = voice.spec.locus;
             if (locus === undefined) {
-                order.push({ voice, held: this.h, delta });
+                order.push({ voice, held, delta });
                 weights.push(this.w);
                 continue;
             }
@@ -810,10 +2417,10 @@ class Mixer {
                 weights.push(0);
             }
         }
-        let bands = this.locusBands.get(subject);
-        if (bands === undefined) {
+        let bands = head.loci;
+        if (bands === null) {
             bands = new Map();
-            this.locusBands.set(subject, bands);
+            head.loci = bands;
         }
         for (let n = 0; n < order.length; n++) {
             const at = order[n];
@@ -847,10 +2454,9 @@ class Mixer {
         return pose;
     }
     /** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
-    read(voice, subject, now, dry) {
+    read(voice, subject, now, dry, held) {
         if (dry) {
-            const held = voice.subjects.get(subject);
-            if (held?.reaches && held.probed === now && held.delta) {
+            if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
                 const setting = voice.setting;
                 setting.timestamp = now;
                 setting.dt = 0;
@@ -860,21 +2466,23 @@ class Mixer {
                 setting.state = held.state;
                 setting.keep = held.keep;
                 this.w = this.weigh(voice, subject, now, held);
-                this.h = held;
+                held.weight = this.w;
+                if (voice.holder !== held && voice.scratch.length > 0)
+                    this.keyed(voice, subject, held);
                 return held.delta;
             }
         }
-        return this.influence(voice, subject, now);
+        return this.influence(voice, subject, now, held);
     }
 }
 /**
- * The one that ships: both forms on the CPU, probed per subject on demand.
+ * The one that ships: every form on the CPU, probed per subject on demand.
  *
  * @category engine
  */
 export const mixer = {
     name: 'mixer',
-    runs: new Set(['fn', 'keys']),
+    runs: new Set(['fn', 'keys', 'motion']),
     create(kit, opts) {
         return new Mixer(kit, opts);
     },