@msb235/blits 0.7.0 → 0.8.0

package/dist/gone.js

@@ -0,0 +1,144 @@
+import { scoredCut } from './scored.js';
+import { Store } from './store.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export class GoneIndex {
+    /** The `gone` list it was built over, and how much of it. */
+    of = null;
+    count = 0;
+    general = [];
+    named = new Store();
+    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    latest = Number.NEGATIVE_INFINITY;
+    slack = 0;
+}
+function add(ix, voice) {
+    if (voice.doneAt < ix.latest)
+        ix.slack = Math.max(ix.slack, ix.latest - voice.doneAt);
+    else
+        ix.latest = voice.doneAt;
+    if (voice.named === null) {
+        ix.general.push(voice);
+        return;
+    }
+    for (const subject of voice.named) {
+        const list = ix.named.get(subject);
+        if (list === undefined)
+            ix.named.set(subject, [voice]);
+        else
+            list.push(voice);
+    }
+}
+function remove(ix, out) {
+    let general = false;
+    for (const v of out) {
+        if (v.named === null) {
+            general = true;
+            continue;
+        }
+        for (const subject of v.named) {
+            const named = ix.named.get(subject);
+            if (named === undefined)
+                continue;
+            const at = named.indexOf(v);
+            if (at >= 0)
+                named.splice(at, 1);
+            if (named.length === 0)
+                ix.named.delete(subject);
+        }
+    }
+    if (general) {
+        const leaving = new Set(out);
+        ix.general = ix.general.filter((v) => !leaving.has(v));
+    }
+}
+/** The index caught up with `mix.gone`. */
+export function goneIndex(mix) {
+    const ix = mix.goneIx;
+    const list = mix.gone;
+    if (ix.of !== list || ix.count > list.length) {
+        ix.general = [];
+        ix.named = new Store();
+        ix.count = 0;
+        ix.of = list;
+        ix.latest = Number.NEGATIVE_INFINITY;
+        ix.slack = 0;
+    }
+    for (let i = ix.count; i < list.length; i++)
+        add(ix, list[i]);
+    ix.count = list.length;
+    return ix;
+}
+/** Hands voices let go of from `gone` to the departed index, noting the latest that left. */
+function forgot(mix, out) {
+    for (const v of out) {
+        mix.departed.add(mix, v);
+        if (v.doneAt > mix.transport.forgotTo)
+            mix.transport.forgotTo = v.doneAt;
+    }
+}
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export function keepGone(mix, keep) {
+    const ix = goneIndex(mix);
+    const list = mix.gone;
+    let i = 0;
+    while (i < list.length && keep(list[i]))
+        i++;
+    if (i === list.length)
+        return;
+    const kept = list.slice(0, i);
+    const out = [list[i]];
+    for (i++; i < list.length; i++) {
+        const v = list[i];
+        (keep(v) ? kept : out).push(v);
+    }
+    remove(ix, out);
+    forgot(mix, out);
+    mix.gone = kept;
+    scoredCut(mix, list, out);
+    ix.of = kept;
+    ix.count = kept.length;
+}
+/**
+ * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
+ * finish, so only the front can hold one: past the point where a voice finished `slack` after
+ * `reach`, none behind it finished before `reach`.
+ */
+export function expireGone(mix, reach) {
+    const ix = goneIndex(mix);
+    if (!Number.isFinite(ix.slack)) {
+        keepGone(mix, (v) => v.doneAt >= reach);
+        return;
+    }
+    const list = mix.gone;
+    const edge = reach + ix.slack;
+    let end = 0;
+    let any = false;
+    for (let seen = Number.NEGATIVE_INFINITY; end < list.length && seen < edge; end++) {
+        const done = list[end].doneAt;
+        if (done < reach)
+            any = true;
+        if (done > seen)
+            seen = done;
+    }
+    if (!any)
+        return;
+    const kept = [];
+    const out = [];
+    for (let i = 0; i < end; i++) {
+        const v = list[i];
+        (v.doneAt < reach ? out : kept).push(v);
+    }
+    list.splice(0, end, ...kept);
+    remove(ix, out);
+    forgot(mix, out);
+    scoredCut(mix, list, out);
+    ix.count = list.length;
+}

package/dist/handle.d.ts

@@ -1,13 +1,17 @@
-import type { FadeOptions, FitResult, Handle } from './types.js';
+import { type Motion, type Value } from './motion.js';
+import type { Doubt, FadeOptions, FitResult, Handle, SeekOptions } from './types.js';
 import type { Voice } from './voice.js';
 /** What a voice's handle asks of the mix that cued it: one per mix, shared by every handle. */
 export interface HandleHost<I, O> {
-    /** The mix clock, or the voice's start before the first sync. */
+    /** The mix clock, or its owner's for a voice one holds; the voice's start before either reads. */
     nowFor(voice: Voice<I, O>): number;
     /** A handle write changed the voice: reschedule it, and refill the lanes. */
     changed(voice: Voice<I, O>): void;
-    /** The voice's clock jumped: for an owner, so did every clock it holds. */
-    sought(voice: Voice<I, O>): void;
+    /**
+     * The voice's clock jumped: for an owner, so did every clock it holds. With `rebuild`, their
+     * state is made again for where they now are. How sure that leaves it.
+     */
+    sought(voice: Voice<I, O>, rebuild: boolean): Doubt;
     fade(voice: Voice<I, O>, opts: FadeOptions<I> | undefined): void;
     rise(voice: Voice<I, O>, opts: {
         over?: number;
@@ -16,6 +20,10 @@ export interface HandleHost<I, O> {
     /** Records a write the host made, which `again` makes once more where a seek replays it. */
     record(label: string, again: () => void): void;
 }
+/** Refuses a voice rate no clock can run at. */
+export declare function finiteRate(rate: number): void;
+/** Refuses a voice weight that is no number: NaN would fold into every channel the voice writes. */
+export declare function plainWeight(weight: number): void;
 /** What a handle answers for a voice a history store paged out, which left long ago. */
 export interface Gone {
     weight: number;
@@ -47,10 +55,13 @@ export declare class VoiceHandle<I, O> implements Handle<I> {
     get rate(): number;
     set rate(r: number);
     ramp(r: number, over: number): void;
-    seek(elapsed: number): void;
+    seek(elapsed: number, opts?: SeekOptions): Doubt;
     fade(opts?: FadeOptions<I>): void;
     rise(opts?: {
         over?: number;
     }): void;
     weightOf(subject: I): number;
+    to(subject: I, target: Value, at?: number): void;
+    push(subject: I, velocity: Value, at?: number): void;
+    read(subject: I, at?: number): Motion<Value> | undefined;
 }

package/dist/handle.js

@@ -1,4 +1,16 @@
 import { retime } from './clock.js';
+import { motionOf } from './motion.js';
+import { leave } from './origin.js';
+/** Refuses a voice rate no clock can run at. */
+export function finiteRate(rate) {
+    if (!Number.isFinite(rate))
+        throw new RangeError(`blits: a voice's rate is a finite number, not ${rate}`);
+}
+/** Refuses a voice weight that is no number: NaN would fold into every channel the voice writes. */
+export function plainWeight(weight) {
+    if (Number.isNaN(weight))
+        throw new RangeError('blits: a voice’s weight is a number, not NaN');
+}
 /**
  * A voice's handle: the host's only way to control a voice once cued. A voice a history store
  * pages out is let go of here too, so the handle answers as a gone voice's does, and a seek that
@@ -49,9 +61,11 @@ export class VoiceHandle {
     }
     // A write to a paged voice changes nothing: it had left when the host made it, as it has on replay.
     set weight(w) {
+        plainWeight(w);
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         voice.weight = w;
         this.#host.changed(voice);
         this.#host.record('weight', () => {
@@ -66,28 +80,40 @@ export class VoiceHandle {
         this.ramp(r, 0);
     }
     ramp(r, over) {
+        finiteRate(r);
         const voice = this.#voice;
         if (voice === null)
             return;
-        retime(voice, this.#host.nowFor(voice), r, over);
+        voice.written = true;
+        const now = this.#host.nowFor(voice);
+        // A pending voice's clock reads 0 at its start, and a rate taken from now would cross 0 sooner:
+        // a subject it freezes before would play, and step, ahead of a voice that has not started.
+        const u = voice.state === 'pending' && voice.start > now && r > 0 ? voice.start : now;
+        leave(voice, u);
+        retime(voice, u, r, over);
         this.#host.changed(voice);
         this.#host.record('rate', () => this.ramp(r, over));
     }
-    seek(elapsed) {
+    seek(elapsed, opts) {
         const voice = this.#voice;
         if (voice === null)
-            return;
-        voice.rebase(this.#host.nowFor(voice));
+            return 'exact';
+        voice.written = true;
+        const u = this.#host.nowFor(voice);
+        leave(voice, u);
+        voice.rebase(u);
         voice.anchorElapsed = elapsed;
         voice.seeks++;
-        this.#host.sought(voice);
+        const doubt = this.#host.sought(voice, opts?.state !== 'keep');
         this.#host.changed(voice);
-        this.#host.record('seek', () => this.seek(elapsed));
+        this.#host.record('seek', () => this.seek(elapsed, opts));
+        return doubt;
     }
     fade(opts) {
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         this.#host.fade(voice, opts);
         this.#host.record('fade', () => this.fade(opts));
     }
@@ -95,6 +121,7 @@ export class VoiceHandle {
         const voice = this.#voice;
         if (voice === null)
             return;
+        voice.written = true;
         this.#host.rise(voice, opts);
         this.#host.record('rise', () => this.rise(opts));
     }
@@ -102,4 +129,27 @@ export class VoiceHandle {
         const voice = this.#voice;
         return voice === null ? 0 : this.#host.weightOf(voice, subject);
     }
+    // The patch records each of these itself, so a seek plays them again without the handle.
+    to(subject, target, at) {
+        const voice = this.#voice;
+        if (voice !== null)
+            moves(voice.patch, 'to', 'a spring or a tween').to(subject, target, at);
+    }
+    push(subject, velocity, at) {
+        const voice = this.#voice;
+        if (voice !== null)
+            moves(voice.patch, 'push', 'a spring or a glide').push(subject, velocity, at);
+    }
+    read(subject, at) {
+        const voice = this.#voice;
+        if (voice === null || motionOf(voice.patch) === undefined)
+            return undefined;
+        return voice.patch.read(subject, at);
+    }
+}
+/** A voice's patch as a motion that takes `verb`, or a throw naming the kinds that do. */
+function moves(patch, verb, kinds) {
+    if (motionOf(patch) === undefined || typeof patch[verb] !== 'function')
+        throw new Error(`blits: ${verb} needs a voice playing ${kinds}`);
+    return patch;
 }

package/dist/held.d.ts

@@ -3,12 +3,15 @@ import type { Subject, Voice } from './voice.js';
 /** The record a voice gives every subject it does not reach. */
 export declare function unreachedOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): Subject<unknown>;
 /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, slot: number): Subject<unknown>;
+export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number): Subject<unknown>;
 /**
- * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
- * the rate it is ramping to.
+ * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
+ * counts from its last seek that rebuilt state, as its records do.
  */
 export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, delay: number): number;
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
-/** A voice has gone live: the records it made while pending count from where it started. */
-export declare function started<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
+ * ahead count from where its clock now puts them.
+ */
+export declare function reorigin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;

package/dist/held.js

@@ -1,41 +1,32 @@
 import { schedule } from './due.js';
-import { mixTime } from './owner.js';
+import { everyoneOf, inherit, sighted } from './everyone.js';
+import { originOf } from './origin.js';
+import { record } from './record.js';
 import { unreach, unreached } from './unreached.js';
 /** The record a voice gives every subject it does not reach. */
 export function unreachedOf(voice, now) {
     const since = this.sinceOf(voice, 0);
-    const none = {
-        reaches: false,
-        delay: 0,
-        since,
-        shown: this.shownOf(voice, since),
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: undefined,
-        stepped: now,
-        ticks: 0,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const none = record(voice, false, undefined);
+    none.since = since;
+    none.shown = this.shownOf(voice, since);
+    none.stepped = now;
+    none.rebuilt = voice.rebuilds;
     voice.unreached = none;
     return none;
 }
 /** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export function held(voice, subject, now, slot) {
+export function held(voice, subject, slot) {
+    if (voice.sharing) {
+        const all = everyoneOf(this, voice);
+        if (all !== null)
+            return all;
+    }
     if (unreached(voice, slot))
         return voice.unreached;
     let held = voice.subjects.get(subject);
     if (held !== undefined)
         return held;
+    const now = this.now;
     const reaches = this.aims(voice, subject);
     if (!reaches) {
         // Nothing is kept for a subject the voice does not reach, so one record stands for them all:
@@ -55,38 +46,36 @@ export function held(voice, subject, now, slot) {
     }
     const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
     const since = this.sinceOf(voice, delay);
-    held = {
-        reaches: true,
-        delay,
-        since,
-        shown: this.shownOf(voice, since),
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: 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: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const shown = this.shownOf(voice, since);
+    held = record(voice, true, voice.patch.state ? voice.patch.state(subject) : undefined);
+    held.delay = delay;
+    held.since = since;
+    held.shown = shown;
+    held.stepped = since < now ? since : now;
+    held.rebuilt = voice.rebuilds;
     if (this.projecting) {
         held.from = held.stepped;
         held.unknown = this.backward && voice.spec.from === 'current';
     }
     voice.subjects.set(subject, held);
-    if (voice.state === 'pending') {
+    if (!(since <= now)) {
         voice.early ??= [];
-        voice.early.push(held);
+        const early = voice.early;
+        // Prunes at each doubling, so records whose origin has passed are not kept to the voice's end.
+        if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
+            let kept = 0;
+            for (const h of early)
+                if (!(h.since <= now))
+                    early[kept++] = h;
+            early.length = kept;
+        }
+        early.push(held);
     }
-    voice.seen++;
+    // A subject a voice saw while it shared one record was counted then.
+    if (sighted(voice, slot))
+        inherit(voice, held, slot);
+    else
+        voice.seen++;
     if (delay > voice.latest) {
         voice.latest = delay;
         // A later end can take a frozen voice live again.
@@ -96,26 +85,35 @@ export function held(voice, subject, now, slot) {
     return held;
 }
 /**
- * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
- * the rate it is ramping to.
+ * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
+ * counts from its last seek that rebuilt state, as its records do.
  */
 export function sinceOf(voice, delay) {
-    const t = voice.rate > 0
-        ? voice.anchorNow + (delay - voice.anchorElapsed) / voice.rate
-        : voice.start + delay;
-    return voice.owner === null ? t : mixTime(voice.owner, t);
+    const p = voice.patch;
+    return originOf(voice, delay, p.state !== undefined || p.step !== undefined || voice.keeping);
 }
 export function shownOf(voice, since) {
     return voice.freezesBefore && voice.opened < since ? voice.opened : since;
 }
-/** A voice has gone live: the records it made while pending count from where it started. */
-export function started(mix, voice) {
+/**
+ * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
+ * ahead count from where its clock now puts them.
+ */
+export function reorigin(mix, voice, now) {
     const early = voice.early;
     if (early === null)
         return;
-    voice.early = null;
+    let kept = 0;
     for (const held of early) {
         held.since = mix.sinceOf(voice, held.delay);
         held.shown = mix.shownOf(voice, held.since);
+        if (held.ticks === 0 && held.stepped > held.since)
+            held.stepped = held.since;
+        if (!(held.since <= now))
+            early[kept++] = held;
     }
+    early.length = kept;
+    if (kept === 0)
+        voice.early = null;
+    mix.lanes?.reshown(voice.id);
 }

package/dist/history.d.ts

@@ -1,13 +1,20 @@
 import type { Mixer } from './mixer.js';
+import { type Cut } from './transport.js';
 import { type Subject, type Voice } from './voice.js';
-/**
- * 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.
- */
+/** The last entry taken before `t`, or at it where `inclusive` says so. */
 export declare function last<T extends {
     at: number;
 }>(list: readonly T[], t: number, inclusive: boolean | ((e: T) => boolean)): T | undefined;
+/**
+ * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
+ * before its frame was read counting as `early`.
+ */
+export declare function lastWithin<T extends {
+    seq: number;
+    sync?: boolean;
+}>(list: readonly T[], cut: Cut): T | undefined;
+/** Deep equality over plain data, for telling whether a host field changed. */
+export declare function same(a: unknown, b: unknown): boolean;
 /** A voice's elapsed at an earlier mix time, by the controls it had then. */
 export declare function elapsedThen<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, t: number): number;
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
@@ -25,11 +32,8 @@ export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, sub
  * for a seek or a read back to before then; without history, keeps nothing.
  */
 export declare function leave<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined): void;
-/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
-export declare function leftAt<I>(left: readonly {
-    subject: I;
-    at: number;
-    held: Subject<unknown>;
-}[] | null, subject: I, t: number): Subject<unknown> | undefined;
-/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
-export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number];
+/**
+ * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
+ * history.
+ */
+export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number, seq?: number];

package/dist/history.js

@@ -1,14 +1,13 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
 import { schedule } from './due.js';
+import { Leavings } from './leavings.js';
 import { packHeld } from './pack.js';
 import { pageOut } from './paging.js';
+import { scoreTouched } from './scored.js';
+import { within } from './transport.js';
 import { none } from './voice.js';
-/**
- * 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.
- */
+/** The last entry taken before `t`, or at it where `inclusive` says so. */
 export function last(list, t, inclusive) {
     let lo = 0;
     let hi = list.length - 1;
@@ -25,8 +24,28 @@ export function last(list, t, inclusive) {
     }
     return found;
 }
+/**
+ * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
+ * before its frame was read counting as `early`.
+ */
+export function lastWithin(list, cut) {
+    let lo = 0;
+    let hi = list.length - 1;
+    let found;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const e = list[mid];
+        if (within(cut, e.seq, e.sync)) {
+            found = e;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return found;
+}
 /** Deep equality over plain data, for telling whether a host field changed. */
-function same(a, b) {
+export function same(a, b) {
     if (a === b)
         return true;
     if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
@@ -52,12 +71,13 @@ function ownerThen(mix, owner, t) {
 }
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
 export function noted(mix, voice) {
+    scoreTouched(mix, voice, true);
     mix.stir();
     schedule(mix, voice);
     const log = voice.log;
     if (log === null)
         return;
-    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.moving);
+    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.transport.seq, mix.moving || !mix.looked);
     const reach = mix.now - mix.opts.history.ms;
     let drop = 0;
     while (drop + 1 < log.length && log[drop + 1].at <= reach)
@@ -106,7 +126,8 @@ export function copyHeld(voice, h) {
 export function recordHost(mix, now) {
     const log = mix.hostLog;
     const prev = log[log.length - 1];
-    if (prev !== undefined && prev.at === now)
+    const seq = mix.transport.seq;
+    if (prev !== undefined && prev.seq === seq)
         return;
     const host = mix.opts.host;
     const fields = {};
@@ -116,7 +137,7 @@ export function recordHost(mix, now) {
                 fields[f] = clone(host[f]);
     if (prev !== undefined && same(prev.fields, fields))
         return;
-    log.push({ at: now, fields });
+    log.push({ at: now, seq, fields });
     const reach = now - mix.opts.history.ms;
     pageOut(mix, 'host', undefined, undefined, older(log, reach), (e) => e.fields, reach);
 }
@@ -133,7 +154,7 @@ export function record(mix, voice, subject, held, value) {
             prev.value = value;
         return;
     }
-    inputs.push({ at: mix.now, value });
+    inputs.push({ at: mix.now, seq: mix.transport.seq, value });
     const reach = mix.now - history.ms;
     const out = older(inputs, reach);
     if (out.length > 0)
@@ -153,7 +174,7 @@ export function remember(mix, voice, subject, held) {
     const prev = snaps[snaps.length - 1];
     if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
         return;
-    snaps.push({ at: mix.now, held: copyHeld(voice, held) });
+    snaps.push({ at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
     const out = older(snaps, reach);
     if (out.length > 0)
@@ -168,27 +189,27 @@ export function leave(mix, voice, subject, held) {
     if (history === undefined || held === undefined)
         return;
     const reach = mix.now - history.ms;
-    const left = [];
-    for (const e of voice.left ?? [])
-        if (e.at >= reach)
-            left.push(e);
-        else if (mix.keys !== null)
-            pageOut(mix, 'left', voice.id, mix.keys.key(e.subject), [e], (x) => packHeld(voice, x.held), reach);
-    left.push({ subject, at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, held });
+    const left = voice.left ?? new Leavings();
     voice.left = left;
+    const keys = mix.keys;
+    left.expire(reach, keys === null
+        ? null
+        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync], reach));
+    left.push({
+        subject,
+        at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now,
+        seq: mix.transport.seq,
+        sync: mix.syncing,
+        held,
+    });
 }
-/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
-export function leftAt(left, subject, t) {
-    let found;
-    for (const e of left ?? [])
-        if (e.at > t && Object.is(e.subject, subject) && (found === undefined || e.at < found.at))
-            found = e;
-    return found?.held;
-}
-/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
+/**
+ * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
+ * history.
+ */
 export function releasing(mix) {
     const history = mix.opts.history;
     if (history === undefined || Number.isNaN(mix.now))
         return [];
-    return [mix.now, mix.now - history.ms];
+    return [mix.now, mix.now - history.ms, mix.transport.seq];
 }