@msb235/blits 0.0.0-stage → 0.1.0

package/dist/mixer.js

@@ -0,0 +1,788 @@
+import { curve } from './easing.js';
+import { builtOf, readKeys } from './patch.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);
+    return made;
+};
+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);
+class Voice {
+    id;
+    spec;
+    patch;
+    fade;
+    start;
+    state = 'pending';
+    rate;
+    weight;
+    /** elapsed = anchorElapsed + (now − anchorNow) · rate, rebased on a rate change or a seek. */
+    anchorNow;
+    anchorElapsed = 0;
+    out = null;
+    subjects = new Store();
+    /** Kit slot of each channel the patch writes, in `writes` order. */
+    slots;
+    /** The stops built ahead of time, for a `keys` patch. */
+    built;
+    ease;
+    /** 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;
+    resolve;
+    done;
+    constructor(id, spec, patch, fade, now, start, slotOf, 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.built = patch.form === 'keys' && patch.keys ? builtOf(patch) : null;
+        this.ease = fade.ease === undefined ? undefined : curve(fade.ease);
+        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 this.anchorElapsed + (now - this.anchorNow) * this.rate;
+    }
+    rebase(now) {
+        this.anchorElapsed = this.elapsedAt(now);
+        this.anchorNow = now;
+    }
+}
+class Mixer {
+    kit;
+    opts;
+    voices = [];
+    pose = new Store();
+    nextId = 1;
+    /** The mix clock: the host's timestamp less every gap `rebase` has taken out. */
+    now = Number.NaN;
+    offset = 0;
+    last = Number.NaN;
+    rebasing = false;
+    wantsPose = false;
+    /** Read once a sync, so a `reduce` function is not called per voice per subject. */
+    reducedNow = false;
+    /**
+     * Per subject, the voices that may reach it, in voice order, so a probe walks those rather than
+     * every voice: a voice targeted at one subject is asked about that subject alone. Rebuilt when
+     * `version` moves, which is whenever the list or a voice's pending state changes.
+     */
+    reach = new Store();
+    version = 0;
+    /** How many voices in the list carry a `target`; with none, every voice reaches every subject. */
+    targeted = 0;
+    /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
+    loci = 0;
+    /** Events sent since the last drain, and who is being probed, so `send` knows whose they are. */
+    sent = [];
+    sending = {
+        voice: null,
+        subject: undefined,
+    };
+    send = (event) => {
+        const { voice, subject } = this.sending;
+        if (voice === null)
+            return;
+        this.sent.push({
+            timestamp: voice.setting.timestamp,
+            subject,
+            voice: voice.id,
+            tags: voice.spec.tags ?? none,
+            event,
+        });
+    };
+    /** What `influence` and `peek` found besides the delta, read by the caller at once. */
+    w = 0;
+    h = null;
+    names;
+    channels;
+    slotOf = new Map();
+    constructor(kit, opts) {
+        this.kit = kit;
+        this.opts = opts;
+        this.names = Object.keys(kit);
+        this.channels = this.names.map((k) => kit[k]);
+        this.names.forEach((k, i) => {
+            this.slotOf.set(k, i);
+        });
+    }
+    get reduced() {
+        const r = this.opts.reduce;
+        return typeof r === 'function' ? r() : r === true;
+    }
+    get band() {
+        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");
+        const start = 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.opts.host, this.send);
+        this.voices.push(voice);
+        this.version++;
+        if (spec.target !== undefined)
+            this.targeted++;
+        if (spec.locus !== undefined)
+            this.loci++;
+        if (spec.from === 'current')
+            this.wantsPose = true;
+        return this.handle(voice);
+    }
+    blend(patches, by, spec = {}) {
+        const locus = `blend:${this.nextId}`;
+        const stops = 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 });
+        });
+    }
+    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.now = now;
+        this.reducedNow = this.reduced;
+        for (const voice of this.voices) {
+            if (voice.state === 'done')
+                continue;
+            if (voice.state === 'pending' && now >= voice.start) {
+                voice.state = 'live';
+                this.version++;
+            }
+            const period = voice.patch.period;
+            const loop = voice.spec.loop ?? true;
+            const passes = loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : loop;
+            if (voice.state === 'live' && period > 0 && Number.isFinite(passes)) {
+                if (voice.elapsedAt(now) >= period * passes + voice.latest)
+                    this.beginFade(voice, {});
+            }
+            if (voice.state === 'fading' && voice.out) {
+                const { at, over, rest, deadline } = voice.out;
+                const spent = now - at;
+                if (rest) {
+                    const out = deadline !== undefined && spent >= deadline;
+                    const settled = voice.seen > 0 && voice.restedCount >= voice.seen;
+                    if (out || settled)
+                        this.retire(voice);
+                }
+                else if (spent >= over)
+                    this.retire(voice);
+            }
+        }
+        for (let i = this.voices.length - 1; i >= 0; i--) {
+            const voice = this.voices[i];
+            if (voice.state === 'done') {
+                this.voices.splice(i, 1);
+                this.version++;
+                if (voice.spec.target !== undefined)
+                    this.targeted--;
+                if (voice.spec.locus !== undefined)
+                    this.loci--;
+            }
+        }
+    }
+    probe(subject, out) {
+        const pose = this.fold(subject, 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.
+        if (out === undefined)
+            this.pose.set(subject, pose);
+        else if (this.wantsPose) {
+            const kept = {};
+            for (const key of this.names) {
+                const v = pose[key];
+                if (v !== undefined)
+                    kept[key] = copy(v);
+            }
+            this.pose.set(subject, kept);
+        }
+        return pose;
+    }
+    atRest(subject) {
+        const pose = this.fold(subject, undefined, true);
+        for (let i = 0; i < this.names.length; i++) {
+            const channel = this.channels[i];
+            const value = pose[this.names[i]];
+            if (channel.rest === undefined) {
+                if (value !== undefined)
+                    return false;
+            }
+            else if (!near(value, channel.rest))
+                return false;
+        }
+        return true;
+    }
+    rebase() {
+        this.rebasing = true;
+    }
+    get live() {
+        return this.voices.some((v) => v.state !== 'done');
+    }
+    mute(opts) {
+        for (const voice of this.voices)
+            this.beginFade(voice, { over: opts?.over });
+    }
+    drop(subject) {
+        this.pose.delete(subject);
+        this.reach.delete(subject);
+        for (const voice of this.voices)
+            voice.subjects.delete(subject);
+    }
+    drain(tag) {
+        const all = this.sent;
+        if (all.length === 0)
+            return [];
+        let out = all;
+        if (tag === undefined)
+            this.sent = [];
+        else {
+            out = [];
+            const kept = [];
+            for (const e of all)
+                (e.tags.includes(tag) ? out : kept).push(e);
+            this.sent = kept;
+        }
+        return out.sort((a, b) => a.timestamp - b.timestamp);
+    }
+    // ── internals ──────────────────────────────────────────────────────────────
+    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;
+            },
+            get rate() {
+                return voice.rate;
+            },
+            set rate(r) {
+                voice.rebase(Number.isNaN(mix.now) ? voice.start : mix.now);
+                voice.rate = r;
+            },
+            seek(elapsed) {
+                voice.anchorNow = Number.isNaN(mix.now) ? voice.start : mix.now;
+                voice.anchorElapsed = elapsed;
+            },
+            fade(opts) {
+                mix.beginFade(voice, opts ?? {});
+            },
+            weightOf(subject) {
+                if (voice.state === 'done')
+                    return 0;
+                return voice.subjects.get(subject)?.weight ?? 0;
+            },
+            done: voice.done,
+        };
+    }
+    beginFade(voice, opts) {
+        if (voice.state === 'done' || voice.state === 'fading')
+            return;
+        const over = this.reduced ? 0 : (opts.over ?? voice.fade.out ?? 0);
+        voice.state = 'fading';
+        voice.out = {
+            from: 1,
+            at: Number.isNaN(this.now) ? voice.start : this.now,
+            over,
+            rest: opts.at === 'rest',
+            deadline: opts.deadline,
+        };
+        if (over === 0 && opts.at !== 'rest')
+            this.retire(voice);
+    }
+    retire(voice) {
+        voice.state = 'done';
+        voice.resolve();
+    }
+    /** The ramp a voice's own fade envelope applies this frame, 0..1. */
+    envelope(voice, now, since) {
+        const reduced = this.reducedNow;
+        const ease = voice.ease;
+        let w = 1;
+        const fadeIn = voice.fade.in ?? 0;
+        if (fadeIn > 0 && !reduced) {
+            const u = (now - since) / fadeIn;
+            if (u < 1)
+                w *= ease ? ease(Math.max(0, u)) : Math.max(0, u);
+        }
+        const out = voice.out;
+        if (out && !out.rest) {
+            if (reduced || out.over === 0)
+                return 0;
+            const u = 1 - (now - out.at) / out.over;
+            const clamped = u < 0 ? 0 : u > 1 ? 1 : u;
+            w *= ease ? ease(clamped) : clamped;
+        }
+        return w;
+    }
+    /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
+    held(voice, subject, now) {
+        let held = voice.subjects.get(subject);
+        if (held !== undefined)
+            return held;
+        const reaches = voice.spec.target ? voice.spec.target(subject) : true;
+        const delay = reaches && voice.spec.stagger ? voice.spec.stagger(subject) : 0;
+        // When the voice clock reads `delay`, from where it is anchored now.
+        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: now,
+            ticks: 0,
+            probed: Number.NaN,
+            delta: null,
+            kept,
+            keep: keeper(kept),
+        };
+        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;
+        const raw = (signal ? signal(subject, voice.setting) : voice.weight) *
+            this.envelope(voice, now, held.since);
+        return raw < 0 ? 0 : raw > 1 ? 1 : raw;
+    }
+    /**
+     * One voice's delta for one subject this frame, or null when it does not reach. Its weight and
+     * the subject's record are left in `w` and `h`.
+     */
+    influence(voice, subject, now) {
+        if (voice.state === 'pending' || voice.state === 'done')
+            return null;
+        const held = this.held(voice, subject, now);
+        held.weight = 0;
+        if (!held.reaches)
+            return null;
+        if (voice.out?.rest && held.rested)
+            return null;
+        const elapsed = voice.elapsedAt(now) - held.delay;
+        if (elapsed < 0)
+            return null;
+        const period = voice.patch.period;
+        const loop = voice.spec.loop ?? true;
+        const passes = loop === true ? Number.POSITIVE_INFINITY : loop === false ? 1 : loop;
+        let phase = 0;
+        let pass = 0;
+        if (period > 0) {
+            const done = Number.isFinite(passes) && elapsed >= period * passes;
+            phase = done ? 1 : (elapsed % period) / period;
+            pass = done ? passes - 1 : Math.floor(elapsed / period);
+        }
+        const setting = voice.setting;
+        setting.timestamp = now;
+        const gap = now - held.stepped;
+        const cap = this.opts.maxDt;
+        setting.dt = this.reducedNow
+            ? Number.POSITIVE_INFINITY
+            : cap !== undefined && gap > cap
+                ? cap
+                : gap;
+        setting.elapsed = elapsed;
+        setting.pass = pass;
+        setting.weight = 0;
+        setting.state = held.state;
+        setting.keep = held.keep;
+        const weight = this.weigh(voice, subject, now, held);
+        setting.weight = weight;
+        held.weight = weight;
+        if (held.probed === now && held.delta) {
+            this.w = weight;
+            this.h = held;
+            return held.delta;
+        }
+        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) {
+            let base;
+            if (voice.spec.from === 'current') {
+                if (held.base === undefined)
+                    held.base = this.baseFor(voice, subject);
+                base = held.base;
+            }
+            delta = readKeys(voice.built, phase, held.delta ?? {}, base);
+        }
+        else {
+            delta = voice.patch.at(phase, subject, setting);
+        }
+        held.delta = delta;
+        held.probed = now;
+        if (voice.out?.rest && this.isRest(delta)) {
+            held.weight = 0;
+            held.rested = true;
+            voice.restedCount++;
+            return null;
+        }
+        this.w = weight;
+        this.h = 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);
+        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;
+    }
+    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 voices that may reach this subject. A live voice is asked once, through the record it keeps
+     * for the subject anyway; a pending one is kept until it goes live, since `target` is asked on
+     * first sight, and sight only comes once a voice plays.
+     */
+    reaching(subject, now) {
+        if (this.targeted === 0)
+            return this.voices;
+        const held = this.reach.get(subject);
+        if (held !== undefined && held.version === this.version)
+            return held.voices;
+        const voices = [];
+        for (const voice of this.voices) {
+            if (voice.state === 'done')
+                continue;
+            if (voice.state === 'pending' || this.held(voice, subject, now).reaches)
+                voices.push(voice);
+        }
+        this.reach.set(subject, { version: this.version, voices });
+        return voices;
+    }
+    locusBands = new Store();
+    /** Voices whose stop 0 is mid-computation, so a fold for one cannot re-enter itself. */
+    folding = new Set();
+    /** Folds one voice's delta into the pose, its band state kept on the subject's record. */
+    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);
+        }
+    }
+    fold(subject, out, dry = false, except) {
+        const now = this.now;
+        const pose = (out ?? {});
+        for (let i = 0; i < this.names.length; i++) {
+            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 (Number.isNaN(now))
+            return pose;
+        const voices = this.reaching(subject, now);
+        if (this.loci === 0) {
+            for (const voice of voices) {
+                if (voice.id === except)
+                    continue;
+                const delta = this.read(voice, subject, now, dry);
+                if (delta === null || this.w <= 0)
+                    continue;
+                this.apply(pose, voice, this.h, delta, this.w);
+            }
+            return pose;
+        }
+        const order = [];
+        const weights = [];
+        const loci = new Map();
+        for (const voice of voices) {
+            if (voice.id === except)
+                continue;
+            const delta = this.read(voice, subject, now, dry);
+            if (delta === null)
+                continue;
+            const locus = voice.spec.locus;
+            if (locus === undefined) {
+                order.push({ voice, held: this.h, 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 = this.locusBands.get(subject);
+        if (bands === undefined) {
+            bands = new Map();
+            this.locusBands.set(subject, 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) {
+        if (dry) {
+            const held = voice.subjects.get(subject);
+            if (held?.reaches && held.probed === now && held.delta) {
+                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);
+                this.h = held;
+                return held.delta;
+            }
+        }
+        return this.influence(voice, subject, now);
+    }
+}
+/**
+ * The one that ships: both forms on the CPU, probed per subject on demand.
+ *
+ * @category engine
+ */
+export const mixer = {
+    name: 'mixer',
+    runs: new Set(['fn', 'keys']),
+    create(kit, opts) {
+        return new Mixer(kit, opts);
+    },
+};
+/**
+ * Makes a mix over a kit, on the engine the options name or the stock one.
+ *
+ * @category mix
+ */
+export function mix(kit, opts = {}) {
+    return (opts.engine ?? mixer).create(kit, opts);
+}