@msb235/blits 0.9.0 → 0.11.0

package/dist/revive.js

@@ -107,9 +107,11 @@ function packVoice(voice, keys) {
             e.seq,
             packHeld(voice, e.held),
             e.sync,
+            e.ramp,
+            e.parted,
         ]),
         parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over, r.seq]),
-        parted: [...(voice.parted ?? [])].map(([s, p]) => [keys.key(s), p.at, p.seq]),
+        parted: [...(voice.parted ?? [])].map(([s, p]) => p.ramp === undefined ? [keys.key(s), p.at, p.seq] : [keys.key(s), p.at, p.seq, p.ramp]),
     };
 }
 /** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
@@ -146,17 +148,22 @@ export function reviveVoice(mix, id, d) {
     }
     for (const [key, run] of d.runs)
         voice.motion?.unpack(subjectOf(key), run);
-    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync]) => ({
+    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync, ramp = null, parted = null]) => ({
         subject: subjectOf(key),
         at,
         seq,
         sync,
         held: unpackHeld(voice, p),
+        ramp,
+        parted,
     })));
     if (d.parts.length > 0)
         voice.parts = new Map(d.parts.map(([key, at, over, seq]) => [subjectOf(key), { at, over, seq }]));
     if (d.parted.length > 0)
-        voice.parted = new Map(d.parted.map(([key, at, seq]) => [subjectOf(key), { at, seq }]));
+        voice.parted = new Map(d.parted.map(([key, at, seq, ramp]) => [
+            subjectOf(key),
+            { at, seq, ramp: ramp ?? undefined },
+        ]));
     const h = mix.outs?.take(id);
     if (h === undefined)
         voice.handle = handle(mix, voice);

package/dist/rows.js

@@ -16,8 +16,11 @@ function same(a, b) {
 /** Takes a crowd row off its subject, to be placed again if a probe meets it again. */
 export function unplace(lanes, c, p) {
     const slot = c.list[p];
-    if (c.idle && slot >= 0)
-        reach(lanes, slot, -1);
+    if (slot >= 0) {
+        if (c.idle)
+            reach(lanes, slot, -1);
+        lanes.placed.remove(slot, c.voices[p].id);
+    }
     c.list[p] = -1;
     c.records[p] = undefined;
     c.deltas[p] = null;
@@ -167,15 +170,20 @@ export function bury(lanes, c, p) {
     lanes.crowdOf.delete(v.id);
     c.dead++;
 }
+/** Copies `n` numbers of a row; a view of them to hand `set` was three objects a row moved. */
+function carry(from, a, to, b, n) {
+    for (let i = 0; i < n; i++)
+        to[b + i] = from[a + i];
+}
 function copyRow(from, p, to, q, keys = from.keys) {
     from.fix(p);
     to.list[q] = from.list[p];
-    to.data.set(from.data.subarray(p * 8 /* Row.STRIDE */, (p + 1) * 8 /* Row.STRIDE */), q * 8 /* Row.STRIDE */);
-    to.hot.set(from.hot.subarray(p * from.stride, (p + 1) * from.stride), q * to.stride);
+    carry(from.data, p * 8 /* Row.STRIDE */, to.data, q * 8 /* Row.STRIDE */, 8 /* Row.STRIDE */);
+    carry(from.hot, p * from.stride, to.hot, q * to.stride, from.stride);
     copyKeys(keys, to, q);
     if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0)
         to.stale = true;
-    to.samples.set(from.samples.subarray(p * from.axes, (p + 1) * from.axes), q * to.axes);
+    carry(from.samples, p * from.axes, to.samples, q * to.axes, from.axes);
     to.deltas[q] = from.deltas[p] ?? null;
     to.records[q] = from.records[p];
     to.voices[q] = from.voices[p];
@@ -257,6 +265,8 @@ function leaveCrowd(lanes, c, p) {
     const slot = c.list[p];
     const rec = c.records[p];
     if (slot >= 0) {
+        // Its row is emptied or left behind with its crowd, so the subject has it placed no longer.
+        lanes.placed.remove(slot, c.voices[p].id);
         if (c.idle)
             reach(lanes, slot, -1);
         const w = reportedRow(lanes, c, p, slot);

package/dist/seek.d.ts

@@ -1,3 +1,8 @@
 import type { Transport } from './transport.js';
-/** Moves every mix on the transport to mix time `t`, as it stood at the end of that frame. */
-export declare function seek(transport: Transport, t: number): void;
+/**
+ * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
+ * the end of the frame numbered `to.frame`.
+ */
+export declare function seek(transport: Transport, to: number | {
+    readonly frame: number;
+}): void;

package/dist/seek.js

@@ -1,7 +1,9 @@
+import { heldAt } from './chain.js';
 import { schedule } from './due.js';
-import { copyHeld, last, lastWithin } from './history.js';
+import { fadesAt } from './fade.js';
+import { origin } from './held.js';
+import { apart, copyHeld, last, lastWithin } from './history.js';
 import { laneHost } from './hosts.js';
-import { Lanes } from './lanes.js';
 import { Leavings } from './leavings.js';
 import { move, nextFrame } from './move.js';
 import { ownerReading } from './owner.js';
@@ -11,14 +13,16 @@ import { Restored } from './restored.js';
 import { recount } from './roster.js';
 import { refitAll } from './spans.js';
 import { Store } from './store.js';
-import { hostAt, replay } from './tape.js';
-import { cover, cut } from './unpage.js';
+import { hostAhead, hostAt, replay } from './tape.js';
+import { cover, coverFrame, cut } from './unpage.js';
 /**
  * A voice's record of one subject as it stood at mix time `t`, from the latest copy kept by then;
  * undefined for a stateful record first made after `t`, which is met afresh. A stateless record
- * holds nothing that moves with time, so it is copied whenever it was made.
+ * holds nothing that moves with time, so it is copied whenever it was made. The weight its last
+ * probe by `t` read is not kept, and a lane holds it apart from the record, so the record reads 0
+ * until the next probe.
  */
-function restore(voice, live, t) {
+function restore(mix, voice, live, t, every) {
     const inputs = live.inputs?.filter((e) => e.at <= t);
     const snaps = live.snaps;
     if (snaps === undefined) {
@@ -28,15 +32,41 @@ function restore(voice, live, t) {
             h.stepped = t;
         // Whether it had rested by `t` is not kept; the next probe finds it again.
         h.rested = false;
+        h.weight = 0;
         h.inputs = inputs;
+        if (!(h.since <= t))
+            origin(mix, voice, h);
         return h;
     }
     const snap = last(snaps, t, true);
     if (snap === undefined)
         return undefined;
     const h = copyHeld(voice, snap.held);
+    h.weight = 0;
+    if (snap.at < t)
+        h.copied = true;
     h.snaps = snaps.slice(0, snaps.indexOf(snap) + 1);
     h.inputs = inputs;
+    // A start still ahead when the copy was kept may have moved before `t`, with no copy between.
+    if (!(h.since <= snap.at))
+        origin(mix, voice, h);
+    if (voice.patch.step !== undefined && (snap.ahead !== undefined || t - snap.at >= every)) {
+        const ahead = snap.ahead;
+        // Steps counted from a start that has moved since are not this record's.
+        if (ahead === undefined || ahead.since !== h.since)
+            snap.ahead = {
+                put: h,
+                sought: t,
+                since: h.since,
+                at: snap.at,
+                ticks: h.ticks,
+                state: undefined,
+            };
+        else {
+            ahead.put = h;
+            ahead.sought = t;
+        }
+    }
     return h;
 }
 /** Takes a voice cued after the moment sought out of the mix, until the tape cues it again. */
@@ -71,9 +101,15 @@ function restoreVoice(mix, voice, t, seq) {
             voice.parts = null;
     }
     if (voice.parted !== null) {
-        for (const [subject, p] of voice.parted)
-            if (p.seq > seq)
-                voice.parted.delete(subject);
+        for (const [subject, p] of voice.parted) {
+            if (p.seq <= seq)
+                continue;
+            voice.parted.delete(subject);
+            if (p.ramp === undefined || p.ramp.seq > seq)
+                continue;
+            voice.parts ??= new Map();
+            voice.parts.set(subject, p.ramp);
+        }
         if (voice.parted.size === 0)
             voice.parted = null;
     }
@@ -87,25 +123,22 @@ function restoreVoice(mix, voice, t, seq) {
     voice.unreachedBits = null;
     voice.seeks++;
     const left = voice.left?.all() ?? [];
+    if (voice.left !== null)
+        fadesAt(voice, voice.left.after(cut), seq);
     voice.left = Leavings.from(left.filter((e) => e.seq <= seq));
     const future = Leavings.from(left.filter((e) => e.seq > seq));
     let records = voice.subjects;
     if (!(records instanceof Restored)) {
-        records = new Restored(records, (live, least, top) => {
-            const h = restore(voice, live, least);
+        const every = apart(mix.opts.history);
+        const now = (subject, held, least, seq) => heldAt(voice, subject, held, least, seq);
+        records = new Restored(records, now, (live, least, top) => {
+            const h = restore(mix, voice, live, least, every);
             if (h === undefined)
                 return h;
             if (h.reaches)
                 voice.seen++;
             if (h.rested)
                 voice.restedCount++;
-            if (!(h.since <= least)) {
-                // Kept while its origin was still ahead: where the controls put back place it now.
-                h.since = mix.sinceOf(voice, h.delay);
-                h.shown = mix.shownOf(voice, h.since);
-                if (h.ticks === 0 && h.stepped > h.since)
-                    h.stepped = h.since;
-            }
             if (!(h.since <= top)) {
                 voice.early ??= [];
                 voice.early.push(h);
@@ -127,8 +160,11 @@ function stateAt(voice, t) {
         return 'frozen';
     return 'live';
 }
-/** Moves every mix on the transport to mix time `t`, as it stood at the end of that frame. */
-export function seek(transport, t) {
+/**
+ * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
+ * the end of the frame numbered `to.frame`.
+ */
+export function seek(transport, to) {
     if (transport.projecting)
         throw new Error('blits: a projection does not seek');
     const history = transport.history;
@@ -139,25 +175,42 @@ export function seek(transport, t) {
         throw new Error('blits: seeking needs history.tape, which keeps the calls a seek plays again');
     if (Number.isNaN(transport.now))
         throw new Error('blits: a mix that has never synced has nothing to seek');
-    if (t === Number.POSITIVE_INFINITY)
-        throw new RangeError('blits: a mix seeks to a finite time');
-    if (!(t >= transport.born))
-        throw new Error(`blits: ${t} is older than this mix's history reaches`);
-    cover(transport, t);
-    if (t >= transport.now) {
+    let t;
+    let frame;
+    if (typeof to === 'number') {
+        t = to;
+        if (t === Number.POSITIVE_INFINITY)
+            throw new RangeError('blits: a mix seeks to a finite time');
+        if (!(t >= transport.born))
+            throw new Error(`blits: ${t} is older than this mix's history reaches`);
+        cover(transport, t);
+        if (t < transport.now) {
+            frame = transport.frames.at(t);
+            if (frame === undefined)
+                throw new Error(`blits: ${t} is older than this mix's history reaches`);
+        }
+    }
+    else {
+        const f = coverFrame(transport, to.frame);
+        t = f.at;
+        // The frame being played is where the mix stands; any other is behind it, whatever its time.
+        if (f.seq !== transport.seq)
+            frame = f;
+    }
+    if (frame === undefined) {
         // Ahead, under the rate the recorded calls up to `t` set, past any frames rate 0 held at `t`.
         const last = replay(transport, (at) => (transport.pace === null ? at : transport.pace.reading(at)) <= t);
-        const u = Number.isNaN(last) ? hostAt(transport, t) : Math.max(last, hostAt(transport, t));
+        const at = hostAhead(transport, t);
+        const u = Number.isNaN(last) ? at : Math.max(last, at);
         if (!Number.isFinite(u))
             throw new RangeError(`blits: the mix's rate never reaches ${t}`);
         transport.u = u;
-        for (const m of transport.members)
-            move(m, t);
+        // A call played at `t` itself moved the mixes there before it, as a sync does.
+        if (Number.isNaN(last) || transport.now !== t)
+            for (const m of transport.members)
+                move(m, t);
     }
     else {
-        const frame = transport.frames.at(t);
-        if (frame === undefined)
-            throw new Error(`blits: ${t} is older than this mix's history reaches`);
         // On the frame itself, its own host time: rate 0 may have held the clock there for several.
         const u = frame.at === t ? frame.u : hostAt(transport, t);
         const seq = frame.seq;
@@ -219,12 +272,14 @@ function back(mix, t, seq, on) {
     mix.retired = [];
     // Owners hold what is back; a voice that went live again counts its place in its owner anew.
     for (const voice of kept)
-        if (voice.holding !== null)
+        if (voice.holding !== null) {
             voice.holding.children = kept.filter((v) => v.owner === voice);
+            voice.holding.back(seq);
+        }
     // Rebuilt from the voices that are back: the lanes, the chains and every count the fold reads.
     const oldLanes = mix.lanes;
-    if (oldLanes !== null)
-        mix.lanes = new Lanes(laneHost(mix));
+    if (oldLanes !== null && mix.lanesOf !== null)
+        mix.lanes = new mix.lanesOf(laneHost(mix));
     mix.chains = new Store();
     mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
     recount(mix);

package/dist/shared.d.ts

@@ -1,3 +1,8 @@
+/**
+ * The package version, for a fact whose shape follows the code too closely to version by hand:
+ * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
+ */
+export declare const release = "0.11.0";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -1,3 +1,8 @@
+/**
+ * The package version, for a fact whose shape follows the code too closely to version by hand:
+ * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
+ */
+export const release = '0.11.0';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/signals.d.ts

@@ -7,6 +7,16 @@ export declare const heard: (signal: object) => boolean;
  * @category signal
  */
 export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]): Signal<I, H>;
+/** A blend member's share of its signal's read `k`: the members' stops sit evenly along 0..1. */
+export declare function shareOf(k: number, i: number, stops: number): number;
+/**
+ * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it: the hat of `by`'s read at the
+ * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of
+ * its members, such as one member played alone.
+ *
+ * @category signal
+ */
+export declare function share<I, H = unknown>(by: Signal<I, H>, i: number, n: number): Signal<I, H>;
 /**
  * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
  * `assess` and a history's `inputs` to treat it as one. Two uses:

package/dist/signals.js

@@ -27,6 +27,23 @@ export function peak(...signals) {
         return out;
     }, signals);
 }
+/** A blend member's share of its signal's read `k`: the members' stops sit evenly along 0..1. */
+export function shareOf(k, i, stops) {
+    const d = stops === 0 ? 0 : Math.abs(k * stops - i);
+    return d >= 1 ? 0 : 1 - d;
+}
+/**
+ * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it: the hat of `by`'s read at the
+ * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of
+ * its members, such as one member played alone.
+ *
+ * @category signal
+ */
+export function share(by, i, n) {
+    if (!Number.isInteger(n) || n < 1 || !Number.isInteger(i) || i < 0 || i >= n)
+        throw new Error(`blits: share wants a member 0 to ${n - 1}, not ${i}`);
+    return marked((subject, setting) => shareOf(by(subject, setting), i, n - 1), [by]);
+}
 const touch = () => {
     reading.inputs++;
 };

package/dist/store.d.ts

@@ -20,3 +20,14 @@ export declare class Store<K, V> {
     delete(key: K): void;
     clear(): void;
 }
+/**
+ * A store over another, for a copy that must not write the one it reads: what is set or deleted
+ * here stays here, and a key deleted here is no longer read from the one under it.
+ */
+export declare class Masked<K, V> extends Store<K, V> {
+    private readonly under;
+    private readonly hidden;
+    constructor(under: Store<K, V>);
+    get(key: K): V | undefined;
+    delete(key: K): void;
+}

package/dist/store.js

@@ -62,6 +62,25 @@ export class Store {
         this.strong.clear();
     }
 }
+/**
+ * A store over another, for a copy that must not write the one it reads: what is set or deleted
+ * here stays here, and a key deleted here is no longer read from the one under it.
+ */
+export class Masked extends Store {
+    under;
+    hidden = new Store();
+    constructor(under) {
+        super();
+        this.under = under;
+    }
+    get(key) {
+        return super.get(key) ?? (this.hidden.get(key) ? undefined : this.under.get(key));
+    }
+    delete(key) {
+        super.delete(key);
+        this.hidden.set(key, true);
+    }
+}
 /** No key held inline. */
 const none = Symbol('none');
 /** A Map's key equality, SameValueZero: NaN finds NaN. */

package/dist/strays.js

@@ -1,6 +1,6 @@
 import { unpart } from './fade.js';
 import { pageOut } from './paging.js';
-import { record } from './tape.js';
+import { record, unplayable } from './tape.js';
 /** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
 export function stray(mix, motion, subject) {
     const list = mix.strays.get(subject);
@@ -49,7 +49,12 @@ export function motionOwner(mix) {
             const m = mix.deref();
             if (m === undefined)
                 return;
-            record(m, 'motion', () => {
+            record(m, 'motion', (stage) => {
+                const to = stage.mix(m);
+                if (to === undefined)
+                    return;
+                if (to !== m)
+                    return changeAhead(to, id, motion, subject, change);
                 const v = cuedById(m, id) ?? m.gone.find((g) => g.id === id);
                 (v?.motion ?? motion).change(subject, { ...change });
             });
@@ -79,6 +84,49 @@ export function motionOwner(mix) {
         },
     };
 }
+/**
+ * A retarget or push the tape holds, made for a read ahead: kept on its transport for the patch
+ * to apply as it reads, since the patch's own state is the live mix's.
+ */
+function changeAhead(to, id, motion, given, change) {
+    const subject = given;
+    const v = cuedById(to, id);
+    let at = change.at;
+    if (v !== undefined) {
+        // As the patch asks its mix live: a subject faded out of the voice is back, and a change with
+        // no time takes the voice's at this frame, or the subject's own where it is yet to be met.
+        const parted = v.parted?.has(subject) === true;
+        if (parted)
+            unpart(to, v, subject);
+        if (at === undefined) {
+            const frame = frameOf(to, v, subject);
+            const back = parted ? timeIn(to, v, v.spec.stagger ? v.spec.stagger(subject) : 0) : frame;
+            if (!Number.isNaN(frame))
+                at = frame;
+            else if (!Number.isNaN(back))
+                at = back;
+        }
+    }
+    if (at === undefined)
+        unplayable('a change to a motion made before its voice met the subject');
+    const stamped = at;
+    const made = to.transport.ahead;
+    let bySubject = made.get(motion);
+    if (bySubject === undefined) {
+        bySubject = new Map();
+        made.set(motion, bySubject);
+    }
+    const list = bySubject.get(subject);
+    const c = { at, to: change.to, v: change.v };
+    if (list === undefined)
+        bySubject.set(subject, [c]);
+    else {
+        let i = list.length;
+        while (i > 0 && list[i - 1].at > stamped)
+            i--;
+        list.splice(i, 0, c);
+    }
+}
 /** The voice in the list with this id, which is in id order. */
 export function cuedById(mix, id) {
     const cued = mix.cued;

package/dist/tape.d.ts

@@ -1,24 +1,49 @@
+import type { Mixer } from './mixer.js';
 import type { Pace } from './pace.js';
 import type { Transport } from './transport.js';
 import type { Tape } from './types.js';
+/**
+ * Where a recorded call is made again: on the mixes the host made it on, or, for a read ahead, on
+ * its copies of them.
+ */
+export interface Stage {
+    transport(of: Transport): Transport;
+    /** The mix standing for `of`; undefined where a read ahead has no copy of it. */
+    mix<I, O>(of: Mixer<I, O>): Mixer<I, O> | undefined;
+}
+/** Refuses a recorded call a read ahead's copies cannot take. */
+export declare function unplayable(what: string): never;
 /**
  * The tape `history.tape` makes for a transport, stamping each call with the host time it was made
  * at: rate 0 holds mix time still across frames, and host time tells them apart.
  */
 export declare function tapeOf(transport: Transport): Tape | undefined;
-/** Records a host call, which `again` makes once more when the mix plays past it after a seek. */
+/**
+ * Records a host call, which `again` makes once more when the mix plays past it after a seek, or
+ * when a read ahead does, on the stage it is given.
+ */
 export declare function record(on: {
     readonly tape: Tape | undefined;
     readonly replaying: boolean;
     readonly projecting: boolean;
-}, label: string, again: () => void): void;
+}, label: string, again: (stage: Stage) => void): void;
 /** The host time at which the mix clock reads `t`, under the rate it has now. */
 export declare function hostAt(clock: {
     readonly pace: Pace | null;
 }, t: number): number;
+/**
+ * The host time a move ahead to mix time `t` lands at: never behind the clock's own, since rate 0
+ * reads `t` at every host time from the earliest `hostAt` gives, and a call stamped earlier than
+ * one already on the tape would cut it out of order.
+ */
+export declare function hostAhead(clock: {
+    readonly pace: Pace | null;
+    readonly u: number;
+}, t: number): number;
 /**
  * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
  * frame of its own with every mix on the transport moved to where it stood then, as the host made
- * them. Answers the host time of the last frame it played, NaN for none.
+ * them. Answers the host time of the last frame it played, NaN for none. Given `onto` and the
+ * stage of its copies, it makes them on those, and the caller puts the tape back.
  */
-export declare function replay(transport: Transport, due: (u: number) => boolean): number;
+export declare function replay(transport: Transport, due: (u: number) => boolean, onto?: Transport, on?: Stage): number;

package/dist/tape.js

@@ -1,4 +1,13 @@
 import { move } from './move.js';
+const live = { transport: (of) => of, mix: (of) => of };
+/** The stage the tape is playing calls on; the live one outside a read ahead's replay. */
+let stage = live;
+/** What a call threw on a read ahead's stage, for `replay` to throw once the tape has the entry back. */
+let failed;
+/** Refuses a recorded call a read ahead's copies cannot take. */
+export function unplayable(what) {
+    throw new Error(`blits: the tape holds ${what}, which a read ahead cannot play; seek there to see it`);
+}
 /** What a recorded call's `invert` gives: a mix goes back by restoring, never by undoing a call. */
 const undone = { apply() { }, invert: () => undone };
 /**
@@ -15,7 +24,10 @@ export function tapeOf(transport) {
         coalesceWindowMs: 0,
     });
 }
-/** Records a host call, which `again` makes once more when the mix plays past it after a seek. */
+/**
+ * Records a host call, which `again` makes once more when the mix plays past it after a seek, or
+ * when a read ahead does, on the stage it is given.
+ */
 export function record(on, label, again) {
     const tape = on.tape;
     if (tape === undefined || on.replaying || on.projecting)
@@ -23,7 +35,16 @@ export function record(on, label, again) {
     const op = {
         label,
         apply() {
-            again();
+            if (stage === live)
+                again(stage);
+            // Thrown inside the tape's `redo`, it would leave the tape without the entry.
+            else
+                try {
+                    again(stage);
+                }
+                catch (e) {
+                    failed ??= { error: e };
+                }
         },
         invert: () => undone,
     };
@@ -33,16 +54,26 @@ export function record(on, label, again) {
 export function hostAt(clock, t) {
     return clock.pace === null ? t : clock.pace.timeOf(t);
 }
+/**
+ * The host time a move ahead to mix time `t` lands at: never behind the clock's own, since rate 0
+ * reads `t` at every host time from the earliest `hostAt` gives, and a call stamped earlier than
+ * one already on the tape would cut it out of order.
+ */
+export function hostAhead(clock, t) {
+    const at = hostAt(clock, t);
+    return clock.u > at ? clock.u : at;
+}
 /**
  * Makes the recorded calls `due` by the host time each was made at again, each host time's in a
  * frame of its own with every mix on the transport moved to where it stood then, as the host made
- * them. Answers the host time of the last frame it played, NaN for none.
+ * them. Answers the host time of the last frame it played, NaN for none. Given `onto` and the
+ * stage of its copies, it makes them on those, and the caller puts the tape back.
  */
-export function replay(transport, due) {
+export function replay(transport, due, onto = transport, on = live) {
     const tape = transport.tape;
     if (tape === undefined)
         return Number.NaN;
-    const u = transport.u;
+    const u = onto.u;
     let last = Number.NaN;
     try {
         for (;;) {
@@ -51,23 +82,30 @@ export function replay(transport, due) {
                 return last;
             if (at !== last) {
                 last = at;
-                transport.u = at;
-                const now = transport.pace === null ? at : transport.pace.reading(at);
-                if (now > transport.now)
-                    for (const m of transport.members)
+                onto.u = at;
+                const now = onto.pace === null ? at : onto.pace.reading(at);
+                if (now > onto.now)
+                    for (const m of onto.members)
                         move(m, now);
-                transport.tick(transport.now);
+                onto.tick(onto.now);
             }
             transport.replaying = true;
+            stage = on;
             try {
                 tape.redo();
             }
             finally {
                 transport.replaying = false;
+                stage = live;
+            }
+            if (failed !== undefined) {
+                const { error } = failed;
+                failed = undefined;
+                throw error;
             }
         }
     }
     finally {
-        transport.u = u;
+        onto.u = u;
     }
 }