@msb235/blits 0.3.0 → 0.5.0

package/dist/mixer.js

@@ -1,324 +1,29 @@
-import { clampWeight, envelope, passAt, passesOf, phaseAt } from './clock.js';
-import { curve } from './easing.js';
-import { clampRun, Lanes } from './lanes.js';
-import { motionOf, noFrame } from './motion.js';
-import { builtOf, intosOf, readKeys } from './patch.js';
-import { reading } from './reading.js';
+import { blended, blendOf, laneRead, shareKept } from './blend.js';
+import { aims, chain, linkable } from './chain.js';
+import { lerpInto } from './channels.js';
+import { cue } from './cue.js';
+import { beginFade, parting } from './fade.js';
+import { apply, baseFor, clamp, fold, folded, foldLoci, foldWith, influence, isRest, keyed, linked, near, owedBy, passes, read, slopeFor, tick, } from './fold.js';
+import { held, shownOf, sinceOf, unreachedOf } from './held.js';
+import { book, laneHost } from './hosts.js';
+import { Lanes } from './lanes.js';
+import { foldLocus } from './locus.js';
+import { listed } from './marks.js';
+import { move, nextFrame, waits } from './move.js';
+import { ownerPatch } from './owner.js';
+import { Pace } from './pace.js';
+import { pin } from './place.js';
+import { project } from './project.js';
+import { keep, pull } from './pull.js';
+import { Steps } from './relink.js';
 import { Store } from './store.js';
-const none = Object.freeze([]);
-const keeper = (kept) => function keep(owner, init) {
-    if (kept.has(owner))
-        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,
-        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;
-    if (Array.isArray(a) && Array.isArray(b))
-        return a.length === b.length && a.every((v, i) => near(v, b[i]));
-    return a === b;
-};
-const copy = (v) => (Array.isArray(v) ? [...v] : v);
-/** 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;
-    fade;
-    start;
-    state = 'pending';
-    rate;
-    weight;
-    /**
-     * elapsed = anchorElapsed + the rate integrated from anchorNow, rebased on a rate change or a seek.
-     * Without a ramp the rate is constant; with one it moves linearly from `from` to `to` over `over`
-     * mix ms starting at the anchor, and holds `to` after.
-     */
-    anchorNow;
-    anchorElapsed = 0;
-    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;
-    ease;
-    /** How many passes its `loop` plays, worked out once. */
-    passes;
-    /** 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. */
-    seen = 0;
-    /** 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;
-    constructor(id, spec, patch, fade, now, start, slotOf, channels, host, send) {
-        this.id = id;
-        this.spec = spec;
-        this.patch = patch;
-        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.setting = {
-            timestamp: 0,
-            dt: 0,
-            elapsed: 0,
-            pass: 0,
-            weight: 0,
-            state: undefined,
-            host,
-            keep: keeper(new Map()),
-            send,
-        };
-        this.rate = spec.rate ?? 1;
-        this.weight = typeof spec.weight === 'number' ? spec.weight : 1;
-        this.anchorNow = start;
-        this.done = new Promise((r) => {
-            this.resolve = r;
-        });
-        if (now >= start)
-            this.state = 'live';
-    }
-    elapsedAt(now) {
-        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) {
-            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;
-        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;
-        return v;
-    }
-    rateAt(now) {
-        const r = this.ramp;
-        if (r === null)
-            return this.rate;
-        const u = (now - this.anchorNow) / r.over;
-        return u >= 1 ? r.to : u <= 0 ? r.from : r.from + (r.to - r.from) * u;
-    }
-    /** Moves the anchor to `now`, carrying what is left of a ramp. */
-    rebase(now) {
-        const rate = this.rateAt(now);
-        this.anchorElapsed = this.elapsedAt(now);
-        const r = this.ramp;
-        if (r !== null) {
-            const left = this.anchorNow + r.over - now;
-            this.ramp = left > 0 ? { from: rate, to: r.to, over: left } : null;
-        }
-        this.anchorNow = now;
-    }
-}
-class Mixer {
+import { none } from './voice.js';
+import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
+export class Mixer {
     kit;
     opts;
-    voices = [];
+    cued = [];
     /** 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. */
@@ -333,24 +38,59 @@ class Mixer {
      */
     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.
+     * Marks the host announced on a score: `at` in host time, so the mix's rate never moves one, and
+     * NaN until the next sync for one announced as now before any sync; `made` is the mix time 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;
-    /** The mix clock: the host's timestamp less every gap `rebase` has taken out. */
+    /**
+     * The mix clock: host time at the mix's rate. Host time is the host's timestamp less every gap
+     * `rebase` has taken out, `u` at the last sync.
+     */
     now = Number.NaN;
+    u = Number.NaN;
+    /** This mix's frame among every mix's: moved by a sync, and by a control change or drop within one. */
+    frame = nextFrame();
     offset = 0;
+    /** The mix's own rate; null while it has never been set, when mix time is host time. */
+    pace = null;
+    /** Pending voices whose start the host gave, by its host time, kept where the rate puts it. */
+    pins = null;
     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, in the order they retired. */
+    retired = [];
+    /** 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;
+    /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
+    stirs = 0;
+    /** Records a change to the mix's voices or controls. */
+    stir() {
+        this.stirred = true;
+        this.stirs++;
+    }
     /**
      * 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
@@ -358,14 +98,28 @@ class Mixer {
      */
     chains = new Store();
     version = 0;
+    steps = new Steps();
     /** 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;
+    /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
+    owner = null;
     /** 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. */
@@ -392,18 +146,29 @@ class Mixer {
     channels;
     /** Slots of the channels that declare bounds, clamped after every fold. */
     bounded;
+    /** By slot, a stock array channel's in-place `lerp`. */
+    lerpsInto;
+    /** What a fold with a locus in play gathers into, one per depth of folds under way. */
+    locusScratch = [];
+    locusDepth = 0;
     slotOf = new Map();
     lanes;
+    handles = null;
+    /** What `book` made, still booking; null while there is none. */
+    bookers = null;
+    /** Every owner still in the mix, null until one is cued. */
+    owners = null;
     constructor(kit, opts) {
         this.kit = kit;
         this.opts = opts;
         this.names = Object.keys(kit);
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
+        this.lerpsInto = this.channels.map((c) => lerpInto(c));
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = opts.lanes === false ? null : new Lanes(this.laneHost());
+        this.lanes = opts.lanes === false ? null : new Lanes(laneHost(this));
     }
     get reduced() {
         const r = this.opts.reduce;
@@ -413,336 +178,71 @@ class Mixer {
         return this.opts.band ?? { on: 0.6, off: 0.4 };
     }
     cue(spec) {
-        const patch = spec.patch;
         const engine = this.opts.engine ?? mixer;
-        if (!engine.runs.has(patch.form))
-            throw new Error(`blits: engine ${engine.name} does not run ${patch.form} patches`);
-        for (const channel of patch.writes) {
-            if (!(channel in this.kit))
-                throw new Error(`blits: kit has no channel ${String(channel)}, which this patch writes`);
-            const wanted = patch.kit?.[channel];
-            const here = this.kit[channel];
-            if (wanted && wanted !== here && (wanted.kind === undefined || wanted.kind !== here.kind))
-                throw new Error(`blits: channel ${String(channel)} is ${here.kind ?? 'a custom channel'} in this kit, but the patch was written for ${wanted.kind ?? 'a custom channel'}`);
-        }
-        if (patch.reads) {
-            const host = this.opts.host;
-            for (const field of patch.reads)
-                if (typeof host !== 'object' || host === null || !(field in host))
-                    throw new Error(`blits: the patch reads host.${field}, which this mix's host lacks`);
-        }
-        if (spec.from === 'current' && patch.form !== 'keys')
-            throw new Error("blits: from: 'current' needs a keys patch");
-        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.placing = anchored;
-        const motion = motionOf(patch);
-        if (motion !== undefined) {
-            voice.frame = Mixer.frameHook(new WeakRef(this), new WeakRef(voice));
-            motion.frame = voice.frame;
-        }
-        this.voices.push(voice);
-        this.index(voice);
-        this.version++;
-        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.version++;
-            }
-        }
-        // 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);
-        }
-        return this.handle(voice);
+        if (!engine.runs.has(spec.patch.form))
+            throw new Error(`blits: engine ${engine.name} does not run ${spec.patch.form} patches`);
+        return cue(this, spec);
     }
     blend(patches, by, spec = {}) {
         const locus = `blend:${this.nextId}`;
-        const stops = patches.length - 1;
+        const of = blendOf(by, patches.length - 1);
         return patches.map((patch, i) => {
-            const share = (subject, setting) => {
-                const k = by(subject, setting);
-                const d = stops === 0 ? 0 : Math.abs(k * stops - i);
-                return d >= 1 ? 0 : 1 - d;
-            };
-            const weight = by.input ? Object.assign(share, { input: true }) : share;
-            return this.cue({ ...spec, patch, weight, locus });
+            const handle = this.cue({ ...spec, patch, weight: by, locus });
+            const voice = this.cued[this.cued.length - 1];
+            voice.blend = { of, i };
+            of.members.push(voice);
+            return handle;
         });
     }
+    owns(spec) {
+        if (spec.loop !== undefined)
+            throw new Error('blits: an owner does not loop: a pass would have to restart its children');
+        return this.cue({ ...spec, patch: ownerPatch });
+    }
     sync(timestamp) {
         if (this.rebasing && !Number.isNaN(this.last))
             this.offset += timestamp - this.last;
         this.rebasing = false;
         this.last = timestamp;
-        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;
+        const u = timestamp - this.offset;
+        const pace = this.pace;
+        const now = pace === null ? u : pace.sync(u);
+        const later = u !== this.u;
+        const still = later && now === this.now;
+        this.u = u;
+        // Host time moving while the mix clock stands still lands what waits on host time or the host.
+        if (now !== this.now || (later && pace !== null && waits(this)))
+            move(this, now);
+        // It is a frame too, which asks every weight signal again, so one reading input follows it.
+        if (still) {
+            this.frame = nextFrame();
+            this.lanes?.refill();
         }
+        const bookers = this.bookers;
+        if (bookers !== null)
+            for (const b of bookers)
+                b.sync();
     }
-    moveTo(now) {
-        this.now = now;
-        this.reducedNow = this.reduced;
-        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);
-        }
-        for (const voice of this.voices) {
-            if (voice.state === 'done')
-                continue;
-            if (voice.state === 'live' && voice.outAt <= now)
-                this.beginFade(voice, {}, Math.max(voice.start, voice.outAt));
-            if (voice.state === 'pending' && now >= voice.start) {
-                voice.state = 'live';
-                this.version++;
-            }
-            const period = voice.patch.period;
-            const passes = voice.passes;
-            if (voice.state === 'live' && period > 0 && Number.isFinite(passes)) {
-                const end = period * passes + voice.latest;
-                // 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.elapsedAt(now) >= end)
-                    this.beginFade(voice, {}, Math.max(voice.start, Math.min(now, voice.timeAt(end))));
-            }
-            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)
-                        this.retire(voice, at + deadline);
-                    else if (settled)
-                        this.retire(voice);
-                }
-                else if (spent >= over)
-                    this.retire(voice, at + over);
-            }
-        }
-        let pruned = false;
-        for (let i = this.voices.length - 1; i >= 0; i--) {
-            const voice = this.voices[i];
-            if (voice.state === 'done') {
-                this.voices.splice(i, 1);
-                if (this.opts.history)
-                    this.gone.push(voice);
-                this.version++;
-                if (voice.named === null)
-                    pruned = true;
-                else
-                    this.unindex(voice);
-                if (voice.spec.locus !== undefined)
-                    this.loci--;
-                if (voice.spec.anchor !== undefined)
-                    this.anchored--;
-            }
-        }
-        if (pruned)
-            this.general = this.general.filter((v) => v.state !== 'done');
-        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);
-        }
+    book(opts) {
+        return book(this, opts);
     }
     probe(subject, out) {
         const pose = this.fold(subject, out);
         this.keep(subject, pose, out);
+        // Where the lanes answer `atRest` from their own values, there is nothing to keep.
+        if (this.restStamps !== null && !(this.linkedLaned && this.restsLaned()))
+            this.restStamps.set(subject, 2 * this.restsKey() + (this.rests(pose) ? 1 : 0));
         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;
-        if (out === undefined)
-            kept = pose;
-        else if (this.wantsPose) {
-            kept = {};
-            for (const key of this.names) {
-                const v = pose[key];
-                if (v !== undefined)
-                    kept[key] = copy(v);
-            }
-        }
-        if (kept !== undefined) {
-            const rec = this.pose.get(subject);
-            if (rec === undefined)
-                this.pose.set(subject, { pose: kept, at: this.now, prev: undefined, prevAt: Number.NaN });
-            else if (rec.at === this.now)
-                rec.pose = kept;
-            else {
-                rec.prev = rec.pose;
-                rec.prevAt = rec.at;
-                rec.pose = kept;
-                rec.at = this.now;
-            }
-        }
-    }
     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;
-            }
-        }
-        let n = 0;
-        for (const subject of subjects) {
-            if (n >= room)
-                throw new RangeError(`blits: pull's array for ${tightest} has room for ${room} subjects, and was given more`);
-            const head = Number.isNaN(now) ? null : this.chain(subject, now);
-            const laned = head !== null && lanes?.prepare(head.slot, subject, now, this.version) === true;
-            if (laned && lanes.whole && !this.wantsPose) {
-                lanes.write(head.slot, columns, n);
-            }
-            else {
-                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);
-            }
-            n++;
-        }
-    }
-    /** 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;
+        pull(this, subjects, into);
     }
     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' : '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);
-            }),
-        };
+        return project(this, c, timestamp);
     }
     announce(name, opts = {}) {
-        const at = opts.at !== undefined ? opts.at - this.offset : this.now;
+        const at = opts.at !== undefined ? opts.at - this.offset : this.u;
         this.announced.push({
             name,
             score: opts.score,
@@ -753,41 +253,28 @@ class Mixer {
         });
     }
     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);
+        return listed(this, from, to).map(({ order: _, ...m }) => m);
     }
     atRest(subject) {
-        const pose = this.fold(subject, undefined, true);
+        this.restStamps ??= new Store();
+        const head = this.linked(subject);
+        const laned = this.linkedLaned;
+        const lanes = this.lanes;
+        // Every voice on lanes and nothing to clamp: the pose a fold would make is the lanes' values.
+        if (laned && this.restsLaned()) {
+            const slot = head.slot;
+            if (!lanes.owes(slot))
+                return lanes.rests(slot);
+        }
+        // A probe this frame answers for the pose it gave the host.
+        const since = (this.restStamps.get(subject) ?? Number.NaN) - 2 * this.restsKey();
+        if (since >= 0)
+            return since === 1;
+        this.restScratch ??= {};
+        const pose = this.foldWith(subject, this.restScratch, head, laned, true);
+        return this.rests((this.bounded.length === 0 ? pose : this.clamp(pose)));
+    }
+    rests(pose) {
         for (let i = 0; i < this.names.length; i++) {
             const channel = this.channels[i];
             const value = pose[this.names[i]];
@@ -803,23 +290,119 @@ class Mixer {
     rebase() {
         this.rebasing = true;
     }
+    voices(tag) {
+        const out = [];
+        for (const voice of this.cued)
+            if (voice.state !== 'done' && (tag === undefined || voice.spec.tags?.includes(tag)))
+                out.push(voice.handle);
+        return out;
+    }
     get live() {
-        return this.voices.some((v) => v.state !== 'done');
+        return this.cued.some((v) => v.state !== 'done');
+    }
+    get inert() {
+        if (this.stirred)
+            return false;
+        // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
+        // that host time may yet reach.
+        if (this.pace?.stopped(this.u))
+            return this.cued.every((v) => v.state === 'done' ||
+                (v.state !== 'pending' &&
+                    typeof v.spec.weight !== 'function' &&
+                    v.spec.anchor === undefined));
+        return this.cued.every((v) => this.still(v, this.now));
+    }
+    get rate() {
+        return this.pace === null ? 1 : this.pace.rateAt(this.u);
+    }
+    set rate(r) {
+        this.ramp(r, 0);
+    }
+    ramp(rate, over) {
+        if (!(rate >= 0 && rate < Number.POSITIVE_INFINITY))
+            throw new RangeError(`blits: a mix's rate is a finite number, 0 or more, not ${rate}`);
+        if (this.pace === null) {
+            this.pace = new Pace(this.opts.history !== undefined);
+            // Until now mix time was host time, so a pending voice's start is the host time it was given.
+            for (const v of this.cued)
+                if (v.state === 'pending' && !v.placing && v.owner === null && v.spec.start !== undefined)
+                    pin(this, v, v.start);
+        }
+        const history = this.opts.history;
+        const reach = history === undefined ? Number.NEGATIVE_INFINITY : this.now - history.ms;
+        this.pace.change(this.u, rate, over, reach);
+        this.stir();
+    }
+    /** 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' || voice.holding !== null)
+            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 });
+        for (const voice of this.cued)
+            beginFade(this, voice, { over: opts?.over });
     }
     drop(subject) {
+        this.frame = nextFrame();
         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.restStamps?.delete(subject);
         this.chains.delete(subject);
-        for (const voice of [...this.voices, ...this.gone]) {
+        this.stir();
+        // 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);
-            motionOf(voice.patch)?.release(subject);
-        }
+            voice.motion?.release(subject);
+            voice.parts?.delete(subject);
+            voice.parted?.delete(subject);
+            voice.blend?.of.reads.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);
+        if (this.owners !== null)
+            for (const voice of this.owners)
+                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);
     }
     drain(tag) {
         const all = this.sent;
@@ -837,1138 +420,83 @@ 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)),
-            envelope: (voice, since) => mix.envelope(voice, mix.now, since),
-            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 (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 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;
-        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;
-    }
-    /** 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 {
-            const period = voice.patch.period;
-            const passes = voice.passes;
-            if (period > 0 && Number.isFinite(passes)) {
-                const t = voice.timeAt(period * passes + 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) {
-        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,
-            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 {
-            id: voice.id,
-            get state() {
-                return voice.state;
-            },
-            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);
-            },
-            set rate(r) {
-                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;
-                voice.rebase(now);
-                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 ?? {});
-            },
-            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, 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.version++;
-        voice.state = 'fading';
-        voice.out = {
-            from: 1,
-            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, voice.out.at);
-    }
-    /** Removes a voice, recording that it left at `at`, default now. */
-    retire(voice, at) {
-        this.lanes?.invalidate();
-        const motion = motionOf(voice.patch);
-        if (motion !== undefined && motion.frame === voice.frame)
-            motion.frame = noFrame;
-        voice.frame = null;
-        voice.state = 'done';
-        voice.doneAt = at ?? (Number.isNaN(this.now) ? Number.NEGATIVE_INFINITY : this.now);
-        voice.resolve();
-    }
-    /** The ramp a voice's own fade envelope applies this frame, 0..1. */
-    envelope(voice, now, since) {
-        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 = 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 kept = new Map();
-        held = {
-            reaches,
-            delay,
-            since,
-            weight: 0,
-            rested: false,
-            bands: new Uint8Array(voice.slots.length),
-            state: reaches && voice.patch.state
-                ? voice.patch.state(subject)
-                : undefined,
-            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 (reaches)
-            voice.seen++;
-        if (delay > voice.latest)
-            voice.latest = delay;
-        return held;
-    }
-    /** 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;
-        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);
-        }
-        return clampWeight(base * this.envelope(voice, now, held.since));
-    }
-    /**
-     * 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, 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 phase = phaseAt(elapsed, period, voice.passes);
-        const pass = passAt(elapsed, period, voice.passes);
-        this.prime(voice, held, now, elapsed, pass);
-        const setting = voice.setting;
-        const weight = this.weigh(voice, subject, now, held);
-        setting.weight = weight;
-        held.weight = weight;
-        if (held.probed === now && held.delta && held.seeks === voice.seeks) {
-            if (voice.holder !== held && voice.scratch.length > 0)
-                this.keyed(voice, subject, held);
-            this.w = weight;
-            return held.delta;
-        }
-        const keptBefore = reading.kept;
-        const history = this.opts.history;
-        if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
-            this.recordHost(now);
-        reading.horizon = this.horizonFor(voice, held.delay, now);
-        const tick = this.opts.stepMs;
-        if (voice.patch.step && held.probed !== now) {
-            if (tick !== undefined && tick > 0 && !this.reducedNow)
-                this.tick(voice, subject, held, tick);
-            else if (now !== held.stepped) {
-                voice.patch.step(held.state, setting.dt, subject, setting);
-                held.stepped = now;
-            }
-        }
-        let delta;
-        if (voice.built) {
-            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;
-            voice.restedCount++;
-            return null;
-        }
-        this.w = weight;
-        return delta;
-    }
-    /** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
-    keyed(voice, subject, held) {
-        let base;
-        if (voice.spec.from === 'current') {
-            if (held.base === undefined) {
-                held.base = this.baseFor(voice, subject);
-                held.slope = this.slopeFor(voice, subject);
-            }
-            base = held.base;
-        }
-        const delta = readKeys(voice.built, held.phase, held.delta ?? {}, base, voice.lerps, held.slope, voice.intos, voice.scratch);
-        held.delta = delta;
-        if (voice.scratch.length > 0)
-            voice.holder = held;
-        return delta;
-    }
-    /**
-     * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
-     * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
-     * rather than adding keeps the grid where it is however many samples it is reached through.
-     */
-    tick(voice, subject, held, tick) {
-        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 cap = this.opts.maxDt;
-        if (cap !== undefined) {
-            const most = Math.floor(cap / tick);
-            if (due - n > most)
-                n = due - most;
-        }
-        const step = voice.patch.step;
-        setting.dt = tick;
-        for (n++; n <= due; n++) {
-            setting.timestamp = held.since + n * tick;
-            step(held.state, tick, subject, setting);
-        }
-        held.ticks = due > held.ticks ? due : held.ticks;
-        held.stepped = held.since + held.ticks * tick;
-        setting.timestamp = now;
-        setting.dt = frameDt;
-    }
-    /**
-     * Stop 0 for a retargeting voice: the subject's pose in the frame before this voice contributes.
-     * With no such frame on record — a voice cued before the subject was ever probed, or a host that
-     * samples into its own object — it is this frame's pose with every other voice folded in.
-     */
-    baseFor(voice, subject) {
-        let prior = this.pose.get(subject)?.pose;
-        if (prior === undefined && !this.folding.has(voice.id)) {
-            this.folding.add(voice.id);
-            try {
-                prior = this.fold(subject, undefined, false, voice.id);
-            }
-            finally {
-                this.folding.delete(voice.id);
-            }
-        }
-        const base = {};
-        for (const key of voice.patch.writes) {
-            const channel = this.kit[key];
-            const value = prior?.[key];
-            const fallback = channel.rest;
-            if (value !== undefined)
-                base[key] = copy(value);
-            else if (fallback !== undefined)
-                base[key] = copy(fallback);
-        }
-        return base;
-    }
-    /**
-     * How fast each numeric channel this voice writes was moving, from the subject's last two probed
-     * poses, in units per ms. Undefined with fewer than two on record, which starts the voice at rest.
-     */
-    slopeFor(voice, subject) {
-        const rec = this.pose.get(subject);
-        if (rec?.prev === undefined || !(rec.at > rec.prevAt))
-            return undefined;
-        const dt = rec.at - rec.prevAt;
-        const now = rec.pose;
-        const before = rec.prev;
-        const slope = {};
-        for (const key of voice.patch.writes) {
-            const a = before[key];
-            const b = now[key];
-            if (typeof a === 'number' && typeof b === 'number')
-                slope[key] = (b - a) / dt;
-            else if (Array.isArray(a) && Array.isArray(b) && a.length === b.length)
-                slope[key] = b.map((v, i) => (v - a[i]) / dt);
-        }
-        return slope;
-    }
-    isRest(delta) {
-        for (const key of Object.keys(delta)) {
-            if (delta[key] === undefined)
-                continue;
-            const channel = this.kit[key];
-            if (channel.rest === undefined)
-                return false;
-            if (!near(delta[key], channel.rest))
-                return false;
-        }
-        return true;
-    }
-    /** Folds a locus's members into one influence through each channel's own `lerp`. */
-    foldLocus(members) {
-        let sum = 0;
-        for (const m of members)
-            sum += m.weight;
-        const delta = {};
-        if (sum <= 0)
-            return { delta, weight: 0 };
-        const taken = new Map();
-        for (const member of members) {
-            if (member.weight <= 0)
-                continue;
-            for (const key of Object.keys(member.delta)) {
-                if (member.delta[key] === undefined)
-                    continue;
-                const channel = this.kit[key];
-                const held = taken.get(key);
-                if (held === undefined) {
-                    delta[key] = copy(member.delta[key]);
-                    taken.set(key, member.weight);
-                    continue;
-                }
-                const total = held + member.weight;
-                delta[key] = channel.lerp(delta[key], member.delta[key], member.weight / total);
-                taken.set(key, total);
-            }
-        }
-        return { delta, weight: sum > 1 ? 1 : sum };
-    }
-    /** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
-    passes(was, w) {
-        const { on, off } = this.band;
-        return w >= on ? true : w <= off ? false : (was ?? w >= on);
-    }
-    /**
-     * 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.
-     */
-    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) => {
-            if (voice.state !== 'live' && voice.state !== 'fading')
-                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) {
-        if (voice.named !== null)
-            return voice.named.has(subject);
-        return voice.spec.target ? voice.spec.target(subject) : true;
-    }
-    /** 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;
-            const i = list.indexOf(voice);
-            if (i >= 0)
-                list.splice(i, 1);
-            if (list.length === 0)
-                this.named.delete(subject);
-        }
-    }
     /** 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. */
-    apply(pose, voice, held, delta, weight) {
-        const slots = voice.slots;
-        for (let i = 0; i < slots.length; i++) {
-            const slot = slots[i];
-            const key = this.names[slot];
-            const value = delta[key];
-            if (value === undefined)
-                continue;
-            const channel = this.channels[slot];
-            if (channel.rest !== undefined && channel.scale) {
-                // pose[key] is the copy of rest this fold made, so it is ours to write into.
-                pose[key] = channel.fold
-                    ? channel.fold(pose[key], value, weight)
-                    : channel.merge(pose[key], channel.scale(value, weight));
-                continue;
-            }
-            const band = held.bands[i];
-            const on = this.passes(band === 0 ? undefined : band === 1, weight);
-            held.bands[i] = on ? 1 : 2;
-            if (on)
-                pose[key] = pose[key] === undefined ? copy(value) : channel.merge(pose[key], value);
-        }
-    }
-    /** Clamps every bounded channel of a folded pose into its range, in place. */
-    clamp(pose) {
-        for (const slot of this.bounded) {
-            const [lo, hi] = this.channels[slot].bounds;
-            const key = this.names[slot];
-            const v = pose[key];
-            if (typeof v === 'number')
-                pose[key] = v < lo ? lo : v > hi ? hi : v;
-            else if (Array.isArray(v))
-                for (let i = 0; i < v.length; i++) {
-                    const x = v[i];
-                    v[i] = x < lo ? lo : x > hi ? hi : x;
-                }
-        }
-        return pose;
-    }
-    fold(subject, out, dry = false, except) {
-        const pose = this.folded(subject, out, dry, except);
-        return (this.bounded.length === 0 ? pose : this.clamp(pose));
-    }
-    folded(subject, out, dry = false, except) {
-        const now = this.now;
-        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.
-            if (rest !== undefined)
-                pose[key] = copy(rest);
-            else if (pose[key] !== undefined)
-                pose[key] = undefined;
-        }
-        if (head === null)
-            return pose;
-        if (laned) {
-            lanes.copy(head.slot, pose);
-            if (lanes.whole)
-                return pose;
-        }
-        if (this.loci === 0) {
-            for (let held = head; held !== null; held = held.next) {
-                const voice = held.voice;
-                if (voice === null || (laned && voice.laned))
-                    continue;
-                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, held, delta, this.w);
-            }
-            return pose;
-        }
-        const order = [];
-        const weights = [];
-        const loci = new Map();
-        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, held);
-            if (delta === null)
-                continue;
-            const locus = voice.spec.locus;
-            if (locus === undefined) {
-                order.push({ voice, held, delta });
-                weights.push(this.w);
-                continue;
-            }
-            const members = loci.get(locus);
-            if (members)
-                members.push({ delta, weight: this.w });
-            else {
-                loci.set(locus, [{ delta, weight: this.w }]);
-                order.push(locus);
-                weights.push(0);
-            }
-        }
-        let bands = head.loci;
-        if (bands === null) {
-            bands = new Map();
-            head.loci = bands;
-        }
-        for (let n = 0; n < order.length; n++) {
-            const at = order[n];
-            if (typeof at !== 'string') {
-                if (weights[n] > 0)
-                    this.apply(pose, at.voice, at.held, at.delta, weights[n]);
-                continue;
-            }
-            const { delta, weight } = this.foldLocus(loci.get(at));
-            if (weight <= 0)
-                continue;
-            for (const key of Object.keys(delta)) {
-                const channel = this.kit[key];
-                const value = delta[key];
-                if (value === undefined)
-                    continue;
-                if (channel.rest !== undefined && channel.scale) {
-                    // pose[key] is the copy of rest this fold made, so it is ours to write into.
-                    pose[key] = channel.fold
-                        ? channel.fold(pose[key], value, weight)
-                        : channel.merge(pose[key], channel.scale(value, weight));
-                    continue;
-                }
-                const band = `${at}:${key}`;
-                const on = this.passes(bands.get(band), weight);
-                bands.set(band, on);
-                if (on)
-                    pose[key] = pose[key] === undefined ? copy(value) : channel.merge(pose[key], value);
-            }
-        }
-        return pose;
-    }
-    /** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
-    read(voice, subject, now, dry, held) {
-        if (dry) {
-            if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
-                const setting = voice.setting;
-                setting.timestamp = now;
-                setting.dt = 0;
-                setting.elapsed = voice.elapsedAt(now);
-                setting.pass = 0;
-                setting.weight = 0;
-                setting.state = held.state;
-                setting.keep = held.keep;
-                this.w = this.weigh(voice, subject, now, held);
-                held.weight = this.w;
-                if (voice.holder !== held && voice.scratch.length > 0)
-                    this.keyed(voice, subject, held);
-                return held.delta;
-            }
-        }
-        return this.influence(voice, subject, now, held);
+    linkedLaned = false;
+    /**
+     * Per subject, twice `restsKey` at its last probe plus 1 if the pose rested; null until `atRest`
+     * is first asked, when probes start writing it.
+     */
+    restStamps = null;
+    /** What a probe's record of rest is good for: moved by a new frame, version or relink. */
+    restsEpoch = 0;
+    restsFrame = Number.NaN;
+    restsVersion = Number.NaN;
+    restsRelinks = -1;
+    restsStirs = -1;
+    /** The pose `atRest` folds into where no probe this frame answers. */
+    restScratch;
+    restsLaned() {
+        return this.lanes.whole && this.bounded.length === 0;
+    }
+    restsKey() {
+        if (this.frame !== this.restsFrame ||
+            this.version !== this.restsVersion ||
+            this.relinks !== this.restsRelinks ||
+            this.stirs !== this.restsStirs) {
+            this.restsEpoch++;
+            this.restsFrame = this.frame;
+            this.restsVersion = this.version;
+            this.restsRelinks = this.relinks;
+            this.restsStirs = this.stirs;
+        }
+        return this.restsEpoch;
     }
 }
+// The probe's hot path is methods, installed here from the modules that own them: as functions
+// called directly they made probes and fills up to 9% slower (bench/ab.sh on teitou, 2026-10-05).
+const methods = {
+    fold,
+    folded,
+    linked,
+    foldWith,
+    owedBy,
+    foldLoci,
+    read,
+    influence,
+    keyed,
+    tick,
+    apply,
+    clamp,
+    passes,
+    isRest,
+    baseFor,
+    slopeFor,
+    prime,
+    capped,
+    horizonFor,
+    weigh,
+    weighOwned,
+    base,
+    envelope: fadeOf,
+    ownedBy,
+    ownerBase,
+    blended,
+    laneRead,
+    shareKept,
+    parting,
+    chain,
+    linkable,
+    aims,
+    held,
+    unreachedOf,
+    sinceOf,
+    shownOf,
+    keep,
+    foldLocus,
+};
+for (const [name, value] of Object.entries(methods))
+    Object.defineProperty(Mixer.prototype, name, { value, writable: true, configurable: true });
 /**
  * The one that ships: every form on the CPU, probed per subject on demand.
  *