@msb235/blits 0.9.0 → 0.11.0

package/dist/crowd.js

@@ -317,7 +317,10 @@ function copyVoice(c, p) {
     let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.FREEZES */);
     if (v.state === 'live' || v.state === 'frozen' || v.state === 'fading')
         f |= 1 /* Flag.PLAYING */;
-    if (v.freezesBefore || v.freezesAfter)
+    // A keys or fn voice an owner holds can turn back with the owner, which copies it no more.
+    if (v.freezesBefore ||
+        v.freezesAfter ||
+        (v.motion === undefined && (v.owner !== null || v.hidesPast)))
         f |= 256 /* Flag.FREEZES */;
     if (v.ramp === null &&
         v.owner === null &&

package/dist/cue.js

@@ -1,3 +1,4 @@
+import { blendOf } from './blend.js';
 import { checkHits } from './book.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
@@ -6,14 +7,15 @@ import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
+import { checkMarks } from './marks.js';
 import { motionOf } from './motion.js';
-import { adopt, ownerPatch, ownerReading } from './owner.js';
+import { adopt, Holding, ownerPatch, ownerReading } from './owner.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';
-import { record } from './tape.js';
+import { cuedById, motionOwner } from './strays.js';
+import { record, unplayable } from './tape.js';
 import { Voice } from './voice.js';
 export function cue(mix, spec) {
     const patch = spec.patch;
@@ -28,6 +30,8 @@ export function cue(mix, spec) {
         checkPlacement(mix, spec, anchor, owner);
     if (spec.hits !== undefined)
         checkHits(spec.hits, patch.duration);
+    if (spec.marks !== undefined)
+        checkMarks(spec.marks, 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);
@@ -51,7 +55,14 @@ export function cue(mix, spec) {
     const h = handle(mix, voice);
     voice.handle = h;
     // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
-    record(mix, 'cue', () => recue(mix, VoiceHandle.voiceOf(h) ?? lost(h)));
+    record(mix, 'cue', (stage) => {
+        const parked = VoiceHandle.voiceOf(h) ?? lost(h);
+        const to = stage.mix(mix);
+        if (to === mix)
+            recue(mix, parked);
+        else if (to !== undefined)
+            recue(to, aheadOf(to, parked));
+    });
     return h;
 }
 /** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
@@ -78,6 +89,10 @@ export function playable(mix, spec) {
         finiteRate(spec.rate);
     if (spec.seek !== undefined && !Number.isFinite(spec.seek))
         throw new RangeError(`blits: a voice's seek is a finite number of ms, not ${spec.seek}`);
+    if (spec.stepMs !== undefined && !(spec.stepMs >= 0 && spec.stepMs < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: a voice's stepMs is a finite number of ms, 0 or more, not ${spec.stepMs}`);
+    if (spec.catchUp !== undefined && spec.catchUp !== 'exact' && spec.catchUp !== 'fresh')
+        throw new RangeError(`blits: catchUp takes 'exact' or 'fresh', not ${String(spec.catchUp)}`);
     if (typeof spec.weight === 'number')
         plainWeight(spec.weight);
     fitsKit(patch, mix.kit);
@@ -110,6 +125,36 @@ function recue(mix, voice) {
         voice.state = 'live';
     enter(mix, voice);
 }
+/** Each read ahead's own blends, by the live blend its copies' members were cued in. */
+const blends = new WeakMap();
+/** A read ahead's copy of a voice a seek parked, as its cue left it, for the copy `to` to cue. */
+function aheadOf(to, parked) {
+    const copy = parked.copy(() => undefined);
+    if (parked.owner !== null) {
+        const owner = cuedById(to, parked.owner.id);
+        if (owner === undefined || owner.holding === null)
+            unplayable('a cue under an owner that has left');
+        copy.owner = owner;
+    }
+    if (copy.holding !== null)
+        copy.holding = new Holding();
+    if (copy.blend !== null) {
+        let own = blends.get(to);
+        if (own === undefined) {
+            own = new Map();
+            blends.set(to, own);
+        }
+        const live = copy.blend.of;
+        let of = own.get(live);
+        if (of === undefined) {
+            of = blendOf(copy.blend.of.by, copy.blend.of.stops);
+            own.set(live, of);
+        }
+        copy.blend = { of, i: copy.blend.i };
+        of.members.push(copy);
+    }
+    return copy;
+}
 function lost(h) {
     throw new Error(`blits: voice ${h.id} is paged out, and the seek that plays its cue again did not load it`);
 }
@@ -120,6 +165,7 @@ function enter(mix, voice) {
     const anchor = spec.anchor;
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
     const motion = voice.motion;
+    voice.parked = false;
     if (owner !== null)
         adopt(owner, voice);
     if (!Number.isNaN(mix.now)) {
@@ -131,7 +177,8 @@ function enter(mix, voice) {
     // A start the host gave by its own clock, where the mix's rate puts it.
     if (!Number.isNaN(voice.pinned) && voice.state === 'pending')
         pin(mix, voice, voice.pinned);
-    if (motion !== undefined) {
+    // A read ahead's copy leaves the patch asking the live mix for its time.
+    if (motion !== undefined && !mix.projecting) {
         mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
         mix.owner ??= motionOwner(new WeakRef(mix));
         motion.owner = mix.owner;

package/dist/departed.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Mark, Query } from './types.js';
+import type { MarkName, 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:
@@ -14,7 +14,8 @@ export interface Departed {
     readonly name: string | undefined;
     readonly tags: readonly string[];
     readonly writes: readonly unknown[];
-    readonly marks: Readonly<Record<Mark, number | undefined>>;
+    /** Its five, and those it placed inside itself. */
+    readonly marks: Readonly<Partial<Record<MarkName, number>>>;
     /** How many of the index's ends hold it. */
     held: number;
 }

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.