@msb235/blits 0.9.0 → 0.11.0

package/dist/project.js

@@ -1,37 +1,52 @@
 import { ownBlends } from './blend.js';
+import { heldAt } from './chain.js';
+import { stepOf } from './clock.js';
 import { open, sighted, weightAt } from './everyone.js';
+import { fadesAt } from './fade.js';
+import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
+import { markOf, voiceMarks } from './marks.js';
 import { Mixer } from './mixer.js';
 import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
-import { pin } from './place.js';
+import { pin, place } from './place.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
 import { copyStanding, stands } from './standing.js';
-import { hostAt } from './tape.js';
+import { hostAhead, hostAt, replay } from './tape.js';
 import { Transport, within } from './transport.js';
-import { cover } from './unpage.js';
+import { cover, coverFrame } from './unpage.js';
 import { unreached } from './unreached.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
- * own, moved together so an anchor across mixes answers as it would live.
+ * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
+ * known event on the way, and a subject asked about is read at each before `t`.
  */
-export function projectAll(transport, t) {
-    const ahead = Number.isNaN(transport.now) || t >= transport.now;
-    const tape = transport.tape;
-    const stamp = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+export function projectAll(transport, at) {
+    const kept = transport.history !== undefined;
+    let t;
+    let numbered;
+    if (typeof at === 'number')
+        t = at;
+    else {
+        if (!kept)
+            throw new Error('blits: reading a frame back needs a mix made with history');
+        numbered = coverFrame(transport, at.frame);
+        t = numbered.at;
+    }
+    // The frame being played reads as the mix's own time does; any other is behind, whatever its time.
+    const ahead = numbered !== undefined
+        ? numbered.seq === transport.seq
+        : Number.isNaN(transport.now) || t >= transport.now;
     const pace = transport.pace;
-    const next = stamp === undefined || pace === null ? stamp : pace.reading(stamp);
-    if (next !== undefined && next <= t)
-        throw new Error(`blits: the tape holds calls at ${next} that a read ahead to ${t} cannot play; seek there to see them`);
     // Behind, the last frame at or before `t`, read as it showed when `t` is that frame's own time.
     let cut = { seq: transport.seq, strict: false };
-    let u = hostAt(transport, t);
-    const kept = transport.history !== undefined;
+    let u = ahead ? hostAhead(transport, t) : hostAt(transport, t);
     if (!ahead && kept) {
-        cover(transport, t);
-        const frame = transport.frames.at(t);
+        if (numbered === undefined)
+            cover(transport, t);
+        const frame = numbered ?? transport.frames.at(t);
         if (frame !== undefined) {
             cut = { seq: frame.seq, strict: frame.at === t };
             if (frame.at === t)
@@ -57,7 +72,7 @@ export function projectAll(transport, t) {
             history: undefined,
             lanes: false,
             transport: c,
-        });
+        }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
         copies.set(mix, copy);
@@ -70,28 +85,50 @@ export function projectAll(transport, t) {
     }
     // A read at the mix's own time lands nothing, as a probe does not: what the host has done since
     // the last sync shows at the next one.
-    if (ahead && t !== transport.now)
-        for (const copy of copies.values())
-            move(copy, t);
+    let stood = c;
+    let earlier = null;
+    if (ahead && t !== transport.now) {
+        earlier = new Map();
+        stood = playAhead(transport, c, copies, t, earlier);
+    }
     const read = (f) => {
         reading.live = false;
+        reading.ahead = stood.ahead.size > 0 ? stood.ahead : null;
         try {
             return f();
         }
         finally {
             reading.live = true;
+            reading.ahead = null;
         }
     };
     return {
         timestamp: t,
         of(mix) {
-            const copy = copies.get(mix);
+            const key = mix;
+            const copy = copies.get(key);
             if (copy === undefined)
                 throw new Error('blits: that mix is not on this transport');
+            const stages = earlier?.get(key);
+            // A subject asked about is read at every stop first, in order, so the state it carries
+            // crosses each event as a frame there would carry it.
+            const warm = stages === undefined
+                ? null
+                : (subject) => {
+                    if (stages.met.has(subject))
+                        return;
+                    stages.met.add(subject);
+                    for (const stage of stages.at)
+                        stage.fold(subject);
+                };
             return {
                 timestamp: t,
-                probe: (subject, out) => read(() => copy.fold(subject, out)),
+                probe: (subject, out) => read(() => {
+                    warm?.(subject);
+                    return copy.fold(subject, out);
+                }),
                 assess: (subject) => read(() => {
+                    warm?.(subject);
                     copy.fold(subject);
                     return doubts(copy, subject);
                 }),
@@ -99,7 +136,150 @@ export function projectAll(transport, t) {
         },
     };
 }
-/** A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one. */
+/**
+ * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
+ * there makes them on the mixes. While a voice could carry state across it, it stops at each known
+ * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
+ * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
+ * transport they stand on, and puts the tape back where it stood.
+ */
+function playAhead(transport, c, copies, t, earlier) {
+    const tape = transport.tape;
+    const depth = tape?.undoDepth() ?? 0;
+    let played = false;
+    try {
+        for (;;) {
+            const e = nextEvent(tape, c, t);
+            if (!(e < t))
+                break;
+            played = playTo(transport, c, copies, e) || played;
+            if (!carries(c))
+                continue;
+            // Placed now, as the next move would place them, while a target that has just left is here.
+            for (const m of c.members)
+                if (m.anchored > 0)
+                    place(m);
+            const next = restage(c);
+            for (const [mix, copy] of copies) {
+                const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
+                on.slot = copy.slot;
+                on.projecting = true;
+                copyAhead(copy, on);
+                const stages = earlier.get(mix);
+                if (stages === undefined)
+                    earlier.set(mix, { at: [copy], met: new Set() });
+                else
+                    stages.at.push(copy);
+                copies.set(mix, on);
+            }
+            c = next;
+        }
+        played = playTo(transport, c, copies, t) || played;
+    }
+    finally {
+        if (played)
+            tape?.goto(depth);
+    }
+    return c;
+}
+/**
+ * Whether a voice on a read ahead's copies could carry state from one known event to the next: a
+ * patch that steps, or a weight given by a signal, which may keep state. Where none could, a read
+ * crosses the events in one go, as fast as one with none.
+ */
+function carries(c) {
+    for (const m of c.members)
+        for (const v of m.cued)
+            if (v.state !== 'done' && (v.patch.step !== undefined || typeof v.spec.weight === 'function'))
+                return true;
+    return false;
+}
+/**
+ * The earliest known event a read ahead's copies have yet to reach before `t`, mix time: the next
+ * call the tape holds, and while a voice could carry state across one, a mark of a voice or one
+ * announced. Infinity where there is none.
+ */
+function nextEvent(tape, c, t) {
+    const now = c.now;
+    let e = Number.POSITIVE_INFINITY;
+    const call = tape?.timestampAt(tape.undoDepth());
+    if (call !== undefined)
+        e = c.pace === null ? call : c.pace.reading(call);
+    if (!carries(c))
+        return e < t ? e : Number.POSITIVE_INFINITY;
+    for (const m of c.members)
+        for (const v of m.cued) {
+            if (v.state === 'done')
+                continue;
+            for (const mark of voiceMarks) {
+                const at = markOf(m, v, mark);
+                if (at !== undefined && at > now && at < e)
+                    e = at;
+            }
+            const inner = v.spec.marks;
+            if (inner !== undefined)
+                for (const mark of Object.keys(inner)) {
+                    const at = markOf(m, v, mark);
+                    if (at !== undefined && at > now && at < e)
+                        e = at;
+                }
+        }
+    for (const a of c.announced) {
+        const at = c.pace === null ? a.at : c.pace.at(a.at, c.u);
+        if (at > now && at < e)
+            e = at;
+    }
+    return e < t ? e : Number.POSITIVE_INFINITY;
+}
+/**
+ * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
+ * there. Answers whether it moved the tape.
+ */
+function playTo(transport, c, copies, to) {
+    const tape = transport.tape;
+    const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
+    const next = tape?.timestampAt(tape.undoDepth());
+    c.u = hostAhead(c, to);
+    let played = false;
+    if (next !== undefined && due(next)) {
+        // A call may write what a copy shares with the voice it was copied from.
+        for (const copy of c.members)
+            for (const v of copy.cued) {
+                if (v.parts !== null)
+                    v.parts = new Map(v.parts);
+                if (v.parted !== null)
+                    v.parted = new Map(v.parted);
+            }
+        played = true;
+        const last = replay(transport, due, c, {
+            transport: () => c,
+            mix: (of) => copies.get(of),
+        });
+        c.u = Math.max(last, hostAhead(c, to));
+    }
+    // A call played at `to` itself moved the copies there before it, as a sync does.
+    if (!(c.now >= to))
+        for (const copy of c.members)
+            move(copy, to);
+    return played;
+}
+/** A transport for a read ahead's copies to go on from where those on `c` stand. */
+function restage(c) {
+    const next = new Transport(undefined, true);
+    next.offset = c.offset;
+    next.u = c.u;
+    next.nextId = c.nextId;
+    next.now = c.now;
+    next.pace = c.pace === null ? null : c.pace.until(Number.POSITIVE_INFINITY);
+    next.announced = c.announced.map((a) => ({ ...a }));
+    // The retargets and pushes the tape made carry their times, so every stop shares one list.
+    next.ahead = c.ahead;
+    return next;
+}
+/**
+ * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
+ * or from the copy at the known event before.
+ */
 function copyAhead(mix, c) {
     mirror(mix, c);
     c.cued = mix.cued
@@ -112,7 +292,8 @@ function copyAhead(mix, c) {
         return copy;
     });
     ownBlends(c.cued);
-    if (mix.owners !== null)
+    // A copy keeps no list of owners, so the one before says only by its voices.
+    if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))
         relink(c.cued);
     recount(c);
 }
@@ -136,11 +317,26 @@ function copyBack(mix, c, t, cut) {
         const copy = v.copy((subject) => recall(mix, v, subject, t, cut, c, copy), lastWithin(log, cut) ?? log[0]);
         if (then !== undefined)
             copy.setting.host = then;
+        // Its own, which a fade the copy plays out writes to.
+        if (v.parts !== null)
+            copy.parts = new Map(v.parts);
+        if (v.parted !== null)
+            copy.parted = new Map(v.parted);
+        if (v.left !== null)
+            fadesAt(copy, v.left.after(cut), cut.seq);
+        if (copy.parted !== null)
+            for (const [subject, p] of copy.parted) {
+                // A ramp that has ended since was still running at `t`.
+                if (p.ramp === undefined || !(t < p.at))
+                    continue;
+                copy.parts ??= new Map();
+                copy.parts.set(subject, p.ramp);
+            }
         return copy;
     });
     ownBlends(c.cued);
     if (mix.owners !== null)
-        relink(c.cued);
+        relink(c.cued, cut.seq);
     stateAt(c, t);
     recount(c);
 }
@@ -202,12 +398,16 @@ function carry(mix, voice, subject, c, copy) {
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
 export function recall(mix, voice, subject, t, cut, c, copy) {
-    const live = voice.left?.at(subject, cut) ?? recordOf(mix, voice, subject);
+    const live = voice.left?.at(subject, cut) ??
+        heldAt(voice, subject, recordOf(mix, voice, subject), t, cut.seq);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
     if (snap) {
         const h = copyHeld(voice, snap.held);
+        // A start still ahead when the copy was kept may have moved before `t`, with no copy between.
+        if (c !== undefined && copy !== undefined && !(h.since <= snap.at))
+            origin(c, copy, h);
         h.from = h.stepped;
         h.replay = live.inputs;
         return h;
@@ -215,17 +415,16 @@ export function recall(mix, voice, subject, t, cut, c, copy) {
     // Its origin by the controls the voice had then: a seek or an anchor has moved a waiting
     // voice's since.
     const since = c === undefined || copy === undefined ? live.since : c.sinceOf(copy, live.delay);
-    const stepped = since < t ? since : t;
     const h = record(voice, live.reaches, live.reaches && voice.patch.state
         ? voice.patch.state(subject)
         : undefined);
     h.delay = live.delay;
     h.since = since;
     h.shown = c === undefined || copy === undefined ? live.shown : c.shownOf(copy, since);
-    h.stepped = stepped;
+    const fresh = meet(mix, voice, h, t);
     h.rebuilt = voice.rebuilds;
-    h.from = stepped;
-    h.unknown = voice.spec.from === 'current';
+    h.from = h.stepped;
+    h.unknown = voice.spec.from === 'current' || fresh;
     h.replay = live.inputs;
     return h;
 }
@@ -286,10 +485,15 @@ function doubtOf(mix, voice, held) {
             return 'held';
     }
     if (mix.now > (held.from ?? mix.now)) {
-        const tick = mix.opts.stepMs;
-        const fixed = tick !== undefined && tick > 0 && !mix.reducedNow;
-        if ((voice.patch.step && !fixed) || (held.kept !== null && held.kept.size > 0 && !replayed))
+        const fixed = stepOf(mix, voice) !== undefined;
+        // A read ahead reads a signal's state at every known event, and one step across a stretch
+        // with none in it is as good as any number; a read back steps it from a copy in one go.
+        const kept = held.kept !== null && held.kept.size > 0 && !replayed && mix.backward;
+        if ((voice.patch.step && !fixed) || kept)
             return 'stepped';
     }
+    // A seek stepped it from a copy, and what it keeps now goes on from there.
+    if (held.copied && held.kept !== null && held.kept.size > 0 && !replayed)
+        return 'stepped';
     return 'exact';
 }

package/dist/pull.js

@@ -1,6 +1,8 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
 import { clampRun, flush, pullRun, writeLater } from './columns.js';
+/** What `pull` remembers at a position it has read no subject at. */
+const UNREAD = Symbol('unread');
 /** Writes a folded pose's value into subject `n`'s places in a column. */
 function writeValue(c, v, n) {
     const at = n * c.axes;
@@ -76,19 +78,33 @@ export function pull(mix, subjects, into) {
     // all of them at once while nothing has relinked since the last pull, else one by one.
     const was = mix.pulled;
     const heads = mix.pulledHeads;
-    was.length = list.length;
-    heads.length = list.length;
     if (mix.pulledSlots.length < list.length) {
-        const slots = new Int32Array(Math.max(64, list.length));
+        const slots = new Int32Array(Math.max(64, list.length)).fill(-1);
         slots.set(mix.pulledSlots);
         mix.pulledSlots = slots;
     }
+    // A position the list no longer has, or has anew, holds no head: its slot says so.
+    if (list.length < was.length)
+        mix.pulledSlots.fill(-1, list.length, was.length);
+    // A new position holds a mark no subject equals: a hole would read as `undefined`, a subject.
+    for (let n = was.length; n < list.length; n++)
+        was.push(UNREAD);
+    was.length = list.length;
+    heads.length = list.length;
     const version = mix.version;
     const relinks = mix.relinks;
     const live = !Number.isNaN(now);
     const current = live && mix.pulledVersion === version && mix.pulledRelinks === relinks;
+    // Which remembered heads `pullRun` takes as current: all while nothing has changed; those
+    // `unlink` has not stamped since `pulledRelinks` while the version they were linked at stands;
+    // none otherwise.
+    const since = current
+        ? Number.POSITIVE_INFINITY
+        : live && mix.pulledVersion === version
+            ? mix.pulledRelinks
+            : -1;
     try {
-        readAll(mix, list, columns, live, current, whole);
+        readAll(mix, list, columns, live, current, since, whole);
     }
     finally {
         if (lanes !== null)
@@ -104,7 +120,7 @@ export function pull(mix, subjects, into) {
  * compile the loop on the stack does not leave `pull`'s own code compiled before its tail had run:
  * under churn that code deoptimized at the tail on every frame.
  */
-function readAll(mix, list, columns, live, current, whole) {
+function readAll(mix, list, columns, live, current, since, whole) {
     const lanes = mix.lanes;
     const now = mix.now;
     const scratch = mix.scratch;
@@ -116,7 +132,7 @@ function readAll(mix, list, columns, live, current, whole) {
     const runs = live && whole;
     for (let n = 0; n < list.length; n++) {
         if (runs) {
-            n = pullRun(lanes, slots, list, was, current ? null : heads, n, columns, now, mix.version);
+            n = pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
             if (n === list.length)
                 break;
         }
@@ -149,13 +165,24 @@ function readAll(mix, list, columns, live, current, whole) {
             writeValue(c, pose[c.key], n);
     }
 }
-/** The kit slot, width, rest and bounds of every channel `pull` was handed an array for. */
+/**
+ * The kit slot, width, rest and bounds of every channel `pull` was handed an array for: one record
+ * a channel for the mix's life, pointed at the array this call was handed.
+ */
 function columnsOf(mix, into) {
     const columns = [];
+    mix.pullColumns ??= new Map();
+    const known = mix.pullColumns;
     for (const key of Object.keys(into)) {
         const out = into[key];
         if (out === undefined)
             continue;
+        const had = known.get(key);
+        if (had !== undefined) {
+            had.out = out;
+            columns.push(had);
+            continue;
+        }
         const slot = mix.slotOf.get(key);
         if (slot === undefined)
             throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
@@ -170,7 +197,9 @@ function columnsOf(mix, into) {
             at.set(rest);
         if (bounds !== undefined)
             clampRun(at, 0, axes, bounds);
-        columns.push({ key, slot, axes, out, rest: at, bounds });
+        const column = { key, slot, axes, out, rest: at, bounds };
+        known.set(key, column);
+        columns.push(column);
     }
     return columns;
 }

package/dist/qualify.js

@@ -1,6 +1,7 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
 import { crowdable } from './crowd.js';
+import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 import { Lane } from './lane.js';
@@ -231,8 +232,13 @@ export function open(lanes, v) {
  * A crowd a quarter empty rows is compacted.
  */
 export function retouch(lanes) {
-    const touched = [...new Set(lanes.touched)].sort((a, b) => a.id - b.id);
-    lanes.touched.length = 0;
+    const touched = byId(lanes.touched);
+    lanes.touched = [];
+    let kept = 0;
+    for (let i = 0; i < touched.length; i++)
+        if (i === 0 || touched[i] !== touched[i - 1])
+            touched[kept++] = touched[i];
+    touched.length = kept;
     // The qualify a false answer calls takes up every touched voice, crowd rows starting included.
     const qualify = () => {
         lanes.touched = touched;

package/dist/reading.d.ts

@@ -25,4 +25,10 @@ export declare const reading: {
      * since it read it. One count for every mix, as `moved` is.
      */
     inputs: number;
+    /**
+     * While a read ahead that played its tape's calls reads: the retargets and pushes those calls
+     * made, by motion patch and then subject, in time order. A patch applies them with its own and
+     * commits none. Null for every other read.
+     */
+    ahead: Map<object, Map<unknown, unknown[]>> | null;
 };

package/dist/reading.js

@@ -25,4 +25,10 @@ export const reading = {
      * since it read it. One count for every mix, as `moved` is.
      */
     inputs: 0,
+    /**
+     * While a read ahead that played its tape's calls reads: the retargets and pushes those calls
+     * made, by motion patch and then subject, in time order. A patch applies them with its own and
+     * commits none. Null for every other read.
+     */
+    ahead: null,
 };

package/dist/record.js

@@ -23,6 +23,7 @@ export function record(voice, reaches, state) {
         phase: 0,
         seeks: 0,
         rebuilt: 0,
+        copied: false,
         base: undefined,
         slope: undefined,
         kept: null,

package/dist/restored.d.ts

@@ -11,6 +11,7 @@ import type { Subject } from './voice.js';
  */
 export declare class Restored<I> extends Store<I, Subject<unknown>> {
     private readonly own;
+    private readonly now;
     private readonly make;
     /** Seeks back so far. */
     private n;
@@ -26,13 +27,15 @@ export declare class Restored<I> extends Store<I, Subject<unknown>> {
     /** The latest seek's moment. */
     private t;
     /**
-     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
-     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     * `own` holds the records as they stood before the first seek, and `now` gives the one a subject
+     * that has not left since has there, as a seek to `t`, the end of frame `seq`, takes it. `make`
+     * puts a record back as it stood at `t`, undefined where it had none then; `top` is the latest
+     * seek's moment.
      */
-    constructor(own: Store<I, Subject<unknown>>, make: (live: Subject<unknown>, t: number, top: number) => Subject<unknown> | undefined);
+    constructor(own: Store<I, Subject<unknown>>, now: (key: I, held: Subject<unknown> | undefined, t: number, seq: number) => Subject<unknown> | undefined, make: (live: Subject<unknown>, t: number, top: number) => Subject<unknown> | undefined);
     /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
     back(t: number, cut: Cut, left: Leavings<I> | null): void;
-    /** The earliest moment sought by seek `from` or any after it. */
+    /** The earliest moment sought by seek `from` or any after it, and the frame it ended. */
     private since;
     get(key: I): Subject<unknown> | undefined;
     set(key: I, value: Subject<unknown>): void;

package/dist/restored.js

@@ -8,6 +8,7 @@ import { Store } from './store.js';
  */
 export class Restored extends Store {
     own;
+    now;
     make;
     /** Seeks back so far. */
     n = 0;
@@ -23,12 +24,15 @@ export class Restored extends Store {
     /** The latest seek's moment. */
     t = Number.NaN;
     /**
-     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
-     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     * `own` holds the records as they stood before the first seek, and `now` gives the one a subject
+     * that has not left since has there, as a seek to `t`, the end of frame `seq`, takes it. `make`
+     * puts a record back as it stood at `t`, undefined where it had none then; `top` is the latest
+     * seek's moment.
      */
-    constructor(own, make) {
+    constructor(own, now, make) {
         super();
         this.own = own;
+        this.now = now;
         this.make = make;
     }
     /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
@@ -37,14 +41,14 @@ export class Restored extends Store {
         const least = this.least;
         while (least.length > 0 && least[least.length - 1].t >= t)
             least.pop();
-        least.push({ n, t });
+        least.push({ n, t, seq: cut.seq });
         this.t = t;
         if (left !== null) {
             this.futures ??= new Map();
             this.futures.set(n, { left, cut });
         }
     }
-    /** The earliest moment sought by seek `from` or any after it. */
+    /** The earliest moment sought by seek `from` or any after it, and the frame it ended. */
     since(from) {
         const least = this.least;
         let lo = 0;
@@ -56,7 +60,7 @@ export class Restored extends Store {
             else
                 lo = mid + 1;
         }
-        return least[lo].t;
+        return least[lo];
     }
     get(key) {
         const at = this.at.get(key) ?? 0;
@@ -66,10 +70,9 @@ export class Restored extends Store {
         // A subject that left after the moment the next seek sought had the record it left with,
         // whatever it has now. Leaving is a write, so no later seek's leavings can hold it.
         const future = this.futures?.get(at + 1);
-        const live = future?.left.at(key, future.cut) ?? this.own.get(key);
-        if (live === undefined)
-            return undefined;
-        const made = this.make(live, this.since(at + 1), this.t);
+        const { t, seq } = this.since(at + 1);
+        const live = future?.left.at(key, future.cut) ?? this.now(key, this.own.get(key), t, seq);
+        const made = live && this.make(live, t, this.t);
         if (made === undefined)
             this.own.delete(key);
         else

package/dist/revive.d.ts

@@ -4,7 +4,7 @@ import type { Past } from './origin.js';
 import { type PackedRecord } from './pack.js';
 import { type Key } from './paging.js';
 import type { Described } from './types.js';
-import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, type Parted, type Parting, type Ramp, type Rise, Voice } from './voice.js';
 /** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
 interface PackedVoice {
     as: Described;
@@ -43,9 +43,11 @@ interface PackedVoice {
     playedSeq: number;
     records: [Key, PackedRecord][];
     runs: [Key, Run][];
-    left: [Key, number, number, PackedRecord, boolean][];
+    /** The fades are absent from a store written before a leaving kept them. */
+    left: [Key, number, number, PackedRecord, boolean, (Parting | null)?, (Parted | null)?][];
     parts: [Key, number, number, number][];
-    parted: [Key, number, number][];
+    /** With the ramp that took the subject out; absent from a store written before a voice kept it. */
+    parted: [Key, number, number, Parting?][];
 }
 /**
  * Voices a history store holds whose handles something still holds, by id: a seek that revives