@msb235/blits 0.7.1 → 0.8.0

package/dist/closed.js

@@ -1,3 +1,4 @@
+import { same } from './clock.js';
 import { eased, progress } from './tweened.js';
 /** The closed forms a motion patch's law picks between, by its first number. */
 export const UNDER = 0;
@@ -26,7 +27,7 @@ function prepare(law, t) {
     const k2 = law[3];
     const k3 = law[4];
     const p = prepared;
-    if (Object.is(t, p.t) && form === p.form && k1 === p.k1 && k2 === p.k2 && k3 === p.k3)
+    if (same(t, p.t) && form === p.form && k1 === p.k1 && k2 === p.k2 && k3 === p.k3)
         return;
     p.form = form;
     p.k1 = k1;
@@ -114,7 +115,7 @@ function solveGlide(law, y0) {
     solved.dy = (-y0 / tau) * e;
 }
 /**
- * A stretch `t` voice ms into it, released at `at` from `x0` moving at `v0` toward `to` (each read
+ * A stretch at voice time `t`, released at `at` from `x0` moving at `v0` toward `to` (each read
  * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's
  * `[form, settle, k1, k2, k3]`, the head of a patch's buffer or a copy of it) picks between. A tween reads `ease` and
  * `ms`, the stretch's length, dividing in milliseconds so a boundary lands exactly; every other

package/dist/color.d.ts

@@ -6,17 +6,6 @@ import type { Channel } from './types.js';
  * @category channel
  */
 export declare function mixHex(a: number, b: number, u: number): number;
-/**
- * Color, as 0xrrggbb, blended in OKLCH as `mixHex` does, or with `space: 'srgb'` channel by
- * channel in sRGB, which keeps a port's arithmetic identical to a host that blended that way.
- *
- * @deprecated Use `color(last(), { lerp: 'oklch' })`, which replaces as this does, and `toHex` at
- * write. A packed color has no arithmetic to stack with; `color()` averages instead.
- * @category channel
- */
-export declare function hex(opts?: {
-    space?: 'oklch' | 'srgb';
-}): Channel<number>;
 /**
  * How a `color` channel interpolates two colors: straight across OKLab, or in OKLCH with hue the
  * short way round, as `mixHex` does.

package/dist/color.js

@@ -1,4 +1,4 @@
-import { last, lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
+import { lerpNumber, numericOf, sum, vec, vouch, widen } from './channels.js';
 const mix = lerpNumber;
 const LINEAR = Array.from({ length: 256 }, (_, c) => {
     const v = c / 255;
@@ -107,28 +107,6 @@ export function mixHex(a, b, u) {
         turn += 2 * Math.PI;
     return fromOklch(mix(al, slotL[sb], u), mix(ac, bc, u), from + turn * u);
 }
-const clamp255 = (v) => (v < 0 ? 0 : v > 255 ? 255 : Math.round(v));
-/** Each of red, green and blue on its own, as klieg's light channel blends. */
-function mixSrgb(a, b, u) {
-    const ar = (a >> 16) & 0xff;
-    const ag = (a >> 8) & 0xff;
-    const ab = a & 0xff;
-    const br = (b >> 16) & 0xff;
-    const bg = (b >> 8) & 0xff;
-    const bb = b & 0xff;
-    return ((clamp255(mix(ar, br, u)) << 16) | (clamp255(mix(ag, bg, u)) << 8) | clamp255(mix(ab, bb, u)));
-}
-/**
- * Color, as 0xrrggbb, blended in OKLCH as `mixHex` does, or with `space: 'srgb'` channel by
- * channel in sRGB, which keeps a port's arithmetic identical to a host that blended that way.
- *
- * @deprecated Use `color(last(), { lerp: 'oklch' })`, which replaces as this does, and `toHex` at
- * write. A packed color has no arithmetic to stack with; `color()` averages instead.
- * @category channel
- */
-export function hex(opts) {
-    return { ...last({ lerp: opts?.space === 'srgb' ? mixSrgb : mixHex }), kind: 'hex' };
-}
 /** Two OKLab colors with coverage, interpolated in OKLCH: color by `u`, coverage by `u` alongside. */
 function lerpLch(x, y, u) {
     const xw = x[3] ?? 0;
@@ -166,7 +144,9 @@ export function color(ofOrOpts, maybe) {
     const opts = of === undefined ? ofOrOpts : maybe;
     const round = opts?.lerp === 'oklch';
     const space = round ? ', oklch' : '';
-    if (of === undefined || (numericOf(of)?.op === 'sum' && of.bounds === undefined)) {
+    const stock = of === undefined ? undefined : numericOf(of);
+    if (of === undefined ||
+        (stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined)) {
         const channel = vec(4, sum());
         channel.kind = `color(sum${space})`;
         // A lane interpolates a stock channel straight across, so a lerp of its own takes it off them.

package/dist/columns.js

@@ -103,7 +103,6 @@ function queue(lanes, columns, slot, row, count) {
     lanes.queueCounts[k] = count;
     lanes.queued = k + 1;
 }
-/** Makes room in the queue for `runs` runs. */
 function room(lanes, runs) {
     if (runs <= lanes.queueSlots.length)
         return;

package/dist/copyout.d.ts

@@ -0,0 +1,6 @@
+import type { Lanes } from './lanes.js';
+/**
+ * Writes a subject's laned values into a pose, each array channel into the array the pose holds
+ * for it where that is the length a new one would be, as a host's `out` holds from its last probe.
+ */
+export declare function copy<I, O>(this: Lanes<I, O>, slot: number, pose: Record<string, unknown>): void;

package/dist/copyout.js

@@ -0,0 +1,38 @@
+/**
+ * Writes a subject's laned values into a pose, each array channel into the array the pose holds
+ * for it where that is the length a new one would be, as a host's `out` holds from its last probe.
+ */
+export function copy(slot, pose) {
+    const laned = this.laned;
+    for (let c = 0; c < laned.length; c++) {
+        const ch = laned[c];
+        const axes = ch.axes;
+        // Never `delete`: it drops a reused out object into dictionary mode for good.
+        if (ch.op === 'last' && Number.isNaN(ch.values[slot * axes])) {
+            if (pose[ch.name] !== undefined)
+                pose[ch.name] = undefined;
+            continue;
+        }
+        if (ch.scalar) {
+            pose[ch.name] = ch.values[slot];
+            continue;
+        }
+        // Made as the general path makes it, a copy of rest, so poses from either path share a shape.
+        const start = ch.start;
+        const base = slot * axes;
+        const held = pose[ch.name];
+        if (Array.isArray(held) &&
+            held !== start &&
+            held.length === (start.length > axes ? start.length : axes)) {
+            for (let a = 0; a < axes; a++)
+                held[a] = ch.values[base + a];
+            for (let a = axes; a < start.length; a++)
+                held[a] = start[a];
+            continue;
+        }
+        const arr = [...start];
+        for (let a = 0; a < axes; a++)
+            arr[a] = ch.values[base + a];
+        pose[ch.name] = arr;
+    }
+}

package/dist/crowd.d.ts

@@ -57,7 +57,7 @@ export declare const enum Flag {
 /** Whether a row's flags let `bareRows` take it. */
 export declare function bare(f: number): boolean;
 /**
- * Every laned voice on one channel that reaches a single subject, a row each, in voice order: the
+ * Every laned voice on the same channels that reaches one 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
@@ -88,7 +88,7 @@ export declare class Crowd<I, O> implements Positions<I, O> {
     };
     /** Where the fill now under way has reached. */
     cursor: number;
-    /** Rows whose voices have left, kept in place until the crowds are next rebuilt. */
+    /** Rows whose voices have left, kept in place until the crowd is compacted or rebuilt. */
     dead: number;
     /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
     stale: boolean;
@@ -114,13 +114,15 @@ export declare class Crowd<I, O> implements Positions<I, O> {
     kept(p: number, xs: Float64Array): void;
     motionAt(p: number): Motions<I> | undefined;
     get size(): number;
-    /** Makes room for `rows` rows. */
     reserve(rows: number): void;
 }
 /** Runs every crowd's rows whose voices come before voice `id`, from where each crowd reached. */
 export declare function crowdsUpTo<I, O>(lanes: Lanes<I, O>, id: number): void;
-/** A keys or fn row's contribution, as `one` makes a lane position's. */
-export declare function row<I, O>(this: Lanes<I, O>, c: Crowd<I, O>, p: number, voice: Voice<I, O>, slot: number, elapsed: number, delay: number, w: number): void;
+/**
+ * A keys or fn row's contribution, as `one` makes a lane position's, at the voice time, delay and
+ * weight in `Arg`.
+ */
+export declare function row<I, O>(this: Lanes<I, O>, c: Crowd<I, O>, p: number, voice: Voice<I, O>, slot: number): void;
 /**
  * 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.

package/dist/crowd.js

@@ -22,7 +22,7 @@ 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
+ * Every laned voice on the same channels that reaches one 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
@@ -50,7 +50,7 @@ export class Crowd {
     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. */
+    /** Rows whose voices have left, kept in place until the crowd is compacted or rebuilt. */
     dead = 0;
     /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
     stale = false;
@@ -111,7 +111,6 @@ export class Crowd {
     get size() {
         return this.list.length;
     }
-    /** Makes room for `rows` rows. */
     reserve(rows) {
         if (rows * 8 /* Row.STRIDE */ <= this.data.length)
             return;
@@ -157,7 +156,7 @@ export function crowdsUpTo(lanes, id) {
         runCrowd(lanes, first, b);
     }
 }
-/** A crowd's rows from its cursor up to voice `id`, bare tweens in `bareRows` and the rest here. */
+/** A crowd's rows from its cursor up to voice `id`, bare tweens in `bareRows`, others in `rows`. */
 function runCrowd(lanes, c, id) {
     const list = c.list;
     const hot = c.hot;
@@ -171,7 +170,7 @@ function runCrowd(lanes, c, id) {
     c.cursor = p;
 }
 /**
- * A crowd's rows from `p` up to voice `id`, until one `bareRows` takes after the first: what
+ * A crowd's rows from `first` 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.
  */
@@ -180,6 +179,7 @@ function rows(lanes, c, first, id) {
     const hot = c.hot;
     const H = c.stride;
     const per = lanes.per;
+    const arg = lanes.arg;
     const list = c.list;
     const ch = c.chans[0];
     const n = c.axes;
@@ -226,11 +226,16 @@ function rows(lanes, c, first, id) {
         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)) {
+            // The envelope first: it may call out, and `signalled` reads `arg` as it starts.
+            const fade = lanes.host.envelope(voice, data[o + 1 /* Row.SINCE */]);
+            arg[1 /* Arg.ELAPSED */] = elapsed;
+            arg[3 /* Arg.PASS */] = passAt(elapsed, voice.duration, voice.passes);
+            arg[5 /* Arg.FADE */] = fade;
+            if (!lanes.signalled(voice, slot, c.records[p])) {
                 data[o + 2 /* Row.WEIGHT */] = 0;
                 continue;
             }
+            w = arg[0 /* Arg.WEIGHT */];
         }
         else
             w = weighed(voice.weight, lanes.host.envelope(voice, data[o + 1 /* Row.SINCE */]), lanes.parting(voice, slot));
@@ -240,8 +245,11 @@ function rows(lanes, c, first, id) {
                 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;
         }
+        arg[1 /* Arg.ELAPSED */] = elapsed;
+        arg[4 /* Arg.DELAY */] = delay;
+        arg[0 /* Arg.WEIGHT */] = w;
         if ((f & 128 /* Flag.MOTION */) === 0) {
-            lanes.row(c, p, voice, slot, elapsed, delay, w);
+            lanes.row(c, p, voice, slot);
             continue;
         }
         if (data[o + 7 /* Row.MET */] === 0) {
@@ -258,7 +266,7 @@ function rows(lanes, c, first, id) {
                 (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);
+            move(lanes, c, run, p, slot, c.records[p]);
             // 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 */]);
@@ -274,19 +282,24 @@ function rows(lanes, c, first, id) {
         if (w <= 0)
             continue;
         if ((f & 32 /* Flag.FOLDS */) !== 0)
-            lanes.foldRun(ch, slot, xs, w);
+            lanes.foldRun(ch, slot, xs);
         else
-            lanes.foldInto(ch, slot, c.motions[p].value(ms, xs), w);
+            lanes.foldInto(ch, slot, c.motions[p].value(ms, xs));
     }
     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) {
+/**
+ * A keys or fn row's contribution, as `one` makes a lane position's, at the voice time, delay and
+ * weight in `Arg`.
+ */
+export function row(c, p, voice, slot) {
+    const arg = this.arg;
+    const elapsed = arg[1 /* Arg.ELAPSED */];
     const duration = voice.duration;
-    const phase = phaseAt(elapsed, duration, voice.passes);
+    arg[2 /* Arg.PHASE */] = phaseAt(elapsed, duration, voice.passes);
     if (voice.built !== null) {
-        if (w > 0)
-            this.foldKeys(voice, c.chans, phase, slot, w);
+        if (arg[0 /* Arg.WEIGHT */] > 0)
+            this.foldKeys(voice, c.chans, slot);
         return;
     }
     const rec = c.records[p];
@@ -294,7 +307,8 @@ export function row(c, p, voice, slot, elapsed, delay, w) {
         this.late.push(slot);
         return;
     }
-    this.call(voice, c.chans, rec, slot, elapsed, phase, passAt(elapsed, duration, voice.passes), delay, w);
+    arg[3 /* Arg.PASS */] = passAt(elapsed, duration, voice.passes);
+    this.call(voice, c.chans, rec, slot);
 }
 /** Copies what a fill reads of a crowd row's voice into `hot`; returns the row's flags. */
 function copyVoice(c, p) {
@@ -349,7 +363,7 @@ function copyStretch(c, p, ms) {
     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)
+        if (run.scalar(ms) === ch.scalar && ch.plain)
             f |= 32 /* Flag.FOLDS */;
     }
     c.hot[h + 0 /* Hot.FLAGS */] = f;

package/dist/cue.d.ts

@@ -1,5 +1,7 @@
 import type { Mixer } from './mixer.js';
-import type { Handle, VoiceSpec } from './types.js';
+import type { Handle, Kit, Patch, VoiceSpec } from './types.js';
 export declare function cue<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): Handle<I>;
+/** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
+export declare function fitsKit<I, O, S, H>(patch: Patch<I, O, S, H>, kit: Kit<O>): void;
 /** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
 export declare function playable<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): void;

package/dist/cue.js

@@ -1,13 +1,15 @@
 import { checkHits } from './book.js';
-import { changed, index } from './chain.js';
+import { changed } from './chain.js';
+import { copyable } from './clone.js';
 import { schedule } from './due.js';
-import { VoiceHandle } from './handle.js';
-import { started } from './held.js';
+import { shares } from './everyone.js';
+import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
+import { reorigin } from './held.js';
 import { handle } from './hosts.js';
 import { motionOf } from './motion.js';
 import { adopt, ownerPatch, ownerReading } from './owner.js';
-import { durationOf } from './patch.js';
 import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
+import { enlist } from './roster.js';
 import { scoredAdd } from './scored.js';
 import { checkChild, refit } from './spans.js';
 import { motionOwner } from './strays.js';
@@ -25,7 +27,7 @@ export function cue(mix, spec) {
     if (anchor)
         checkPlacement(mix, spec, anchor, owner);
     if (spec.hits !== undefined)
-        checkHits(spec.hits, durationOf(patch));
+        checkHits(spec.hits, patch.duration);
     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);
@@ -52,17 +54,31 @@ export function cue(mix, spec) {
     record(mix, 'cue', () => recue(mix, VoiceHandle.voiceOf(h) ?? lost(h)));
     return h;
 }
-/** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
-export function playable(mix, spec) {
-    const patch = spec.patch;
+/** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
+export function fitsKit(patch, kit) {
     for (const channel of patch.writes) {
-        if (!(channel in mix.kit))
+        if (!(channel in 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];
+        const here = kit[channel];
+        const rest = here.rest;
+        if (here.fold && !here.copy && typeof rest === 'object' && rest !== null && !copyable(rest))
+            throw new Error(`blits: channel ${String(channel)} folds into a copy of its rest, which the mix cannot copy; give the channel a copy`);
         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'}`);
     }
+}
+/** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
+export function playable(mix, spec) {
+    const patch = spec.patch;
+    const loop = spec.loop;
+    if (typeof loop === 'number' && !(Number.isInteger(loop) && loop >= 1))
+        throw new RangeError(`blits: loop takes true, false or a whole number of passes, not ${loop}`);
+    if (spec.rate !== undefined)
+        finiteRate(spec.rate);
+    if (typeof spec.weight === 'number')
+        plainWeight(spec.weight);
+    fitsKit(patch, mix.kit);
     const motion = motionOf(patch);
     if (motion !== undefined) {
         const channel = patch.writes[0];
@@ -104,12 +120,9 @@ function enter(mix, voice) {
     const motion = voice.motion;
     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.cuedSeq = mix.transport.seq;
         voice.opened = mix.now;
     }
     voice.placing = anchored;
@@ -129,21 +142,19 @@ function enter(mix, voice) {
         i--;
     cued.splice(i, 0, voice);
     scoredAdd(mix, voice);
-    index(mix, voice);
+    voice.sharing = shares(mix, voice);
+    enlist(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);
+            reorigin(mix, voice, mix.now);
             changed(mix, voice);
         }
     }
@@ -152,7 +163,7 @@ function enter(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);
+        voice.note(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
         voice.first ??= voice.log[0];
     }
     schedule(mix, voice);

package/dist/departed.d.ts

@@ -0,0 +1,34 @@
+import type { Mixer } from './mixer.js';
+import type { Mark, Query } from './types.js';
+import { type Voice } from './voice.js';
+/**
+ * What a mix keeps of a voice it has forgotten, on leaving without history or past history's reach:
+ * what a query matches it by and the times of its marks, so an anchor that no voice the mix still
+ * knows answers can find it.
+ */
+export interface Departed {
+    readonly id: number;
+    readonly score: string | undefined;
+    /** Its owner's id, -1 for none. */
+    readonly owner: number;
+    readonly name: string | undefined;
+    readonly tags: readonly string[];
+    readonly writes: readonly unknown[];
+    readonly marks: Readonly<Record<Mark, number | undefined>>;
+    /** How many of the index's ends hold it. */
+    held: number;
+}
+/**
+ * The departed voices a query could still pick: for each name, tag and channel within a score and
+ * owner, the first and the last to leave. It grows with those, never with how many voices left.
+ */
+export declare class DepartedIndex {
+    private readonly ends;
+    readonly all: Set<Departed>;
+    add<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+    /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
+    dropOwner(owner: number): void;
+    private release;
+}
+/** Whether a departed voice answers `q`, asked by a voice of `owner` (-1 for none) on `score`. */
+export declare function departedMatches(d: Departed, q: Query, score: string | undefined, anywhere: boolean, owner: number): boolean;

package/dist/departed.js

@@ -0,0 +1,73 @@
+import { markOf } from './marks.js';
+import { none } from './voice.js';
+const MARKS = ['start', 'in', 'coast', 'out', 'end'];
+/**
+ * The departed voices a query could still pick: for each name, tag and channel within a score and
+ * owner, the first and the last to leave. It grows with those, never with how many voices left.
+ */
+export class DepartedIndex {
+    ends = new Map();
+    all = new Set();
+    add(mix, voice) {
+        // Nothing can be cued beside a voice whose owner has gone, so nothing will ask for it.
+        if (voice.owner?.state === 'done')
+            return;
+        const marks = {};
+        for (const mark of MARKS)
+            marks[mark] = markOf(mix, voice, mark);
+        const d = {
+            id: voice.id,
+            score: voice.spec.score,
+            owner: voice.owner?.id ?? -1,
+            name: voice.spec.name,
+            tags: voice.spec.tags ?? none,
+            writes: voice.patch.writes,
+            marks,
+            held: 0,
+        };
+        const base = `${d.score ?? ''}\u0000${d.owner}\u0000`;
+        const keys = [`${base}w`];
+        if (d.name !== undefined)
+            keys.push(`${base}n\u0000${d.name}`);
+        for (const tag of d.tags)
+            keys.push(`${base}t\u0000${tag}`);
+        for (const ch of d.writes)
+            keys.push(`${base}c\u0000${String(ch)}`);
+        for (const key of keys) {
+            const end = this.ends.get(key);
+            if (end === undefined) {
+                this.ends.set(key, { first: d, last: d });
+                d.held += 2;
+                continue;
+            }
+            this.release(end.last);
+            end.last = d;
+            d.held++;
+        }
+        if (d.held > 0)
+            this.all.add(d);
+        if (voice.holding !== null)
+            this.dropOwner(voice.id);
+    }
+    /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
+    dropOwner(owner) {
+        for (const [key, end] of this.ends)
+            if (end.first.owner === owner) {
+                this.ends.delete(key);
+                this.all.delete(end.first);
+                this.all.delete(end.last);
+            }
+    }
+    release(d) {
+        if (--d.held === 0)
+            this.all.delete(d);
+    }
+}
+/** Whether a departed voice answers `q`, asked by a voice of `owner` (-1 for none) on `score`. */
+export function departedMatches(d, q, score, anywhere, owner) {
+    return (d.score === score &&
+        (anywhere || d.owner === owner) &&
+        (q.name === undefined || d.name === q.name) &&
+        (q.tag === undefined || d.tags.includes(q.tag)) &&
+        (q.writes === undefined || d.writes.includes(q.writes)));
+}

package/dist/easing.d.ts

@@ -1,4 +1,9 @@
 import type { Easing } from './types.js';
 export type Curve = (u: number) => number;
+/**
+ * How fast a curve leaves 0, for bending a retarget to the speed the subject had: Infinity where
+ * the curve jumps or leaves vertically, so no finite bend can match it.
+ */
+export declare function startSlope(c: Curve): number;
 /** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
 export declare function curve(easing: Easing): Curve;

package/dist/easing.js

@@ -46,6 +46,31 @@ const named = {
     'ease-in-out': bezier(0.42, 0, 0.58, 1),
 };
 const built = new WeakMap();
+/** Each built curve's slope at 0, where its definition gives one: Infinity for a jump. */
+const starts = new WeakMap([[linear, 1]]);
+/** A bezier's slope at u = 0: dy/dx as t leaves 0, by the first control point that moves x. */
+function bezierStart(x1, y1, x2, y2) {
+    if (x1 > 0)
+        return y1 / x1;
+    if (y1 > 0)
+        return Number.POSITIVE_INFINITY;
+    if (x2 > 0)
+        return y2 / x2;
+    return y2 > 0 ? Number.POSITIVE_INFINITY : 1;
+}
+/**
+ * How fast a curve leaves 0, for bending a retarget to the speed the subject had: Infinity where
+ * the curve jumps or leaves vertically, so no finite bend can match it.
+ */
+export function startSlope(c) {
+    const known = starts.get(c);
+    if (known !== undefined)
+        return known;
+    const h = 1e-6;
+    const v = c(h);
+    // Past a thousandth of the way within a millionth of the time: a jump, not a slope.
+    return v > 1e-3 ? Number.POSITIVE_INFINITY : v / h;
+}
 /** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
 export function curve(easing) {
     if (typeof easing === 'function')
@@ -60,15 +85,19 @@ export function curve(easing) {
     if (held)
         return held;
     let made;
-    if ('bezier' in easing)
+    if ('bezier' in easing) {
         made = bezier(...easing.bezier);
+        starts.set(made, bezierStart(...easing.bezier));
+    }
     else {
         const n = easing.steps;
         const start = easing.jump === 'start';
         made = (u) => {
             const c = u <= 0 ? 0 : u >= 1 ? 1 : u;
-            return (start ? Math.ceil(c * n) : Math.floor(c * n)) / n;
+            // CSS: jump-start has already taken its first step at 0, and neither form passes n.
+            return (start ? Math.min(n, Math.floor(c * n) + 1) : Math.floor(c * n)) / n;
         };
+        starts.set(made, start ? Number.POSITIVE_INFINITY : 0);
     }
     built.set(easing, made);
     return made;