@msb235/blits 0.5.0 → 0.7.0

package/dist/fit.js

@@ -0,0 +1,181 @@
+/** How far through the one before a child starts under each order, before any fit. */
+export function shareOf(order, stagger) {
+    return order === 'queue' ? 1 : order === 'together' ? 0 : stagger;
+}
+/**
+ * The plan before any fit: every child at its own rate, played, in the span's order.
+ *
+ * @category score
+ */
+export function plain(span, kids) {
+    return {
+        rate: kids.map(() => 1),
+        skip: kids.map(() => false),
+        share: shareOf(span.order, span.share),
+        allow: 0,
+    };
+}
+/**
+ * Where a plan puts each child, span ms from now, and how long they take together. A playing child
+ * is where it is, at 0; each pending one starts its share through the one before it.
+ *
+ * @category score
+ */
+export function layout(span, kids, plan) {
+    const base = shareOf(span.order, span.share);
+    const at = [];
+    let length = 0;
+    let prevAt = 0;
+    let prevLen = 0;
+    kids.forEach((k, i) => {
+        const len = plan.skip[i] ? 0 : k.natural / plan.rate[i];
+        const t = k.state === 'playing' || i === 0
+            ? 0
+            : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen;
+        at.push(t);
+        length = Math.max(length, t + len);
+        prevAt = t;
+        prevLen = len;
+    });
+    return { at, length };
+}
+const fits = (span, kids, plan) => layout(span, kids, plan).length <= span.left + plan.allow + 1e-9;
+/** The smallest value in `lo..hi` at which `ok` holds, where it holds from some point up. */
+function least(lo, hi, ok) {
+    if (ok(lo))
+        return lo;
+    if (!ok(hi))
+        return hi;
+    for (let i = 0; i < 60; i++) {
+        const mid = (lo + hi) / 2;
+        if (ok(mid))
+            hi = mid;
+        else
+            lo = mid;
+    }
+    return hi;
+}
+/**
+ * Moves every child's rate by one factor toward the budget, before the span's fit: faster where
+ * they run past it, each no faster than its `faster` allows, and slower where they leave room in
+ * it, each no slower than its `slower` allows, so they fill it.
+ */
+export function rescale(span, kids, plan) {
+    if (!fits(span, kids, plan)) {
+        const top = Math.max(1, ...kids.map((k) => k.faster));
+        const at = (f) => ({
+            ...plan,
+            rate: kids.map((k, i) => Math.max(plan.rate[i], Math.min(f, k.faster))),
+        });
+        return at(least(1, top, (f) => fits(span, kids, at(f))));
+    }
+    if (!Number.isFinite(span.left))
+        return plan;
+    const top = Math.max(1, ...kids.map((k) => k.slower));
+    if (top === 1)
+        return plan;
+    const at = (f) => ({
+        ...plan,
+        rate: kids.map((k, i) => plan.rate[i] / Math.min(f, k.slower)),
+    });
+    // The largest factor that still fits: `least` over the factors that do not.
+    const f = least(1, top, (x) => !fits(span, kids, at(x)));
+    return fits(span, kids, at(f)) ? at(f) : at(Math.max(1, f - 1e-9));
+}
+/**
+ * Starts children that may overlap sooner after the one before, toward all at once, until they
+ * fit.
+ *
+ * @category score
+ */
+export function condense() {
+    return (span, kids, plan) => {
+        if (fits(span, kids, plan) || !kids.some((k) => k.overlap))
+            return plan;
+        const at = (s) => ({ ...plan, share: s });
+        // `least` finds the smallest x that fits; the share wanted is the largest, so search 1 - share.
+        const x = least(0, plan.share, (d) => fits(span, kids, at(plan.share - d)));
+        return at(plan.share - x);
+    };
+}
+/**
+ * Jumps children that may be skipped to their end, latest first, until they fit.
+ *
+ * @category score
+ */
+export function shed() {
+    return (span, kids, plan) => {
+        let p = plan;
+        for (let i = kids.length - 1; i >= 0 && !fits(span, kids, p); i--) {
+            if (!kids[i].ballast || p.skip[i])
+                continue;
+            const s = p.skip.slice();
+            s[i] = true;
+            p = { ...p, skip: s };
+        }
+        return p;
+    };
+}
+/**
+ * Jumps every child left to its end at once, whether or not it fits otherwise.
+ *
+ * @category score
+ */
+export function conclude() {
+    return (_span, kids, plan) => ({ ...plan, skip: kids.map(() => true) });
+}
+/**
+ * Lets the span run past its budget: up to `cap` times it, or without limit.
+ *
+ * @category score
+ */
+export function overrun(opts = {}) {
+    return (span, _kids, plan) => {
+        const cap = opts.cap;
+        const allow = cap === undefined ? Number.POSITIVE_INFINITY : Math.max(0, (cap - 1) * span.budget);
+        return { ...plan, allow: Math.max(plan.allow, allow) };
+    };
+}
+/**
+ * Tries each fit in turn, handing the plan on, and stops once the children fit.
+ *
+ * @category score
+ */
+export function pipe(...fits_) {
+    return (span, kids, plan) => {
+        let p = plan;
+        for (const f of fits_) {
+            if (fits(span, kids, p))
+                break;
+            p = f(span, kids, p);
+        }
+        return p;
+    };
+}
+/**
+ * Every way of giving way after the span's retiming, overrunning only once the rest are spent.
+ *
+ * @category score
+ */
+export function lax(opts = {}) {
+    return pipe(condense(), shed(), overrun(opts));
+}
+/** The fit a span takes without one of its own. */
+export const defaultFit = pipe(condense(), shed());
+const rank = { weak: 0, strong: 1, required: 2 };
+/**
+ * A span's fit settled: the plan, and what it had to do past the strategy, which starts from the
+ * children retimed toward the budget. Where the children still
+ * do not fit, a span weaker than `strong` lets them run long; otherwise `spill` either skips
+ * every child weaker than the span (`instant`), or lets them run long (`overrun`).
+ */
+export function settle(span, kids, fit, spill) {
+    let plan = fit(span, kids, rescale(span, kids, plain(span, kids)));
+    if (fits(span, kids, plan) || rank[span.priority] === 0 || spill === 'overrun')
+        return { plan, fell: !fits(span, kids, plan) && rank[span.priority] > 0 };
+    plan = {
+        ...plan,
+        skip: kids.map((k, i) => plan.skip[i] || rank[k.priority] < rank[span.priority]),
+    };
+    return { plan, fell: true };
+}

package/dist/fold.d.ts

@@ -7,7 +7,7 @@ export type Values = Record<string, unknown>;
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
  */
-export declare function influence<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
+export declare function contribution<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): Record<string, unknown> | null;
 /** Reads a keys voice's stops at `held.phase` into the subject's delta, through the voice's scratch. */
 export declare function keyed<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): Record<string, unknown>;
 /**
@@ -28,7 +28,7 @@ export declare function baseFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sub
  */
 export declare function slopeFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): Record<string, unknown> | undefined;
 export declare function isRest<I, O>(this: Mixer<I, O>, delta: Record<string, unknown>): boolean;
-/** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
+/** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export declare function passes<I, O>(this: Mixer<I, O>, was: boolean | undefined, w: number): boolean;
 /** Folds one voice's delta into the pose, its band state kept on the subject's record. */
 export declare function apply<I, O>(this: Mixer<I, O>, pose: Record<string, unknown>, voice: Voice<I, O>, held: Subject<unknown>, delta: Record<string, unknown>, weight: number): void;
@@ -47,5 +47,5 @@ export declare function foldWith<I, O>(this: Mixer<I, O>, subject: I, out: O, he
 export declare function owedBy<I, O>(this: Mixer<I, O>, owed: number, voice: Voice<I, O>): boolean;
 /** `foldWith`'s voices with a locus in play: each locus folds at its first member's place. */
 export declare function foldLoci<I, O>(this: Mixer<I, O>, subject: I, pose: Record<string, unknown>, head: Subject<unknown>, laned: boolean, dry: boolean, except: number | undefined, owed: number): O;
-/** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
 export declare function read<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, dry: boolean, held: Subject<unknown>): Record<string, unknown> | null;

package/dist/fold.js

@@ -1,4 +1,4 @@
-import { heldTime, passAt, phaseAt, silent } from './clock.js';
+import { frozenTime, passAt, phaseAt, silent } from './clock.js';
 import { copy as copyValue } from './clone.js';
 import { recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
@@ -39,18 +39,18 @@ function merged(channel, acc, b) {
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
  */
-export function influence(voice, subject, now, held) {
+export function contribution(voice, subject, now, held) {
     held.weight = 0;
     if (!held.reaches)
         return null;
     if (voice.out?.rest && held.rested)
         return null;
     const raw = voice.elapsedAt(now) - held.delay;
-    if (raw < 0 && !voice.holdsBefore)
+    if (raw < 0 && !voice.freezesBefore)
         return null;
-    const elapsed = heldTime(raw, voice.holdsBefore, voice.holdsAfter, voice.span);
-    // A held subject's clock stands still at the edge it holds: -1 before, 1 after, 0 playing.
-    const still = raw < 0 ? -1 : voice.holdsAfter && raw > voice.span ? 1 : 0;
+    const elapsed = frozenTime(raw, voice.freezesBefore, voice.freezesAfter, voice.span);
+    // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
+    const still = raw < 0 ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
     const phase = phaseAt(elapsed, duration, voice.passes);
     const pass = passAt(elapsed, duration, voice.passes);
@@ -77,7 +77,7 @@ export function influence(voice, subject, now, held) {
     reading.horizon = this.horizonFor(voice, held.delay, now);
     const tick = this.opts.stepMs;
     if (voice.patch.step && held.probed !== now && still >= 0) {
-        // Held after, it steps once more to where its last pass ended, and no further.
+        // Frozen after, it steps once more to where its last pass ended, and no further.
         const to = still === 1 ? voice.timeAt(held.delay + voice.span) : now;
         if (tick !== undefined && tick > 0 && !this.reducedNow)
             this.tick(voice, subject, held, tick, to);
@@ -89,19 +89,27 @@ export function influence(voice, subject, now, held) {
         }
     }
     let delta = null;
-    // Keys read even when silent: a `from: 'current'` voice takes its base on its first read.
-    if (voice.built) {
+    // A keys voice in a locus reads at weight 0 too: having a delta makes it a member, and the
+    // locus folds at its first member's place.
+    if (silent(voice, weight) && (voice.built === null || voice.spec.locus === undefined)) {
+        // A `from: 'current'` voice takes its base on its first read, silent or not.
+        if (voice.built && voice.spec.from === 'current' && held.base === undefined) {
+            held.base = this.baseFor(voice, subject);
+            held.slope = this.slopeFor(voice, subject);
+        }
+    }
+    else if (voice.built) {
         held.phase = phase;
         delta = this.keyed(voice, subject, held);
     }
-    else if (!silent(voice, weight)) {
+    else {
         delta = voice.patch.at(phase, subject, setting);
     }
     held.delta = delta;
     held.probed = now;
     held.seeks = voice.seeks;
     if (history !== undefined)
-        remember(this, voice, held);
+        remember(this, voice, subject, held);
     if (reading.kept !== keptBefore && !voice.keeping)
         stateful(this, voice);
     if (delta === null)
@@ -222,7 +230,7 @@ export function isRest(delta) {
     }
     return true;
 }
-/** Whether a rest-less channel's influence is switched on, across a band rather than an edge. */
+/** Whether a rest-less channel's contribution is switched on, across a band rather than an edge. */
 export function passes(was, w) {
     const { on, off } = this.band;
     return w >= on ? true : w <= off ? false : (was ?? w >= on);
@@ -281,10 +289,9 @@ export function folded(subject, out, dry = false, except) {
  * voices on them; a subject numbered since the frame's fill folds every voice, laned ones included.
  */
 export function linked(subject) {
-    const now = this.now;
-    const head = Number.isNaN(now) ? null : this.chain(subject, now);
+    const head = Number.isNaN(this.now) ? null : this.chain(subject);
     this.linkedLaned =
-        head !== null && this.lanes?.prepare(head.slot, subject, now, this.version, head) === true;
+        head !== null && this.lanes?.prepare(head.slot, subject, this.version, head) === true;
     return head;
 }
 /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */
@@ -450,13 +457,13 @@ export function foldLoci(subject, pose, head, laned, dry, except, owed) {
         this.locusDepth--;
     }
 }
-/** `influence`, or for a dry fold a subject already probed this frame, without advancing it. */
+/** `contribution`, or for a dry fold a subject already probed this frame, without advancing it. */
 export function read(voice, subject, now, dry, held) {
     if (dry) {
         if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
             const setting = voice.setting;
             // The setting the probe that read the delta had, but for `dt`: a dry read advances nothing.
-            const elapsed = heldTime(voice.elapsedAt(now) - held.delay, voice.holdsBefore, voice.holdsAfter, voice.span);
+            const elapsed = frozenTime(voice.elapsedAt(now) - held.delay, voice.freezesBefore, voice.freezesAfter, voice.span);
             setting.timestamp = now;
             setting.dt = 0;
             setting.elapsed = elapsed;
@@ -471,5 +478,5 @@ export function read(voice, subject, now, dry, held) {
             return held.delta;
         }
     }
-    return this.influence(voice, subject, now, held);
+    return this.contribution(voice, subject, now, held);
 }

package/dist/gather.d.ts

@@ -22,3 +22,9 @@ export declare function foldDelta<I, O>(this: Lanes<I, O>, chans: readonly Laned
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */
 export declare function foldRun<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, xs: Float64Array, w: number): void;
 export declare function foldInto<I, O>(this: Lanes<I, O>, ch: Laned, slot: number, value: unknown, w: number): void;
+/**
+ * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the
+ * general path's `apply` decides it from the same band state on the same record, so a subject
+ * moving between the paths carries it.
+ */
+export declare function gate<I, O>(this: Lanes<I, O>, ch: Laned, w: number): boolean;

package/dist/gather.js

@@ -171,6 +171,8 @@ export function foldInto(ch, slot, value, w) {
         gatherInto(this, this.into, ch, slot, value, w);
         return;
     }
+    if (ch.op === 'last' && !this.gate(ch, w))
+        return;
     const values = ch.values;
     if (ch.scalar) {
         values[slot] = foldNumber(ch.op, values[slot], value, w);
@@ -184,3 +186,19 @@ export function foldInto(ch, slot, value, w) {
         values[base + a] = foldNumber(ch.op, values[base + a], v, w);
     }
 }
+/**
+ * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the
+ * general path's `apply` decides it from the same band state on the same record, so a subject
+ * moving between the paths carries it.
+ */
+export function gate(ch, w) {
+    const lane = this.folding;
+    const rec = this.rec;
+    const i = lane.chans.indexOf(ch);
+    const bands = rec.bands ?? new Uint8Array(lane.chans.length);
+    rec.bands = bands;
+    const band = bands[i];
+    const on = this.host.passes(band === 0 ? undefined : band === 1, w);
+    bands[i] = on ? 1 : 2;
+    return on;
+}

package/dist/handle.d.ts

@@ -1,4 +1,4 @@
-import type { FadeOptions, Handle } from './types.js';
+import type { FadeOptions, FitResult, Handle } 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> {
@@ -9,17 +9,39 @@ export interface HandleHost<I, O> {
     /** The voice's clock jumped: for an owner, so did every clock it holds. */
     sought(voice: Voice<I, O>): void;
     fade(voice: Voice<I, O>, opts: FadeOptions<I> | undefined): void;
+    rise(voice: Voice<I, O>, opts: {
+        over?: number;
+    } | undefined): void;
     weightOf(voice: Voice<I, O>, subject: I): number;
+    /** Records a write the host made, which `again` makes once more where a seek replays it. */
+    record(label: string, again: () => void): void;
 }
-/** A voice's handle: the host's only way to control a voice once cued. */
+/** What a handle answers for a voice a history store paged out, which left long ago. */
+export interface Gone {
+    weight: number;
+    played: boolean;
+}
+/**
+ * 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
+ * revives it puts the revived voice behind the same handle.
+ */
 export declare class VoiceHandle<I, O> implements Handle<I> {
     #private;
     readonly id: number;
     constructor(voice: Voice<I, O>, host: HandleHost<I, O>);
+    /** The voice behind a handle; null while a history store holds it. */
+    static voiceOf<I, O>(h: VoiceHandle<I, O>): Voice<I, O> | null;
+    /** Lets go of a voice a history store paged out. */
+    static page<I, O>(h: VoiceHandle<I, O>, gone: Gone): void;
+    /** Puts a voice revived from a history store behind the handle it had. */
+    static rehome<I, O>(h: VoiceHandle<I, O>, voice: Voice<I, O>): void;
     get state(): Handle<I>['state'];
     get owner(): Handle<I> | undefined;
     get played(): Promise<boolean>;
     get done(): Promise<void>;
+    /** How a span's children were last fitted; undefined for any voice but a span. */
+    get result(): FitResult | undefined;
     get weight(): number;
     set weight(w: number);
     get rate(): number;
@@ -27,5 +49,8 @@ export declare class VoiceHandle<I, O> implements Handle<I> {
     ramp(r: number, over: number): void;
     seek(elapsed: number): void;
     fade(opts?: FadeOptions<I>): void;
+    rise(opts?: {
+        over?: number;
+    }): void;
     weightOf(subject: I): number;
 }

package/dist/handle.js

@@ -1,56 +1,105 @@
 import { retime } from './clock.js';
-/** A voice's handle: the host's only way to control a voice once cued. */
+/**
+ * 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
+ * revives it puts the revived voice behind the same handle.
+ */
 export class VoiceHandle {
     id;
     #voice;
+    #gone = null;
     #host;
     constructor(voice, host) {
         this.id = voice.id;
         this.#voice = voice;
         this.#host = host;
     }
+    /** The voice behind a handle; null while a history store holds it. */
+    static voiceOf(h) {
+        return h.#voice;
+    }
+    /** Lets go of a voice a history store paged out. */
+    static page(h, gone) {
+        h.#voice = null;
+        h.#gone = gone;
+    }
+    /** Puts a voice revived from a history store behind the handle it had. */
+    static rehome(h, voice) {
+        h.#voice = voice;
+        h.#gone = null;
+    }
     get state() {
-        return this.#voice.state;
+        return this.#voice?.state ?? 'done';
     }
     get owner() {
-        return this.#voice.owner?.handle ?? undefined;
+        return this.#voice?.owner?.handle ?? undefined;
     }
     get played() {
-        return this.#voice.played;
+        return this.#voice?.played ?? Promise.resolve(this.#gone?.played ?? false);
     }
     get done() {
-        return this.#voice.done;
+        return this.#voice?.done ?? Promise.resolve();
+    }
+    /** How a span's children were last fitted; undefined for any voice but a span. */
+    get result() {
+        return this.#voice?.fitting?.report;
     }
     get weight() {
-        return this.#voice.weight;
+        return this.#voice?.weight ?? this.#gone?.weight ?? 0;
     }
+    // A write to a paged voice changes nothing: it had left when the host made it, as it has on replay.
     set weight(w) {
-        this.#voice.weight = w;
-        this.#host.changed(this.#voice);
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        voice.weight = w;
+        this.#host.changed(voice);
+        this.#host.record('weight', () => {
+            this.weight = w;
+        });
     }
     get rate() {
-        return this.#voice.rateAt(this.#host.nowFor(this.#voice));
+        const voice = this.#voice;
+        return voice === null ? 0 : voice.rateAt(this.#host.nowFor(voice));
     }
     set rate(r) {
         this.ramp(r, 0);
     }
     ramp(r, over) {
         const voice = this.#voice;
+        if (voice === null)
+            return;
         retime(voice, this.#host.nowFor(voice), r, over);
         this.#host.changed(voice);
+        this.#host.record('rate', () => this.ramp(r, over));
     }
     seek(elapsed) {
         const voice = this.#voice;
+        if (voice === null)
+            return;
         voice.rebase(this.#host.nowFor(voice));
         voice.anchorElapsed = elapsed;
         voice.seeks++;
         this.#host.sought(voice);
         this.#host.changed(voice);
+        this.#host.record('seek', () => this.seek(elapsed));
     }
     fade(opts) {
-        this.#host.fade(this.#voice, opts);
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        this.#host.fade(voice, opts);
+        this.#host.record('fade', () => this.fade(opts));
+    }
+    rise(opts) {
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        this.#host.rise(voice, opts);
+        this.#host.record('rise', () => this.rise(opts));
     }
     weightOf(subject) {
-        return this.#host.weightOf(this.#voice, subject);
+        const voice = this.#voice;
+        return voice === null ? 0 : this.#host.weightOf(voice, subject);
     }
 }

package/dist/held.js

@@ -49,6 +49,10 @@ export function held(voice, subject, now, slot) {
             voice.subjects.set(subject, none);
         return none;
     }
+    if (this.keys !== null) {
+        voice.keyed ??= new Set();
+        voice.keyed.add(this.keys.key(subject));
+    }
     const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
     const since = this.sinceOf(voice, delay);
     held = {
@@ -85,8 +89,8 @@ export function held(voice, subject, now, slot) {
     voice.seen++;
     if (delay > voice.latest) {
         voice.latest = delay;
-        // A later end can take a held voice live again.
-        if (voice.state === 'held')
+        // A later end can take a frozen voice live again.
+        if (voice.state === 'frozen')
             schedule(this, voice);
     }
     return held;
@@ -102,7 +106,7 @@ export function sinceOf(voice, delay) {
     return voice.owner === null ? t : mixTime(voice.owner, t);
 }
 export function shownOf(voice, since) {
-    return voice.holdsBefore && voice.opened < since ? voice.opened : 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) {

package/dist/history.d.ts

@@ -17,6 +17,19 @@ export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>):
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
 export declare function recordHost<I, O>(mix: Mixer<I, O>, now: number): void;
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
-export declare function record<I, O>(mix: Mixer<I, O>, held: Subject<unknown>, value: number): void;
+export declare function record<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, value: number): void;
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
-export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>): void;
+export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
+/**
+ * Under history, keeps the record a subject had when it left a voice, faded out of it or dropped,
+ * 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];