@msb235/blits 0.5.0 → 0.7.0

package/dist/seek.js

@@ -0,0 +1,311 @@
+import { index } from './chain.js';
+import { schedule } from './due.js';
+import { copyHeld, last, leftAt } from './history.js';
+import { laneHost } from './hosts.js';
+import { Lanes } from './lanes.js';
+import { move } from './move.js';
+import { ownerReading } from './owner.js';
+import { refitAll } from './spans.js';
+import { Store } from './store.js';
+import { hostAt, replay } from './tape.js';
+import { cover, 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.
+ */
+function restore(voice, live, t) {
+    const inputs = live.inputs?.filter((e) => e.at <= t);
+    const snaps = live.snaps;
+    if (snaps === undefined) {
+        // Nothing a step or `setting.keep` holds: what it keeps does not move with time.
+        const h = copyHeld(voice, live);
+        if (h.stepped > t)
+            h.stepped = t;
+        // Whether it had rested by `t` is not kept; the next probe finds it again.
+        h.rested = false;
+        h.inputs = inputs;
+        return h;
+    }
+    const snap = last(snaps, t, true);
+    if (snap === undefined)
+        return undefined;
+    const h = copyHeld(voice, snap.held);
+    h.snaps = snaps.slice(0, snaps.indexOf(snap) + 1);
+    h.inputs = inputs;
+    return h;
+}
+/**
+ * A voice's records after a seek back: each subject's is put back from the records it had, the first
+ * time it is asked for, since the subjects a store holds cannot be listed.
+ */
+class Restored extends Store {
+    was;
+    make;
+    left;
+    constructor(was, make, left) {
+        super();
+        this.was = was;
+        this.make = make;
+        this.left = left;
+    }
+    /** Subjects whose record has been put back or deleted, which `left` no longer answers for. */
+    settled = new Store();
+    get(key) {
+        const v = super.get(key);
+        if (v !== undefined)
+            return v;
+        // A subject that left after the moment sought had the record it left with, whatever it has now.
+        const kept = this.settled.get(key) === undefined ? this.left(key) : undefined;
+        this.settled.set(key, true);
+        const live = kept ?? this.was.get(key);
+        if (live === undefined)
+            return undefined;
+        this.was.delete(key);
+        const made = this.make(live);
+        if (made !== undefined)
+            super.set(key, made);
+        return made;
+    }
+    delete(key) {
+        super.delete(key);
+        this.was.delete(key);
+        this.settled.set(key, true);
+    }
+}
+/** Takes a voice cued after the moment sought out of the mix, until the tape cues it again. */
+function park(mix, voice) {
+    const owner = voice.owner;
+    if (owner?.holding) {
+        owner.holding.kids--;
+        if (voice.passed)
+            owner.holding.played--;
+    }
+    const motion = voice.motion;
+    if (motion !== undefined && motion.owner === mix.owner && motion.ownerId === voice.id)
+        motion.owner = null;
+    voice.park();
+}
+/** Puts a voice's controls and records back as they stood at mix time `t`. */
+function restoreVoice(voice, t) {
+    const log = voice.log;
+    const c = last(log, t, true) ?? log[0];
+    log.length = log.indexOf(c) + 1;
+    voice.anchorNow = c.anchorNow;
+    voice.anchorElapsed = c.anchorElapsed;
+    voice.rate = c.rate;
+    voice.ramp = c.ramp;
+    voice.weight = c.weight;
+    voice.out = c.out;
+    voice.start = c.start;
+    voice.outAt = c.outAt;
+    voice.outOver = c.outOver;
+    voice.outSet = c.outSet;
+    if (voice.reopen(t) && voice.owner?.holding)
+        voice.owner.holding.played--;
+    voice.doneAt = Number.POSITIVE_INFINITY;
+    if (voice.parts !== null) {
+        for (const [subject, r] of voice.parts)
+            if (r.at > t)
+                voice.parts.delete(subject);
+        if (voice.parts.size === 0)
+            voice.parts = null;
+    }
+    if (voice.parted !== null) {
+        for (const [subject, at] of voice.parted)
+            if (at > t)
+                voice.parted.delete(subject);
+        if (voice.parted.size === 0)
+            voice.parted = null;
+    }
+    voice.seen = 0;
+    voice.restedCount = 0;
+    voice.early = null;
+    voice.holder = null;
+    voice.keepOn = null;
+    voice.laned = false;
+    voice.unreached = null;
+    voice.unreachedBits = null;
+    voice.seeks++;
+    const left = voice.left;
+    voice.left = left === null ? null : left.filter((e) => e.at <= t);
+    const future = left === null ? [] : left.filter((e) => e.at > t);
+    voice.subjects = new Restored(voice.subjects, (live) => {
+        const h = restore(voice, live, t);
+        if (h === undefined)
+            return h;
+        if (h.reaches)
+            voice.seen++;
+        if (h.rested)
+            voice.restedCount++;
+        if (voice.state === 'pending') {
+            voice.early ??= [];
+            voice.early.push(h);
+        }
+        return h;
+    }, (key) => leftAt(future, key, t));
+}
+/** Each voice's state at mix time `t`, once every clock above it is back where it was. */
+function stateAt(voice, t) {
+    if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
+        return 'pending';
+    if (voice.out !== null && voice.out.at <= t)
+        return 'fading';
+    if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
+        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) {
+    if (transport.projecting)
+        throw new Error('blits: a projection does not seek');
+    const history = transport.history;
+    if (!history)
+        throw new Error('blits: seeking needs a mix made with history');
+    const tape = transport.tape;
+    if (tape === undefined)
+        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`);
+    const unpaged = cover(transport, t);
+    if (t >= transport.now)
+        replay(transport, () => t);
+    // Under the rate the recorded calls up to `t` set, ahead; behind, under the rate it had then.
+    const u = hostAt(transport, t);
+    if (!Number.isFinite(u))
+        throw new RangeError(`blits: the mix's rate never reaches ${t}`);
+    if (t >= transport.now) {
+        transport.u = u;
+        for (const m of transport.members)
+            move(m, t);
+    }
+    else {
+        const n = tape.depthAt(t);
+        if (n < tape.undoDepth())
+            tape.goto(n);
+        transport.undrop(t);
+        // What history kept after `t` is let go; the tape holds the calls that made it.
+        transport.announced = transport.announced.filter((a) => a.made <= t);
+        transport.pace?.cut(u);
+        transport.u = u;
+        transport.now = t;
+        for (const m of transport.members)
+            back(m, t);
+        cut(transport, t, unpaged);
+    }
+    // The host's clock reads on from here: its next sync reads `t` plus its time since its last.
+    transport.offset = transport.last - u;
+    transport.u = u;
+    transport.kept();
+    for (const m of transport.members) {
+        m.stir();
+        const bookers = m.bookers;
+        if (bookers !== null)
+            for (const b of bookers)
+                b.sought();
+    }
+}
+/** Puts one mix back as it stood at the end of frame `t`, its transport already there. */
+function back(mix, t) {
+    const all = [...mix.cued, ...mix.gone].sort((a, b) => a.id - b.id);
+    const kept = [];
+    const gone = [];
+    // Every motion patch takes back the changes made after `t`, which the tape makes again.
+    const motions = new Set();
+    for (const voice of all)
+        if (voice.motion !== undefined)
+            motions.add(voice.motion);
+    for (const voice of all)
+        if (voice.cuedAt > t)
+            park(mix, voice);
+        else if (voice.doneAt <= t)
+            gone.push(voice);
+        else
+            kept.push(voice);
+    for (const voice of kept)
+        restoreVoice(voice, t);
+    for (const voice of kept)
+        voice.state = stateAt(voice, t);
+    mix.cued = kept;
+    mix.gone = gone;
+    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)
+            voice.holding.children = kept.filter((v) => v.owner === voice);
+    // 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));
+    mix.chains = new Store();
+    mix.named = new Store();
+    mix.naming = 0;
+    mix.general = [];
+    for (const voice of kept)
+        index(mix, voice);
+    mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
+    mix.loci = kept.filter((v) => v.spec.locus !== undefined).length;
+    mix.anchored = kept.filter((v) => v.spec.anchor !== undefined).length;
+    mix.parters.clear();
+    for (const voice of [...kept, ...gone])
+        if (voice.parts !== null || voice.parted !== null)
+            mix.parters.add(voice);
+    mix.steps.push(null, ++mix.version);
+    mix.relinks++;
+    mix.pose = new Store();
+    if (mix.restStamps !== null)
+        mix.restStamps = new Store();
+    mix.pulled = [];
+    mix.pulledHeads = [];
+    mix.pulledSlots = new Int32Array(0);
+    mix.pulledVersion = Number.NaN;
+    mix.pulledRelinks = -1;
+    for (const voice of [...kept, ...gone]) {
+        voice.unreached = null;
+        voice.unreachedBits = null;
+        const blend = voice.blend?.of;
+        if (blend !== undefined) {
+            blend.frame = 0;
+            blend.reads = new Store();
+            blend.frames = new Float64Array(0);
+            blend.values = new Float64Array(0);
+        }
+    }
+    // A motion patch is asked for its time by the latest voice playing it.
+    mix.playing.clear();
+    for (const voice of kept) {
+        const motion = voice.motion;
+        if (motion === undefined)
+            continue;
+        mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
+        if (mix.owner !== null) {
+            motion.owner = mix.owner;
+            motion.ownerId = voice.id;
+        }
+    }
+    for (const motion of motions) {
+        if (oldLanes !== null && motion.watcher === oldLanes)
+            motion.watcher = null;
+        motion.rewind(t);
+    }
+    // What history kept after `t` is let go; the tape holds the calls that made it.
+    mix.hostLog = mix.hostLog.filter((e) => e.at <= t);
+    mix.sent = mix.sent.filter((e) => e.timestamp <= t);
+    mix.sentTo = t;
+    mix.pins = null;
+    for (const voice of kept)
+        if (voice.state === 'pending' && !Number.isNaN(voice.pinned)) {
+            mix.pins ??= new Map();
+            mix.pins.set(voice, voice.pinned);
+        }
+    refitAll(mix);
+    mix.due = [];
+    for (const voice of kept)
+        schedule(mix, voice);
+    mix.stir();
+    move(mix, t);
+}

package/dist/signals.d.ts

@@ -16,7 +16,8 @@ export declare function level<I, H = unknown>(initial?: number): Signal<I, H> &
 /**
  * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * unless `dt` is infinite.
  *
  * @category signal
  */
@@ -31,7 +32,7 @@ export declare function slew<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs,
  * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
  * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
  * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from`.
+ * A subject starts on its input, or at `from` unless `dt` is infinite.
  *
  * @category signal
  */

package/dist/signals.js

@@ -30,19 +30,25 @@ export function level(initial = 0) {
         },
     });
 }
-/** Where a follower starts for a subject: on its input, or at `from`, seen now so the next frame moves. */
-const firstSight = (target, from, now) => from === undefined ? { value: target, seen: Number.NaN } : { value: from, seen: now };
+/**
+ * Where a follower starts for a subject: on its input, or at `from`, seen now so the next frame
+ * moves. Under reduced motion it starts on its input, since every later frame would snap there.
+ */
+const firstSight = (target, from, setting) => from === undefined || !Number.isFinite(setting.dt)
+    ? { value: target, seen: Number.NaN }
+    : { value: from, seen: setting.timestamp };
 /**
  * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * unless `dt` is infinite.
  *
  * @category signal
  */
 export function slew(of, { riseMs = 0, fallMs = 0, from }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
-        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
+        const held = setting.keep(read, () => firstSight(target, from, setting));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;
@@ -66,14 +72,14 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
  * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
  * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
  * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from`.
+ * A subject starts on its input, or at `from` unless `dt` is infinite.
  *
  * @category signal
  */
 export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
-        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
+        const held = setting.keep(read, () => firstSight(target, from, setting));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;

package/dist/spans.d.ts

@@ -0,0 +1,29 @@
+import { type Fit, type SpanClaim } from './fit.js';
+import type { Mixer } from './mixer.js';
+import type { FitResult, SpanSpec, VoiceSpec } from './types.js';
+import type { Voice } from './voice.js';
+/** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
+export declare class Fitting {
+    readonly budget: number;
+    readonly claim: Omit<SpanClaim, 'left'>;
+    readonly fit: Fit;
+    readonly spill: 'instant' | 'overrun';
+    /** Where its children end or its budget does, whichever is later, ms on its own clock. */
+    end: number;
+    report: FitResult;
+    constructor(spec: SpanSpec<unknown>);
+}
+/** Refuses a voice a span cannot fit: one it would not own the timing of, or one with no end. */
+export declare function checkChild<I, O>(spec: VoiceSpec<I, O>, child: Voice<I, O>): void;
+/**
+ * Lays out a span's children and fits them into what is left of its budget, from its clock now.
+ * Only what is still to come moves: a playing child keeps its place and may change rate, a
+ * pending one is placed. A span held by a span is fitted again by its own span after.
+ */
+export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>): void;
+/** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */
+export declare function lingers<I, O>(span: Voice<I, O>, at: number): boolean;
+/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+export declare function lapse<I, O>(mix: Mixer<I, O>, now: number): void;
+/** Fits every span again, as after a seek put its children back. */
+export declare function refitAll<I, O>(mix: Mixer<I, O>): void;

package/dist/spans.js

@@ -0,0 +1,165 @@
+import { elapsedWith, retime } from './clock.js';
+import { retire } from './fade.js';
+import { defaultFit, layout, settle } from './fit.js';
+import { noted } from './history.js';
+import { nextFrame } from './move.js';
+import { ownerReading } from './owner.js';
+/** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
+export class Fitting {
+    budget;
+    claim;
+    fit;
+    spill;
+    /** Where its children end or its budget does, whichever is later, ms on its own clock. */
+    end;
+    report;
+    constructor(spec) {
+        const budget = spec.duration ?? Number.POSITIVE_INFINITY;
+        if (!(budget >= 0))
+            throw new Error('blits: a span lasts 0 ms or more');
+        const share = spec.share ?? 0.5;
+        if (!(share >= 0 && share <= 1))
+            throw new Error('blits: a span staggers by a share in 0..1');
+        this.budget = budget;
+        this.claim = {
+            budget,
+            priority: spec.priority ?? 'strong',
+            order: spec.order ?? 'queue',
+            share,
+        };
+        this.fit = spec.fit ?? defaultFit;
+        this.spill = spec.spill ?? 'instant';
+        this.end = Number.isFinite(budget) ? budget : 0;
+        this.report = { budget, length: 0, over: 0, skipped: 0, fell: false };
+    }
+}
+/** Refuses a voice a span cannot fit: one it would not own the timing of, or one with no end. */
+export function checkChild(spec, child) {
+    if (spec.start !== undefined || spec.anchor?.start !== undefined || spec.anchor?.in !== undefined)
+        throw new Error('blits: a span places the voices it holds, so one takes no start of its own');
+    if (child.holding !== null) {
+        if (child.fitting === null)
+            throw new Error('blits: a span holds voices and spans, not owners');
+    }
+    else if (!Number.isFinite(child.span))
+        throw new Error('blits: a span cannot fit a voice that never ends');
+}
+/** A span's own clock at the mix's now, from 0 while it has not started. */
+function clockOf(mix, span) {
+    if (Number.isNaN(mix.now))
+        return 0;
+    const t = ownerReading(span, mix.now);
+    return Number.isFinite(t) ? Math.max(0, t) : 0;
+}
+/** What a child's own clock reads at its span's `local`, 0 while it waits. */
+function elapsedIn(child, local) {
+    return child.state === 'pending' ? 0 : Math.max(0, elapsedWith(child, local));
+}
+/** How much of a child is left, voice ms at its own clock: what its span still has to fit. */
+function leftOf(child, local) {
+    const length = child.fitting !== null ? child.fitting.end : child.span;
+    return Math.max(0, length - elapsedIn(child, local));
+}
+/**
+ * Lays out a span's children and fits them into what is left of its budget, from its clock now.
+ * Only what is still to come moves: a playing child keeps its place and may change rate, a
+ * pending one is placed. A span held by a span is fitted again by its own span after.
+ */
+export function refit(mix, span) {
+    const fitting = span.fitting;
+    if (mix.projecting || span.state === 'done')
+        return;
+    const local = clockOf(mix, span);
+    const kids = (span.holding?.children ?? []).filter((c) => c.state !== 'done' && c.state !== 'frozen' && c.state !== 'fading' && leftOf(c, local) > 0);
+    const claims = kids.map((c) => {
+        const s = c.spec;
+        return {
+            natural: leftOf(c, local) / (s.rate ?? 1),
+            state: c.state === 'pending' ? 'pending' : 'playing',
+            faster: Math.max(1, s.faster ?? 1),
+            slower: Math.max(1, s.slower ?? 1),
+            overlap: s.overlap === true,
+            ballast: s.ballast === true && c.holding === null,
+            priority: s.priority ?? 'weak',
+        };
+    });
+    const claim = { ...fitting.claim, left: fitting.budget - local };
+    const { plan, fell } = settle(claim, claims, fitting.fit, fitting.spill);
+    const { at, length } = layout(claim, claims, plan);
+    kids.forEach((c, i) => {
+        const rate = (c.spec.rate ?? 1) * plan.rate[i];
+        const skipped = plan.skip[i] && c.holding === null;
+        let moved = false;
+        if (c.state === 'pending') {
+            const start = local + at[i];
+            const elapsed = skipped ? c.span : 0;
+            if (c.start !== start || c.rate !== rate || c.anchorElapsed !== elapsed || c.ramp !== null) {
+                c.start = start;
+                c.anchorNow = start;
+                c.anchorElapsed = elapsed;
+                c.rate = rate;
+                c.ramp = null;
+                moved = true;
+            }
+        }
+        else {
+            if (skipped) {
+                c.rebase(local);
+                c.anchorElapsed = c.span;
+                c.seeks++;
+                moved = true;
+            }
+            if (c.rate !== rate || c.ramp !== null) {
+                retime(c, local, rate, 0);
+                moved = true;
+            }
+        }
+        if (moved) {
+            mix.frame = nextFrame();
+            noted(mix, c);
+        }
+    });
+    if (kids.length > 0)
+        mix.lanes?.refill();
+    const reach = local + length;
+    const over = Number.isFinite(fitting.budget) ? Math.max(0, reach - fitting.budget) : 0;
+    const within = over < 1e-6;
+    const end = !Number.isFinite(fitting.budget) ? reach : within ? fitting.budget : reach;
+    fitting.report = {
+        budget: fitting.budget,
+        length: reach,
+        over: within ? 0 : over,
+        skipped: plan.skip.filter((s, i) => s && kids[i]?.holding === null).length,
+        fell,
+    };
+    if (end !== fitting.end) {
+        fitting.end = end;
+        noted(mix, span);
+        if (span.owner?.fitting)
+            refit(mix, span.owner);
+    }
+}
+/** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */
+export function lingers(span, at) {
+    const f = span.fitting;
+    return f !== null && Number.isFinite(f.budget) && ownerReading(span, at) < f.budget;
+}
+/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+export function lapse(mix, now) {
+    for (const span of mix.owners ?? []) {
+        const f = span.fitting;
+        if (f === null || span.state === 'done' || !Number.isFinite(f.budget))
+            continue;
+        if ((span.holding?.children.length ?? 0) > 0)
+            continue;
+        if (ownerReading(span, now) >= f.budget)
+            retire(mix, span, span.timeAt(f.budget));
+    }
+}
+/** Fits every span again, as after a seek put its children back. */
+export function refitAll(mix) {
+    const spans = (mix.owners ?? []).filter((v) => v.fitting !== null);
+    // Later cued first, so a span held by a span is fitted before the one holding it.
+    for (let i = spans.length - 1; i >= 0; i--)
+        refit(mix, spans[i]);
+}

package/dist/strays.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { MotionOwner, Motions } from './motion.js';
+import type { MotionOwner, Motions } from './motions.js';
 import type { Voice } from './voice.js';
 /** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
 export declare function stray<I, O>(mix: Mixer<I, O>, motion: Motions<I>, subject: I): void;

package/dist/strays.js

@@ -1,4 +1,6 @@
 import { unpart } from './fade.js';
+import { pageOut } from './paging.js';
+import { record } 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);
@@ -37,6 +39,25 @@ export function motionOwner(mix) {
             const v = m === undefined ? undefined : cuedById(m, id);
             return m === undefined || v === undefined ? Number.NaN : frameOf(m, v, subject);
         },
+        now() {
+            return mix.deref()?.now ?? Number.NaN;
+        },
+        changed(id, motion, subject, change) {
+            const m = mix.deref();
+            if (m === undefined)
+                return;
+            record(m, 'motion', () => {
+                const v = cuedById(m, id) ?? m.gone.find((g) => g.id === id);
+                (v?.motion ?? motion).change(subject, { ...change });
+            });
+        },
+        page(id, stream, subject, out) {
+            const m = mix.deref();
+            const ms = m?.opts.history?.ms;
+            if (m === undefined || m.keys === null || ms === undefined)
+                return;
+            pageOut(m, stream, id, m.keys.key(subject), out, (e) => e.data, m.now - ms);
+        },
         revive(id, subject) {
             const m = mix.deref();
             if (m === undefined)

package/dist/tape.d.ts

@@ -0,0 +1,21 @@
+import type { Pace } from './pace.js';
+import type { Transport } from './transport.js';
+import type { Tape } from './types.js';
+/** The tape `history.tape` makes for a transport, stamping each call with the mix time it was made at. */
+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. */
+export declare function record(on: {
+    readonly tape: Tape | undefined;
+    readonly replaying: boolean;
+    readonly projecting: boolean;
+}, label: string, again: () => 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;
+/**
+ * Makes the recorded calls due by mix time `to()` again, each with every mix on the transport
+ * moved to the time it was made at, as the host made it then. `to` is asked again after every
+ * call, since a call may change the rate and so where a host time lands.
+ */
+export declare function replay(transport: Transport, to: () => number): void;