@msb235/blits 0.10.0 → 0.11.0

package/dist/departed.js

@@ -1,6 +1,5 @@
-import { markOf } from './marks.js';
+import { markOf, voiceMarks } 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.
@@ -12,9 +11,13 @@ export class DepartedIndex {
         // 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)
+        const marks = Object.create(null);
+        for (const mark of voiceMarks)
             marks[mark] = markOf(mix, voice, mark);
+        const inner = voice.spec.marks;
+        if (inner !== undefined)
+            for (const mark of Object.keys(inner))
+                marks[mark] = markOf(mix, voice, mark);
         const d = {
             id: voice.id,
             score: voice.spec.score,

package/dist/due.d.ts

@@ -10,3 +10,7 @@ export interface Due<I, O> {
 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>[];
+/** Puts voices in id order in place, those of one id left in the order they had; returns `list`. */
+export declare function byId<V extends {
+    readonly id: number;
+}>(list: V[]): V[];

package/dist/due.js

@@ -97,7 +97,20 @@ export function popDue(mix, now) {
             out.push(top.voice);
         }
     }
-    if (out.length > 1)
-        out.sort((a, b) => a.id - b.id);
-    return out;
+    return byId(out);
+}
+/** Past this many voices the built-in sort, which makes working arrays however few it is given. */
+const SHORT = 8;
+/** Puts voices in id order in place, those of one id left in the order they had; returns `list`. */
+export function byId(list) {
+    if (list.length > SHORT)
+        return list.sort((a, b) => a.id - b.id);
+    for (let i = 1; i < list.length; i++) {
+        const v = list[i];
+        let k = i;
+        for (; k > 0 && list[k - 1].id > v.id; k--)
+            list[k] = list[k - 1];
+        list[k] = v;
+    }
+    return list;
 }

package/dist/fade.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Subject, Voice } from './voice.js';
+import type { Left, Parted, Parting, 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. */
@@ -12,11 +12,18 @@ export declare function part<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject
 /** 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;
 /**
- * The record a read back finds a subject left a voice with: its own, or the voice's record for
- * subjects it does not reach while faded out of it, since a probe on either path may have left a
- * record of that or none.
+ * Keeps, under history, the record a subject leaves a voice with as it is let go of: for one faded
+ * out before the voice met it, a record saying it is not reached.
  */
-export declare function leftWith<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): Subject<unknown> | undefined;
+export declare function leaveVoice<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I): void;
+/**
+ * Puts back into a voice's fades, or a copy's, those of the subjects that left it after frame `seq`
+ * as they stood then: `leave` keeps them, since a drop or a subject brought back forgets them.
+ */
+export declare function fadesAt<I>(fades: {
+    parts: Map<I, Parting> | null;
+    parted: Map<I, Parted> | null;
+}, left: readonly Left<I>[], seq: number): void;
 export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, opts: {
     over?: number;
     at?: 'rest';

package/dist/fade.js

@@ -1,9 +1,10 @@
-import { changed } from './chain.js';
+import { changed, unlink } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
-import { unshare } from './everyone.js';
+import { unshare, unsight } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
-import { orphan } from './owner.js';
+import { markOf } from './marks.js';
+import { orphan, ownerReading } from './owner.js';
 import { startOf } from './place.js';
 import { scoreTouched } from './scored.js';
 import { lingers, refit } from './spans.js';
@@ -38,11 +39,12 @@ export function parting(voice, subject, now) {
  * its lane position and a motion patch's state for it, and reaches it no more.
  */
 export function part(mix, voice, subject, at) {
+    const ramp = voice.parts?.get(subject);
     voice.parts?.delete(subject);
     if (voice.parts?.size === 0)
         voice.parts = null;
     voice.parted ??= new Map();
-    voice.parted.set(subject, { at, seq: mix.transport.seq });
+    voice.parted.set(subject, { at, seq: mix.transport.seq, ramp });
     mix.parters.add(voice);
     forgetIn(mix, voice, subject);
     const motion = voice.motion;
@@ -55,31 +57,54 @@ export function unpart(mix, voice, subject) {
         return;
     // `forgetIn` keeps the subject's own record for a read back; without one, keep the voice's.
     if (voice.subjects.get(subject) === undefined)
-        leave(mix, voice, subject, leftWith(mix, voice, subject));
+        leaveVoice(mix, voice, subject);
+    // Left with its parting still on, which a seek back to before this puts back.
+    forgetIn(mix, voice, subject);
     voice.parted.delete(subject);
     if (voice.parted.size === 0)
         voice.parted = null;
-    forgetIn(mix, voice, subject);
     const slot = mix.chains.get(subject)?.slot ?? -1;
     if (slot >= 0)
         mix.lanes?.rejoin(slot);
 }
 /**
- * The record a read back finds a subject left a voice with: its own, or the voice's record for
- * subjects it does not reach while faded out of it, since a probe on either path may have left a
- * record of that or none.
+ * Keeps, under history, the record a subject leaves a voice with as it is let go of: for one faded
+ * out before the voice met it, a record saying it is not reached.
  */
-export function leftWith(mix, voice, subject) {
+export function leaveVoice(mix, voice, subject) {
     const held = voice.subjects.get(subject);
     if (held !== undefined || voice.parted?.has(subject) !== true)
-        return held;
-    return voice.unreached ?? mix.unreachedOf(voice, mix.now);
+        leave(mix, voice, subject, held);
+    else
+        leave(mix, voice, subject, voice.unreached ?? mix.unreachedOf(voice, mix.now));
+}
+/**
+ * Puts back into a voice's fades, or a copy's, those of the subjects that left it after frame `seq`
+ * as they stood then: `leave` keeps them, since a drop or a subject brought back forgets them.
+ */
+export function fadesAt(fades, left, seq) {
+    for (const e of left) {
+        const parted = e.parted;
+        if (parted !== null && parted.seq <= seq) {
+            fades.parted ??= new Map();
+            fades.parted.set(e.subject, parted);
+            continue;
+        }
+        const ramp = e.ramp ?? parted?.ramp;
+        if (ramp === undefined || ramp === null || ramp.seq > seq)
+            continue;
+        fades.parts ??= new Map();
+        fades.parts.set(e.subject, ramp);
+    }
 }
 /** Drops a voice's record of a subject and relinks the subject's chain without it. */
 function forgetIn(mix, voice, subject) {
     const head = mix.chains.get(subject);
-    if (head !== undefined && head.slot >= 0)
+    if (head !== undefined && head.slot >= 0) {
         unreach(voice, head.slot, false);
+        // What the voice kept for the subject while it shared one record, which `weightOf` reads.
+        unsight(voice, head.slot);
+    }
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
         leave(mix, voice, subject, held);
@@ -93,8 +118,7 @@ function forgetIn(mix, voice, subject) {
     }
     if (head === undefined)
         return;
-    head.version = Number.NaN;
-    mix.relinks++;
+    unlink(mix, head);
     if (voice.laned && head.slot >= 0)
         mix.lanes?.part(voice.id, head.slot);
     mix.lanes?.refill();
@@ -153,12 +177,20 @@ export function beginRise(mix, voice, opts) {
     const over = mix.reduced ? 0 : (opts.over ?? voice.fade.in ?? voice.fade.out ?? 0);
     const left = out.rest || out.over === 0 ? 1 : 1 - (at - out.at) / out.over;
     const from = left < 0 ? 0 : left > 1 ? 1 : left;
+    // A voice faded before its start waits for it again, as a seek back finds it.
+    const waiting = Number.isNaN(mix.now) ||
+        (voice.owner === null ? at : ownerReading(voice.owner, at)) < voice.start;
     voice.out = null;
     voice.outAt = Number.POSITIVE_INFINITY;
-    voice.state = 'live';
+    voice.state = waiting ? 'pending' : 'live';
     voice.back = over > 0 && from < 1 ? { from, at, over } : null;
+    if (waiting)
+        changed(mix, voice);
     noted(mix, voice);
-    mix.lanes?.refill();
+    if (waiting)
+        mix.lanes?.invalidate();
+    else
+        mix.lanes?.refill();
 }
 /**
  * Fades a voice out from mix time `at`: ahead, it plays untouched until then and begins its fade
@@ -182,6 +214,11 @@ export function fadeAt(mix, voice, at, over) {
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
 }
+/** What a child leaving tells its owner of when the owner coasts. */
+function leaving(mix, child) {
+    const h = child.owner.holding;
+    h.left(child.passed ? markOf(mix, child, 'coast') : undefined, child.doneSeq);
+}
 /** Removes a voice, recording that it left at `at`, default now. */
 export function retire(mix, voice, at) {
     if (voice.holding === null)
@@ -209,6 +246,7 @@ export function retire(mix, voice, at) {
                 retire(mix, child, voice.doneAt);
     if (voice.owner !== null) {
         const span = voice.owner;
+        leaving(mix, voice);
         const owner = orphan(voice);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);

package/dist/fold.d.ts

@@ -1,6 +1,6 @@
 import type { Mixer } from './mixer.js';
 import type { Channel } from './types.js';
-import type { Subject, Voice } from './voice.js';
+import { type Subject, type Voice } from './voice.js';
 export type Key<O> = keyof O & string;
 export declare function near(a: unknown, b: unknown): boolean;
 /**

package/dist/fold.js

@@ -1,12 +1,13 @@
-import { passAt, phaseAt, phaseBefore, silent } from './clock.js';
+import { passAt, phaseAt, phaseBefore, silent, stepOf } from './clock.js';
 import { copy as copyValue, first } from './clone.js';
 import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
-import { recordHost, remember } from './history.js';
+import { apart, copyState, recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
 import { locusScratch } from './locus.js';
 import { moved } from './moved.js';
 import { readKeys } from './patch.js';
 import { reading } from './reading.js';
+import { checkWrites } from './voice.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
 const open = openRecord;
@@ -74,6 +75,8 @@ export function contribution(voice, subject, now, held) {
     if (early && !voice.holdsFirst)
         return null;
     const elapsed = voice.shownAt(raw);
+    if (Number.isNaN(elapsed))
+        return null;
     // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
     const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
@@ -100,7 +103,6 @@ export function contribution(voice, subject, now, held) {
     if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
         recordHost(this, now);
     reading.horizon = this.horizonFor(voice, held.delay, now);
-    const tick = this.opts.stepMs;
     if (voice.patch.step && held.probed !== now) {
         // Frozen after, it steps once more to where its last pass ended, and no further; run back
         // past its start, to where it reached it. Before a start it has yet to reach, it does not step.
@@ -114,8 +116,13 @@ export function contribution(voice, subject, now, held) {
                 held.stepped = held.since;
                 setting.dt = this.capped(now - held.since);
             }
-            if (tick !== undefined && tick > 0 && !this.reducedNow)
+            const tick = stepOf(this, voice);
+            if (tick !== undefined) {
+                // Never probed, it may be a record a seek put back.
+                if (Number.isNaN(held.probed) && held.snaps !== undefined)
+                    ahead(this, voice, subject, held, held.snaps, tick, to);
                 this.tick(voice, subject, held, tick, to);
+            }
             else if (still === 0 ? now !== held.stepped : to > held.stepped) {
                 if (still !== 0)
                     setting.dt = this.capped(to - held.stepped);
@@ -143,6 +150,8 @@ export function contribution(voice, subject, now, held) {
     }
     else {
         delta = voice.patch.at(phase, subject, setting);
+        if (voice.unchecked)
+            checkWrites(voice, delta);
     }
     held.delta = delta;
     held.probed = now;
@@ -178,6 +187,45 @@ export function keyed(voice, subject, held) {
         voice.holder = held;
     return delta;
 }
+/** How many whole intervals of `tick` a subject's step grid holds by mix time `to`. */
+function dueBy(held, tick, to) {
+    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
+    return Math.floor((to - held.since) / tick + 1e-9);
+}
+/**
+ * The first step of a record a seek put back from a copy: takes up the state that copy was last
+ * stepped ahead to, where the steps due now run past it, and keeps the copy's stepped ahead to the
+ * moment sought, so a mix sought back time after time does not step from the copy each time. Only
+ * where the same steps give the same state: a fixed interval, no `maxDt`, no host field read.
+ */
+function ahead(mix, voice, subject, held, snaps, tick, to) {
+    const from = snaps[snaps.length - 1];
+    const got = from?.ahead;
+    if (from === undefined || got === undefined || got.put !== held)
+        return;
+    got.put = null;
+    const reads = voice.patch.reads;
+    if (mix.opts.maxDt !== undefined || (reads !== undefined && reads.length > 0))
+        return;
+    // Stepped, rebuilt or placed anew since it was put back, its steps are no longer the copy's.
+    const was = from.held;
+    if (held.ticks !== was.ticks || held.since !== got.since || held.rebuilt !== was.rebuilt)
+        return;
+    const at = got.sought;
+    const usable = got.state !== undefined && got.ticks <= dueBy(held, tick, to);
+    if (usable) {
+        held.state = copyState(voice, got.state);
+        voice.setting.state = held.state;
+        held.ticks = got.ticks;
+    }
+    const last = usable ? got.at : from.at;
+    if (!(at < to) || at - last < apart(mix.opts.history))
+        return;
+    mix.tick(voice, subject, held, tick, at);
+    got.state = copyState(voice, held.state);
+    got.ticks = held.ticks;
+    got.at = at;
+}
 /**
  * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
  * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
@@ -188,8 +236,7 @@ export function tick(voice, subject, held, tick, to) {
     const setting = voice.setting;
     const frameDt = setting.dt;
     let n = held.ticks;
-    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
-    const due = Math.floor((to - held.since) / tick + 1e-9);
+    const due = dueBy(held, tick, to);
     const cap = this.opts.maxDt;
     if (cap !== undefined) {
         const most = Math.floor(cap / tick);

package/dist/frames.d.ts

@@ -15,6 +15,8 @@ export declare class Frames {
      * since rate 0 can hold the clock at `t` for many.
      */
     at(t: number): Frame | undefined;
+    /** The frame numbered `seq`, if it is still held. */
+    numbered(seq: number): Frame | undefined;
     /** Every frame held, oldest first. */
     all(): Frame[];
     set(frames: Frame[]): void;

package/dist/frames.js

@@ -48,6 +48,23 @@ export class Frames {
         }
         return found;
     }
+    /** The frame numbered `seq`, if it is still held. */
+    numbered(seq) {
+        const list = this.list;
+        let lo = this.head;
+        let hi = list.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const f = list[mid];
+            if (f.seq === seq)
+                return f;
+            if (f.seq < seq)
+                lo = mid + 1;
+            else
+                hi = mid - 1;
+        }
+        return undefined;
+    }
     /** Every frame held, oldest first. */
     all() {
         return this.list.slice(this.head);

package/dist/handle.d.ts

@@ -17,8 +17,11 @@ export interface HandleHost<I, O> {
         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;
+    /**
+     * Records a write the host made through `h`, which `again` makes once more where a seek replays
+     * it, on the handle it is given: `h`, or a read ahead's handle on its copy of the voice.
+     */
+    record(h: VoiceHandle<I, O>, label: string, again: (h: VoiceHandle<I, O>) => void): void;
 }
 /** Refuses a voice rate no clock can run at. */
 export declare function finiteRate(rate: number): void;

package/dist/handle.js

@@ -59,17 +59,25 @@ export class VoiceHandle {
     get 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.
+    /**
+     * The voice a write reaches: none while a history store holds it, or a seek back to before its
+     * cue has it waiting. It had left, or was yet to be cued, when the host made the write, as on
+     * replay, so the write changes nothing and the tape does not take it.
+     */
+    get #cued() {
+        const voice = this.#voice;
+        return voice === null || voice.parked ? null : voice;
+    }
     set weight(w) {
         plainWeight(w);
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         voice.weight = w;
         this.#host.changed(voice);
-        this.#host.record('weight', () => {
-            this.weight = w;
+        this.#host.record(this, 'weight', (h) => {
+            h.weight = w;
         });
     }
     get rate() {
@@ -81,7 +89,7 @@ export class VoiceHandle {
     }
     ramp(r, over) {
         finiteRate(r);
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
@@ -97,10 +105,10 @@ export class VoiceHandle {
             retime(voice, now, r, over);
         }
         this.#host.changed(voice);
-        this.#host.record('rate', () => this.ramp(r, over));
+        this.#host.record(this, 'rate', (h) => h.ramp(r, over));
     }
     seek(elapsed, opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return 'exact';
         voice.written = true;
@@ -114,24 +122,24 @@ export class VoiceHandle {
         voice.seeks++;
         const doubt = this.#host.sought(voice, opts?.state !== 'keep');
         this.#host.changed(voice);
-        this.#host.record('seek', () => this.seek(elapsed, opts));
+        this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));
         return doubt;
     }
     fade(opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         this.#host.fade(voice, opts);
-        this.#host.record('fade', () => this.fade(opts));
+        this.#host.record(this, 'fade', (h) => h.fade(opts));
     }
     rise(opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         this.#host.rise(voice, opts);
-        this.#host.record('rise', () => this.rise(opts));
+        this.#host.record(this, 'rise', (h) => h.rise(opts));
     }
     weightOf(subject) {
         const voice = this.#voice;

package/dist/held.d.ts

@@ -4,6 +4,12 @@ import type { Subject, Voice } from './voice.js';
 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, slot: number): Subject<unknown>;
+/**
+ * Where a new record met at `now` starts stepping: from its `since`, or from `now` for a voice that
+ * catches up `fresh`, on the `stepMs` grid. True where that skipped steps, so the state depends on
+ * when the subject was first probed.
+ */
+export declare function meet<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>, now: number): boolean;
 /**
  * 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.
@@ -20,6 +26,8 @@ export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sin
  * while it waited is made again for where its clock is.
  */
 export declare function begin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
+/** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
+export declare function origin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>): 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.

package/dist/held.js

@@ -1,4 +1,5 @@
 import { changed } from './chain.js';
+import { stepOf } from './clock.js';
 import { schedule } from './due.js';
 import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
@@ -53,11 +54,11 @@ export function held(voice, subject, slot) {
     held.delay = delay;
     held.since = since;
     held.shown = shown;
-    held.stepped = since < now ? since : now;
+    const fresh = meet(this, voice, held, now);
     held.rebuilt = voice.rebuilds;
     if (this.projecting) {
         held.from = held.stepped;
-        held.unknown = this.backward && voice.spec.from === 'current';
+        held.unknown = (this.backward && voice.spec.from === 'current') || fresh;
     }
     voice.subjects.set(subject, held);
     if (!(since <= now)) {
@@ -91,6 +92,30 @@ export function held(voice, subject, slot) {
     }
     return held;
 }
+/**
+ * Where a new record met at `now` starts stepping: from its `since`, or from `now` for a voice that
+ * catches up `fresh`, on the `stepMs` grid. True where that skipped steps, so the state depends on
+ * when the subject was first probed.
+ */
+export function meet(mix, voice, held, now) {
+    const since = held.since;
+    if (!(since < now)) {
+        held.stepped = now;
+        return false;
+    }
+    if (voice.spec.catchUp !== 'fresh' || voice.patch.step === undefined) {
+        held.stepped = since;
+        return false;
+    }
+    const tick = stepOf(mix, voice);
+    if (tick === undefined)
+        held.stepped = now;
+    else {
+        held.ticks = Math.floor((now - since) / tick + 1e-9);
+        held.stepped = since + held.ticks * tick;
+    }
+    return held.stepped > since;
+}
 /**
  * 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.
@@ -118,10 +143,19 @@ export function begin(mix, voice, now) {
     if (voice.anchorElapsed !== 0) {
         voice.seeks++;
         voice.rebuilds++;
+        // Kept with its controls, so a seek back to after this puts back the count its records hold.
+        voice.note(now, mix.transport.seq, true);
     }
     reorigin(mix, voice, now);
     changed(mix, voice);
 }
+/** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
+export function origin(mix, voice, held) {
+    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;
+}
 /**
  * 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.
@@ -132,10 +166,7 @@ export function reorigin(mix, voice, now) {
         return;
     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;
+        origin(mix, voice, held);
         if (!(held.since <= now))
             early[kept++] = held;
     }

package/dist/history.d.ts

@@ -19,12 +19,18 @@ export declare function same(a: unknown, b: unknown): boolean;
 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. */
 export declare function noted<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** A copy of the state a voice's patch keeps for a subject. */
+export declare function copyState<I, O>(voice: Voice<I, O>, state: unknown): unknown;
 /** A copy of a subject's record that shares nothing a read could change. */
 export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>): 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>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, value: number): void;
+/** How far apart, in mix ms, a record's copies are kept. */
+export declare function apart(history: {
+    readonly every?: number;
+}): number;
 /** 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>, subject: I, held: Subject<unknown>): void;
 /**