@msb235/blits 0.3.0 → 0.5.0

package/dist/crowd.js

@@ -0,0 +1,354 @@
+import { bareRows, clock, unbare } from './bare.js';
+import { clampWeight, passAt, phaseAt, weighed } from './clock.js';
+import { KeyRows } from './keyrows.js';
+import { held, SPARSE } from './lane.js';
+import { closed } from './motion.js';
+import { move } from './sample.js';
+/**
+ * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
+ * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
+ * write several, and joins the crowd of voices writing those same channels.
+ */
+export function crowdable(v) {
+    return (v.named !== null &&
+        v.named.size === 1 &&
+        v.spec.locus === undefined &&
+        (v.slots.length === 1 || v.motion === undefined));
+}
+/** The law of a row that has none, a keys or fn voice's. */
+export const none = new Float64Array(0);
+/** Whether a row's flags let `bareRows` take it. */
+export function bare(f) {
+    return (f & 2043 /* Bare.MASK */) === 1211 /* Bare.WANT */;
+}
+/**
+ * Every laned voice on one channel that reaches a single subject, a row each, in voice order: the
+ * per-subject numbers a lane keeps, and a copy of what a fill reads of the voice and, for a motion
+ * voice, its patch, so a fill over 100k of them reads a few flat arrays instead of 100k voices,
+ * lanes and patch buffers. Each copy is written when its source changes: the voice's by
+ * `voiceChanged`, the stretch by `stretchChanged`.
+ */
+export class Crowd {
+    chans;
+    axes;
+    /** The subject number at each row. */
+    list = [];
+    /** `STRIDE` numbers per row, laid out as a lane's. */
+    data = new Float64Array(0);
+    hot = new Float64Array(0);
+    stride;
+    samples = new Float64Array(0);
+    deltas = [];
+    records = [];
+    voices = [];
+    motions = [];
+    eases = [];
+    /** Each row's patch law, one array shared by every row whose law is the same. */
+    laws = [];
+    rowOf = new Map();
+    idle = false;
+    line = SPARSE.other;
+    /** Where the fill now under way has reached. */
+    cursor = 0;
+    /** Rows whose voices have left, kept in place until the crowds are next rebuilt. */
+    dead = 0;
+    /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
+    stale = false;
+    xs;
+    vs;
+    /** What a keys row reads into, folded before the next row reads. */
+    delta = {};
+    /** The stops of its `Flag.FLAT` keys rows. */
+    keys = new KeyRows();
+    scratch = [];
+    /** The last fill that ran the crowd's rows, and its `now`, which a `Sampled.BARE` row was sampled at. */
+    bareFill = -1;
+    bareNow = Number.NaN;
+    constructor(chans, axes) {
+        this.chans = chans;
+        this.axes = axes;
+        this.stride = 10 /* Hot.X0 */ + 3 * axes;
+        this.xs = new Float64Array(axes);
+        this.vs = new Float64Array(axes);
+    }
+    voiceAt(p) {
+        return this.voices[p];
+    }
+    fix(p) {
+        unbare(this, p);
+    }
+    numbered() { }
+    /** Marks row `p` to copy its stretch from its patch again before the next fill reads it. */
+    restale(p, flags) {
+        this.hot[p * this.stride + 0 /* Hot.FLAGS */] = flags | 4 /* Flag.STALE */;
+        this.stale = true;
+    }
+    /** Samples of another width than the channel's, which `samples` cannot hold, by row. */
+    odd = null;
+    keep(p, xs, n) {
+        if (n === this.axes) {
+            for (let a = 0; a < n; a++)
+                this.samples[p * n + a] = xs[a];
+            this.odd?.delete(p);
+            return;
+        }
+        this.odd ??= new Map();
+        this.odd.set(p, xs.slice(0, n));
+    }
+    kept(p, xs) {
+        const odd = this.odd?.get(p);
+        if (odd !== undefined) {
+            xs.set(odd);
+            return;
+        }
+        const n = this.axes;
+        for (let a = 0; a < n; a++)
+            xs[a] = this.samples[p * n + a];
+    }
+    motionAt(p) {
+        return this.motions[p];
+    }
+    get size() {
+        return this.list.length;
+    }
+    /** Makes room for `rows` rows. */
+    reserve(rows) {
+        if (rows * 8 /* Row.STRIDE */ <= this.data.length)
+            return;
+        const cap = Math.max(rows, (this.data.length / 8 /* Row.STRIDE */) * 2, 16);
+        const data = new Float64Array(cap * 8 /* Row.STRIDE */);
+        data.set(this.data);
+        this.data = data;
+        const hot = new Float64Array(cap * this.stride);
+        hot.set(this.hot);
+        this.hot = hot;
+        const samples = new Float64Array(cap * this.axes);
+        samples.set(this.samples);
+        this.samples = samples;
+    }
+}
+/** Runs every crowd's rows whose voices come before voice `id`, from where each crowd reached. */
+export function crowdsUpTo(lanes, id) {
+    if (!lanes.overlap) {
+        for (const c of lanes.crowds)
+            if (!c.idle && c.cursor < c.size)
+                runCrowd(lanes, c, id);
+        return;
+    }
+    // Crowds sharing a channel take turns in voice order, so a subject's rows fold as one crowd's do.
+    for (;;) {
+        let first;
+        let a = id;
+        let b = id;
+        for (const c of lanes.crowds) {
+            if (c.idle || c.cursor >= c.size)
+                continue;
+            const next = c.hot[c.cursor * c.stride + 7 /* Hot.ID */];
+            if (next < a) {
+                b = a;
+                a = next;
+                first = c;
+            }
+            else if (next < b)
+                b = next;
+        }
+        if (first === undefined)
+            return;
+        runCrowd(lanes, first, b);
+    }
+}
+/** A crowd's rows from its cursor up to voice `id`, bare tweens in `bareRows` and the rest here. */
+function runCrowd(lanes, c, id) {
+    const list = c.list;
+    const hot = c.hot;
+    let p = c.cursor;
+    for (;;) {
+        p = bareRows(lanes, c, p, id);
+        if (p >= list.length || hot[p * c.stride + 7 /* Hot.ID */] >= id)
+            break;
+        p = rows(lanes, c, p, id);
+    }
+    c.cursor = p;
+}
+/**
+ * A crowd's rows from `p` up to voice `id`, until one `bareRows` takes after the first: what
+ * `runMotion` does for a lane's subjects, reading each row's voice and stretch from `hot`, and
+ * through `move` for whatever `hot` cannot answer, as `runMotion` does. Returns where it stopped.
+ */
+function rows(lanes, c, first, id) {
+    const data = c.data;
+    const hot = c.hot;
+    const H = c.stride;
+    const per = lanes.per;
+    const list = c.list;
+    const ch = c.chans[0];
+    const n = c.axes;
+    const fills = lanes.fills;
+    const from = lanes.frameProbes;
+    const probed = lanes.probes !== from;
+    const now = lanes.now;
+    const xs = c.xs;
+    const vs = c.vs;
+    const samples = c.samples;
+    let p = first;
+    for (; p < list.length; p++) {
+        const h = p * H;
+        if (hot[h + 7 /* Hot.ID */] >= id)
+            break;
+        let f = hot[h + 0 /* Hot.FLAGS */];
+        if (p > first && bare(f))
+            break;
+        if (data[p * 8 /* Row.STRIDE */ + 5 /* Row.SAMPLED */] === -2 /* Sampled.BARE */)
+            unbare(c, p);
+        if ((f & 64 /* Flag.VOICE */) !== 0)
+            f = copyVoice(c, p);
+        if ((f & 1 /* Flag.PLAYING */) === 0 || (f & 16 /* Flag.PLACED */) === 0)
+            continue;
+        const slot = list[p];
+        const o = p * 8 /* Row.STRIDE */;
+        const q = slot * 6 /* Per.SLOT */;
+        if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
+            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        const delay = data[o + 0 /* Row.DELAY */];
+        const fast = (f & 2 /* Flag.FAST */) !== 0;
+        const voice = c.voices[p];
+        const elapsedNow = fast ? clock(hot, h, now) : voice.elapsedAt(now);
+        let elapsed = elapsedNow - delay;
+        if ((f & 256 /* Flag.HOLDS */) !== 0)
+            elapsed = held(voice, elapsed);
+        if (!(elapsed >= 0)) {
+            data[o + 2 /* Row.WEIGHT */] = 0;
+            continue;
+        }
+        let w;
+        if (fast)
+            w = hot[h + 4 /* Hot.WEIGHT */];
+        else if (typeof voice.spec.weight === 'function') {
+            w = lanes.signalled(voice, slot, c.records[p], elapsed, passAt(elapsed, voice.duration, voice.passes), lanes.host.envelope(voice, data[o + 1 /* Row.SINCE */]));
+            if (Number.isNaN(w)) {
+                data[o + 2 /* Row.WEIGHT */] = 0;
+                continue;
+            }
+        }
+        else
+            w = weighed(voice.weight, lanes.host.envelope(voice, data[o + 1 /* Row.SINCE */]), lanes.parting(voice, slot));
+        data[o + 2 /* Row.WEIGHT */] = w;
+        if ((f & 512 /* Flag.FLAT */) !== 0) {
+            if (w > 0)
+                c.keys.fold(hot[h + 8 /* Hot.AT */], phaseAt(elapsed, hot[h + 10 /* Hot.X0 */], hot[h + 9 /* Hot.MS */]), c.chans, slot, w);
+            continue;
+        }
+        if ((f & 128 /* Flag.MOTION */) === 0) {
+            lanes.row(c, p, voice, slot, elapsed, delay, w);
+            continue;
+        }
+        if (data[o + 7 /* Row.MET */] === 0) {
+            if (Number.isNaN(c.records[p].probed)) {
+                lanes.late.push(slot);
+                continue;
+            }
+            data[o + 7 /* Row.MET */] = 1;
+        }
+        const ms = data[o + 4 /* Row.MSLOT */];
+        if (ms < 0 ||
+            (f & 8 /* Flag.BARE */) === 0 ||
+            (probed &&
+                (per[q + 3 /* Per.LANE_PROBE */] > from ||
+                    per[q + 4 /* Per.GENERAL_PROBE */] > from))) {
+            const run = c.motions[p];
+            move(lanes, c, run, p, slot, c.records[p], elapsed, delay, w);
+            // The first sample numbered the subject in the patch: copy its stretch from the next fill.
+            if (ms < 0)
+                c.restale(p, hot[h + 0 /* Hot.FLAGS */]);
+            continue;
+        }
+        closed(c.laws[p], c.eases[p], n, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */], hot, h + 10 /* Hot.X0 */, hot, h + 10 /* Hot.X0 */ + n, hot, h + 10 /* Hot.X0 */ + 2 * n, elapsed, xs, vs);
+        for (let a = 0; a < n; a++)
+            samples[p * n + a] = xs[a];
+        if (c.deltas[p] !== null)
+            c.deltas[p] = null;
+        data[o + 5 /* Row.SAMPLED */] = fills;
+        data[o + 6 /* Row.SEEKS */] = hot[h + 5 /* Hot.SEEKS */];
+        if (w <= 0)
+            continue;
+        if ((f & 32 /* Flag.FOLDS */) !== 0)
+            lanes.foldRun(ch, slot, xs, w);
+        else
+            lanes.foldInto(ch, slot, c.motions[p].value(ms, xs), w);
+    }
+    return p;
+}
+/** A keys or fn row's contribution, as `one` makes a lane position's. */
+export function row(c, p, voice, slot, elapsed, delay, w) {
+    const duration = voice.duration;
+    const phase = phaseAt(elapsed, duration, voice.passes);
+    if (voice.built !== null) {
+        if (w > 0)
+            this.foldKeys(voice, c.chans, phase, slot, w);
+        return;
+    }
+    const rec = c.records[p];
+    if (Number.isNaN(rec.probed)) {
+        this.late.push(slot);
+        return;
+    }
+    this.call(voice, c.chans, rec, slot, elapsed, phase, passAt(elapsed, duration, voice.passes), delay, w);
+}
+/** Copies what a fill reads of a crowd row's voice into `hot`; returns the row's flags. */
+function copyVoice(c, p) {
+    const v = c.voices[p];
+    const h = p * c.stride;
+    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.HOLDS */);
+    if (v.state === 'live' || v.state === 'held' || v.state === 'fading')
+        f |= 1 /* Flag.PLAYING */;
+    if (v.holdsBefore || v.holdsAfter)
+        f |= 256 /* Flag.HOLDS */;
+    if (v.ramp === null &&
+        v.owner === null &&
+        !((v.fade.in ?? 0) > 0) &&
+        v.out === null &&
+        v.parts === null &&
+        !v.keeping &&
+        typeof v.spec.weight !== 'function')
+        f |= 2 /* Flag.FAST */;
+    c.hot[h + 1 /* Hot.NOW */] = v.anchorNow;
+    c.hot[h + 2 /* Hot.ELAPSED */] = v.anchorElapsed;
+    c.hot[h + 3 /* Hot.RATE */] = v.rate;
+    c.hot[h + 4 /* Hot.WEIGHT */] = clampWeight(v.weight);
+    c.hot[h + 5 /* Hot.SEEKS */] = v.seeks;
+    c.hot[h + 0 /* Hot.FLAGS */] = f;
+    return f;
+}
+/**
+ * Copies stale motion rows' stretches as a fill begins: inside `runCrowd`, once voices came and
+ * went, TurboFan spent its inlining on the copy and stopped inlining every row's ease.
+ */
+export function freshen(c) {
+    c.stale = false;
+    const hot = c.hot;
+    const H = c.stride;
+    for (let p = 0; p < c.list.length; p++) {
+        const f = hot[p * H + 0 /* Hot.FLAGS */];
+        if ((f & 4 /* Flag.STALE */) === 0 || (f & 128 /* Flag.MOTION */) === 0)
+            continue;
+        // A row with no stretch yet is marked again once its first sample numbers it.
+        const ms = c.data[p * 8 /* Row.STRIDE */ + 4 /* Row.MSLOT */];
+        if (ms >= 0)
+            copyStretch(c, p, ms);
+    }
+}
+/** Copies a crowd row's current stretch from its patch into `hot`; returns the row's flags. */
+function copyStretch(c, p, ms) {
+    unbare(c, p);
+    const run = c.motions[p];
+    const h = p * c.stride;
+    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(4 /* Flag.STALE */ | 8 /* Flag.BARE */ | 32 /* Flag.FOLDS */);
+    const ch = c.chans[0];
+    if (run.n === c.axes && run.stretchInto(ms, c.hot, h + 8 /* Hot.AT */)) {
+        f |= 8 /* Flag.BARE */;
+        if (run.scalar(ms) === ch.scalar)
+            f |= 32 /* Flag.FOLDS */;
+    }
+    c.hot[h + 0 /* Hot.FLAGS */] = f;
+    return f;
+}

package/dist/cue.d.ts

@@ -0,0 +1,3 @@
+import type { Mixer } from './mixer.js';
+import type { Handle, VoiceSpec } from './types.js';
+export declare function cue<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): Handle<I>;

package/dist/cue.js

@@ -0,0 +1,115 @@
+import { checkHits } from './book.js';
+import { changed, index } from './chain.js';
+import { schedule } from './due.js';
+import { started } from './held.js';
+import { handle } from './hosts.js';
+import { motionOf } from './motion.js';
+import { adopt, ownerReading } from './owner.js';
+import { durationOf } from './patch.js';
+import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
+import { motionOwner } from './strays.js';
+import { Voice } from './voice.js';
+export function cue(mix, spec) {
+    const patch = spec.patch;
+    for (const channel of patch.writes) {
+        if (!(channel in mix.kit))
+            throw new Error(`blits: kit has no channel ${String(channel)}, which this patch writes`);
+        const wanted = patch.kit?.[channel];
+        const here = mix.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'}`);
+    }
+    const motion = motionOf(patch);
+    if (motion !== undefined) {
+        const channel = patch.writes[0];
+        const rest = mix.kit[channel].rest;
+        if (typeof rest === 'number')
+            motion.cuedOn(String(channel), true);
+        else if (Array.isArray(rest) || ArrayBuffer.isView(rest))
+            motion.cuedOn(String(channel), false);
+    }
+    if (patch.reads) {
+        const host = mix.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;
+    const owner = spec.owner === undefined ? null : ownerOf(mix, spec.owner);
+    if (anchor)
+        checkPlacement(mix, spec, anchor, owner);
+    if (spec.hits !== undefined)
+        checkHits(spec.hits, durationOf(patch));
+    const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
+    // A voice an owner holds is placed on the owner's clock: ms from when it starts.
+    const local = owner === null ? mix.now : ownerReading(owner, mix.now);
+    const start = anchored
+        ? Number.POSITIVE_INFINITY
+        : owner !== null
+            ? (spec.start ?? (local > 0 ? local : 0))
+            : spec.start !== undefined
+                ? mixAt(mix, spec.start - mix.offset)
+                : Number.isNaN(mix.now)
+                    ? 0
+                    : mix.now;
+    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? {}, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    if (owner !== null)
+        adopt(owner, voice);
+    if (voice.holding !== null) {
+        mix.owners ??= [];
+        mix.owners.push(voice);
+    }
+    if (!Number.isNaN(mix.now)) {
+        voice.cuedAt = mix.now;
+        voice.opened = mix.now;
+    }
+    voice.placing = anchored;
+    if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
+        pin(mix, voice, spec.start - mix.offset);
+    if (motion !== undefined) {
+        mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
+        mix.owner ??= motionOwner(new WeakRef(mix));
+        motion.owner = mix.owner;
+        motion.ownerId = voice.id;
+    }
+    mix.cued.push(voice);
+    index(mix, voice);
+    changed(mix, voice);
+    mix.stir();
+    if (spec.locus !== undefined)
+        mix.loci++;
+    if (spec.from === 'current')
+        mix.wantsPose = true;
+    if (anchor) {
+        mix.anchored++;
+        place(mix);
+        if (!Number.isNaN(mix.now) &&
+            voice.state === 'pending' &&
+            localNow(mix, voice) >= voice.start) {
+            voice.state = 'live';
+            started(mix, voice);
+            changed(mix, voice);
+        }
+    }
+    // After placing, so the controls it starts with are where its anchors put it at the cue.
+    if (mix.opts.history) {
+        voice.log = [];
+        voice.note(Number.NEGATIVE_INFINITY);
+    }
+    schedule(mix, voice);
+    voice.handle = handle(mix, voice);
+    return voice.handle;
+}
+/** The owner a handle names, refused where it is not one of this mix's or has left. */
+function ownerOf(mix, handle) {
+    const found = mix.owners?.find((v) => v.handle === handle);
+    if (found === undefined)
+        throw new Error('blits: owner is not a handle mix.owns returned on this mix');
+    if (found.state === 'done')
+        throw new Error('blits: that owner has left the mix');
+    return found;
+}

package/dist/due.d.ts

@@ -0,0 +1,12 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/** One entry in a mix's due queue; stale once its voice has been scheduled again. */
+export interface Due<I, O> {
+    at: number;
+    voice: Voice<I, O>;
+    token: number;
+}
+/** Files a voice in the due queue at its current due, replacing any entry it had. */
+export declare function schedule<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Takes every current entry due by `now` off the queue, in cue order. */
+export declare function popDue<I, O>(mix: Mixer<I, O>, now: number): Voice<I, O>[];

package/dist/due.js

@@ -0,0 +1,93 @@
+/**
+ * The earliest mix time `moveTo` would change a voice: its start, its anchored out, the end of
+ * its last pass, the end of its fade or of a subject's ramp out; -Infinity where it must be
+ * visited every frame, Infinity where nothing will happen until a handle or anchor changes it.
+ * Early is safe, since a visit that finds nothing due schedules again; late is not, so anything
+ * that can bring it earlier calls `schedule`.
+ */
+function dueOf(mix, voice) {
+    if (voice.state === 'done')
+        return Number.POSITIVE_INFINITY;
+    // An owner and the voices it holds run on clocks that move with it, so each is visited every frame.
+    if (Number.isNaN(voice.opened) || voice.owner !== null || voice.holding !== null)
+        return Number.NEGATIVE_INFINITY;
+    let due = Number.POSITIVE_INFINITY;
+    if (voice.parts !== null)
+        for (const r of voice.parts.values())
+            due = Math.min(due, r.at + r.over);
+    if (voice.state === 'pending')
+        return Math.min(due, Number.isNaN(voice.start) ? due : voice.start);
+    if (voice.state === 'fading') {
+        const out = voice.out;
+        if (out === null || out.rest)
+            return Number.NEGATIVE_INFINITY;
+        return Math.min(due, out.at + out.over);
+    }
+    due = Math.min(due, voice.outAt);
+    if (Number.isFinite(voice.span)) {
+        const end = voice.span + voice.latest;
+        // A held voice goes live again once its clock is back before its end: by a seek, by a
+        // subject staggered later than any before, or by running backwards, which is checked each
+        // frame while it can.
+        if (voice.state === 'held') {
+            if (voice.rate <= 0 || voice.ramp !== null)
+                return Number.NEGATIVE_INFINITY;
+            if (!Number.isNaN(mix.now) && voice.elapsedAt(mix.now) < end)
+                return Number.NEGATIVE_INFINITY;
+        }
+        if (voice.state === 'live')
+            due = Math.min(due, voice.timeAt(end));
+    }
+    return due;
+}
+/** Files a voice in the due queue at its current due, replacing any entry it had. */
+export function schedule(mix, voice) {
+    if (mix.projecting)
+        return;
+    mix.lanes?.voiceChanged(voice.id);
+    const token = ++voice.dueToken;
+    const due = dueOf(mix, voice);
+    if (due === Number.POSITIVE_INFINITY)
+        return;
+    const heap = mix.due;
+    heap.push({ at: Number.isNaN(due) ? Number.NEGATIVE_INFINITY : due, voice, token });
+    let i = heap.length - 1;
+    while (i > 0) {
+        const up = (i - 1) >> 1;
+        if (heap[up].at <= heap[i].at)
+            break;
+        [heap[up], heap[i]] = [heap[i], heap[up]];
+        i = up;
+    }
+}
+/** Takes every current entry due by `now` off the queue, in cue order. */
+export function popDue(mix, now) {
+    const heap = mix.due;
+    const at = (k) => k < heap.length ? heap[k].at : Number.POSITIVE_INFINITY;
+    const out = [];
+    while (heap.length > 0 && heap[0].at <= now) {
+        const top = heap[0];
+        const last = heap.pop();
+        if (heap.length > 0) {
+            heap[0] = last;
+            let i = 0;
+            for (;;) {
+                const l = 2 * i + 1;
+                const r = l + 1;
+                const m0 = at(l) < at(i) ? l : i;
+                const m = at(r) < at(m0) ? r : m0;
+                if (m === i)
+                    break;
+                [heap[m], heap[i]] = [heap[i], heap[m]];
+                i = m;
+            }
+        }
+        if (top.token === top.voice.dueToken && top.voice.state !== 'done') {
+            top.voice.dueToken++;
+            out.push(top.voice);
+        }
+    }
+    if (out.length > 1)
+        out.sort((a, b) => a.id - b.id);
+    return out;
+}

package/dist/fade.d.ts

@@ -0,0 +1,19 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
+export declare function fadeSubject<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, over?: number): void;
+/** What a subject's own ramp out of a voice leaves of its weight this frame, 0..1. */
+export declare function parting<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number): number;
+/**
+ * Takes a subject out of one voice for good, as of mix time `at`: the voice forgets its record,
+ * its lane position and a motion patch's state for it, and reaches it no more.
+ */
+export declare function part<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, at: number): void;
+/** Brings a subject faded out of a voice back, to be met afresh on its next probe. */
+export declare function unpart<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): void;
+export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, opts: {
+    over?: number;
+    at?: 'rest';
+    deadline?: number;
+}, at?: number): void;
+export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;