@msb235/blits 0.7.1 → 0.8.0

package/dist/motions.js

@@ -43,7 +43,7 @@ const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel}
  * The one copy, read by `at` and by a mix's lane alike.
  *
  * After the law, each subject's run of `stride` numbers is its release time, its flags, a tween's
- * seconds for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
+ * ms for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
@@ -52,6 +52,8 @@ export class Motions {
     numbers = new Numbers(this);
     /** Numbers by subject once a second is numbered: till then the one subject is found by `numbers`. */
     slots = new Store();
+    /** How many numbers have been given up, so a number kept elsewhere can tell it is stale. */
+    freed = 0;
     /** Axes per subject; -1 until the first subject sets it. */
     n = -1;
     cap = 0;
@@ -163,10 +165,10 @@ export class Motions {
      */
     released = [];
     /**
-     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at`, under
-     * history, its run is kept for a rewind before then, until `reach` passes it.
+     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+     * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
      */
-    release(subject, at, reach = Number.NEGATIVE_INFINITY) {
+    release(subject, at, reach = Number.NEGATIVE_INFINITY, seq = Number.NaN) {
         const s = this.known(subject);
         if (s === undefined)
             return;
@@ -176,19 +178,21 @@ export class Motions {
                 if (e.at >= reach)
                     kept.push(e);
                 else
-                    this.owner?.page(this.ownerId, 'released', e.subject, [{ at: e.at, data: runOf(e) }]);
+                    this.owner?.page(this.ownerId, 'released', e.subject, [
+                        { at: e.at, seq: e.seq, data: runOf(e) },
+                    ]);
             this.released = kept;
-            this.released.push({ subject, at, ...this.runAt(s) });
+            this.released.push({ subject, at, seq, ...this.runAt(s) });
         }
         this.slots.delete(subject);
         this.numbers.release(s);
     }
-    /** Puts back each subject released after mix time `t`, as it stood when released. */
-    unrelease(t) {
-        const back = this.released.filter((e) => e.at > t).sort((a, b) => a.at - b.at);
+    /** Puts back each subject released after frame `seq`, as it stood when released. */
+    unrelease(seq) {
+        const back = this.released.filter((e) => e.seq > seq).sort((a, b) => a.seq - b.seq);
         if (back.length === 0)
             return;
-        this.released = this.released.filter((e) => e.at <= t);
+        this.released = this.released.filter((e) => e.seq <= seq);
         const done = new Set();
         for (const e of back) {
             if (done.has(e.subject))
@@ -239,24 +243,24 @@ export class Motions {
         }
     }
     /** A released run a history store gave back, for a rewind to before its release. */
-    reclaim(subject, at, run) {
-        if (this.released.some((e) => e.at === at && Object.is(e.subject, subject)))
+    reclaim(subject, at, seq, run) {
+        if (this.released.some((e) => e.seq === seq && Object.is(e.subject, subject)))
             return;
-        this.released.push({ subject, at, ...run });
+        this.released.push({ subject, at, seq, ...run });
     }
     /**
-     * Stretches a history store gave back, each by the mix time it was in force by: each life of the
+     * Stretches a history store gave back, each by the frame it was in force by: each life of the
      * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
      */
     restretch(subject, back) {
         const lives = this.released
             .filter((e) => Object.is(e.subject, subject))
-            .sort((x, y) => x.at - y.at);
+            .sort((x, y) => x.seq - y.seq);
         let from = Number.NEGATIVE_INFINITY;
-        const within = (to) => back.filter((r) => r.at > from && r.at <= to).map((r) => r.data);
+        const within = (to) => back.filter((r) => r.seq > from && r.seq <= to).map((r) => r.data);
         for (const e of lives) {
-            e.stretches = ahead(within(e.at), e.stretches);
-            from = e.at;
+            e.stretches = ahead(within(e.seq), e.stretches);
+            from = e.seq;
         }
         const s = this.known(subject);
         if (s === undefined)
@@ -298,7 +302,7 @@ export class Motions {
         return true;
     }
     /**
-     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its seconds, then
+     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its ms, then
      * `x0`, `v0` and `to` per axis; false, copying nothing, while it has a change pending or an
      * earlier stretch kept, which only `sample` handles.
      */
@@ -354,7 +358,7 @@ export class Motions {
         this.peek(s, t, xo, vo);
     }
     /**
-     * Where subject `s`'s run starts in `runs` (its release time, then flags, seconds, `x0`, `v0`
+     * Where subject `s`'s run starts in `runs` (its release time, then flags, ms, `x0`, `v0`
      * and `to`) while it has nothing pending and no earlier stretch kept; -1 for any other.
      */
     bareAt(s) {
@@ -455,6 +459,7 @@ export class Motions {
         this.check(c.to, this.n);
         this.check(c.v, this.n);
         c.made = this.owner === null ? Number.NaN : this.owner.now();
+        c.seq = this.owner === null ? Number.NaN : this.owner.seq();
         if (c.at === undefined) {
             const at = this.frame(subject);
             if (!Number.isNaN(at))
@@ -511,6 +516,7 @@ export class Motions {
         this.runs[i] = on ? flags | bit : flags & ~bit;
     }
     forget(s) {
+        this.freed++;
         if (this.pending !== null)
             this.pending[s] = undefined;
         if (this.older !== null)
@@ -519,16 +525,16 @@ export class Motions {
             this.causes[s] = undefined;
     }
     /**
-     * Takes back every change made after mix time `t`: each subject plays from its earliest stretch
+     * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
      * kept, with the changes made by then queued to be applied again.
      */
-    rewind(t) {
-        this.unrelease(t);
+    rewind(seq) {
+        this.unrelease(seq);
         for (let s = 0; s < this.numbers.size; s++)
             if (this.numbers.subject(s) !== absent)
-                this.cut(s, t);
+                this.cut(s, seq);
     }
-    cut(s, t) {
+    cut(s, seq) {
         const older = this.older?.[s];
         const pending = this.pending?.[s];
         const current = this.latest(s);
@@ -536,7 +542,7 @@ export class Motions {
         const kept = [];
         let cut = false;
         for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
-            if (c === undefined || c.made === undefined || !(c.made > t)) {
+            if (c === undefined || c.seq === undefined || !(c.seq > seq)) {
                 if (c !== undefined)
                     kept.push(c);
             }
@@ -684,12 +690,15 @@ export class Motions {
         list.splice(i, 0, seg);
     }
     /**
-     * The mix time a stretch was in force by, which a store keys it under: when the change that
-     * ended it was made, which falls in the same life of the subject.
+     * The mix time and frame a stretch was in force by, which a store keys it under: when the change
+     * that ended it was made, which falls in the same life of the subject.
      */
     made(next) {
-        const made = next.change?.made;
-        return made === undefined || Number.isNaN(made) ? (this.owner?.now() ?? Number.NaN) : made;
+        const c = next.change;
+        const made = c?.made;
+        if (made === undefined || Number.isNaN(made))
+            return { at: this.owner?.now() ?? Number.NaN, seq: this.owner?.seq() ?? Number.NaN };
+        return { at: made, seq: c?.seq ?? Number.NaN };
     }
     /** Lets go of stretches older than the one in force at `reading.horizon`. */
     prune(s) {
@@ -706,10 +715,7 @@ export class Motions {
         const out = list.splice(0, n);
         const subject = this.numbers.subject(s);
         if (this.owner !== null && subject !== absent)
-            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({
-                at: this.made(out[i + 1] ?? list[0] ?? this.latest(s)),
-                data: seg,
-            })));
+            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({ ...this.made(out[i + 1] ?? list[0] ?? this.latest(s)), data: seg })));
         if (list.length === 0) {
             this.older[s] = undefined;
             this.flag(s, OLDER, false);

package/dist/move.js

@@ -1,11 +1,13 @@
-import { changed, unindex } from './chain.js';
+import { changed } from './chain.js';
 import { popDue, schedule } from './due.js';
+import { detour } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
-import { started } from './held.js';
+import { reorigin } from './held.js';
 import { ownerReading } from './owner.js';
 import { mixAt, place, repin, startOf } from './place.js';
 import { pageVoice } from './revive.js';
+import { delist } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
 import { lapse } from './spans.js';
 import { unplay } from './strays.js';
@@ -31,6 +33,11 @@ export function move(mix, now) {
 }
 function moveTo(mix, now) {
     mix.now = now;
+    mix.looked = false;
+    if (mix.unshared) {
+        mix.unshared = false;
+        detour(mix);
+    }
     mix.frame = nextFrame();
     mix.reducedNow = mix.reduced;
     for (const a of mix.announced)
@@ -52,18 +59,19 @@ function moveTo(mix, now) {
             continue;
         if (Number.isNaN(voice.opened))
             voice.opened = now;
-        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
-            beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state === 'pending' &&
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
             voice.state = 'live';
-            started(mix, voice);
+            reorigin(mix, voice, now);
             changed(mix, voice);
         }
+        // After it starts, so a fade due by now on a voice that started since the last frame begins.
+        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
+            beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state !== 'pending' && Number.isFinite(voice.span)) {
             const end = voice.span + voice.latest;
             if (voice.elapsedAt(now) >= end) {
-                voice.play(true, now);
+                voice.play(true, now, mix.transport.seq);
                 // The fade starts when the last pass ended, not at the frame that noticed, so it plays
                 // the same at any frame rate and a read at another time can find it.
                 if (voice.state === 'live') {
@@ -154,8 +162,12 @@ function prune(mix) {
         }
         voices.length = kept;
     }
-    if (pruned)
+    if (pruned) {
         mix.general = mix.general.filter((v) => v.state !== 'done');
+        if (mix.sharers.length > 0)
+            mix.sharers = mix.sharers.filter((v) => v.state !== 'done');
+        detour(mix);
+    }
 }
 /** The voice's place in a list in id order, or -1 where it is not there. */
 function indexOf(voices, voice) {
@@ -180,18 +192,13 @@ function leave(mix, voice) {
         mix.gone.push(voice);
         scoredLeft(mix, voice);
     }
-    else
+    else {
         mix.parters.delete(voice);
+        mix.departed.add(mix, voice);
+    }
     unplay(mix, voice);
     changed(mix, voice);
-    if (voice.named !== null)
-        unindex(mix, voice);
-    if (voice.holding !== null && mix.owners !== null)
-        mix.owners = mix.owners.filter((v) => v !== voice);
-    if (voice.spec.locus !== undefined)
-        mix.loci--;
-    if (voice.spec.anchor !== undefined)
-        mix.anchored--;
+    delist(mix, voice);
     return voice.named === null;
 }
 /** Lets go of the voices that have left and that history no longer reaches. */

package/dist/moved.d.ts

@@ -0,0 +1,11 @@
+import type { Motions } from './motions.js';
+import type { Subject } from './voice.js';
+/**
+ * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
+ * into the record's last delta and the array that holds, where `at` makes an object and an array a
+ * call, and the patch's number for the subject kept on the record, where `at` looks it up a call.
+ * `setting` has the voice time to sample at.
+ */
+export declare function moved<I>(run: Motions<I>, key: string, subject: I, setting: {
+    readonly elapsed: number;
+}, rec: Subject<unknown>): Record<string, unknown>;

package/dist/moved.js

@@ -0,0 +1,29 @@
+import { doubles } from './channels.js';
+/**
+ * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
+ * into the record's last delta and the array that holds, where `at` makes an object and an array a
+ * call, and the patch's number for the subject kept on the record, where `at` looks it up a call.
+ * `setting` has the voice time to sample at.
+ */
+export function moved(run, key, subject, setting, rec) {
+    let s = rec.run;
+    if (rec.freed !== run.freed) {
+        s = run.slot(subject);
+        rec.run = s;
+        rec.freed = run.freed;
+    }
+    const xs = run.xs;
+    run.sample(s, setting.elapsed, xs, run.vs);
+    const delta = rec.delta ?? {};
+    if (run.scalar(s)) {
+        delta[key] = xs[0];
+        return delta;
+    }
+    const n = run.n;
+    const held = delta[key];
+    const out = Array.isArray(held) && held.length === n ? held : doubles(n, 0);
+    for (let i = 0; i < n; i++)
+        out[i] = xs[i];
+    delta[key] = out;
+    return delta;
+}

package/dist/origin.d.ts

@@ -0,0 +1,19 @@
+import { type Clock } from './clock.js';
+import type { Voice } from './voice.js';
+/** A clock a voice ran on before its current one, until its local time `until`. */
+export interface Past extends Clock {
+    until: number;
+    /** The voice's `rebuilds` while it ran on this clock. */
+    rebuilds: number;
+}
+/**
+ * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
+ * where a subject's origin could still be found on it.
+ */
+export declare function leave<I, O>(voice: Voice<I, O>, u: number): void;
+/**
+ * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
+ * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
+ * `rebuilt` starts from the last seek that rebuilt state, as a stateful record does.
+ */
+export declare function originOf<I, O>(voice: Voice<I, O>, elapsed: number, rebuilt: boolean): number;

package/dist/origin.js

@@ -0,0 +1,68 @@
+import { elapsedWith, timeWith } from './clock.js';
+/** The most past clocks a voice keeps. */
+const MOST = 256;
+/**
+ * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
+ * where a subject's origin could still be found on it.
+ */
+export function leave(voice, u) {
+    const past = voice.clocks;
+    if (past !== null && past.length >= MOST)
+        return;
+    // A voice with neither stagger nor children is only ever asked when its clock read 0.
+    const reach = voice.holding !== null || voice.spec.stagger !== undefined ? Number.POSITIVE_INFINITY : 0;
+    if (past !== null && reached(past, 0) >= reach && reached(past, fresh(voice)) >= reach)
+        return;
+    const { anchorNow, anchorElapsed, rate, ramp, rebuilds } = voice;
+    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds };
+    if (past === null)
+        voice.clocks = [left];
+    else
+        past.push(left);
+}
+/** The most a voice's past clocks from index `from` read before they were left. */
+function reached(past, from) {
+    let most = Number.NEGATIVE_INFINITY;
+    for (let i = from; i < past.length; i++) {
+        const p = past[i];
+        const e = elapsedWith(p, p.until);
+        if (e > most)
+            most = e;
+    }
+    return most;
+}
+/** Where a walk for a record rebuilt by the voice's last seek starts: its first clock since. */
+function fresh(voice) {
+    const past = voice.clocks;
+    if (past === null)
+        return 0;
+    let i = 0;
+    while (i < past.length && past[i].rebuilds !== voice.rebuilds)
+        i++;
+    return i;
+}
+/**
+ * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
+ * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
+ * `rebuilt` starts from the last seek that rebuilt state, as a stateful record does.
+ */
+export function originOf(voice, elapsed, rebuilt) {
+    const past = voice.clocks;
+    let t = Number.NaN;
+    if (past !== null) {
+        for (let i = rebuilt ? fresh(voice) : 0; i < past.length; i++) {
+            const p = past[i];
+            const at = timeWith(p, elapsed);
+            if (at <= p.until) {
+                t = at;
+                break;
+            }
+        }
+    }
+    if (Number.isNaN(t)) {
+        t = timeWith(voice, elapsed);
+        if (t === Number.POSITIVE_INFINITY)
+            t = voice.start + elapsed;
+    }
+    return voice.owner === null ? t : originOf(voice.owner, t, rebuilt);
+}

package/dist/owed.d.ts

@@ -17,8 +17,8 @@ export declare class Owed {
     owes(slot: number): boolean;
     /** Whether the subject at `slot` owes voice `id` this fill. */
     owesVoice(slot: number, id: number): boolean;
-    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
-    owe(slot: number, met: readonly number[]): void;
-    /** Whether `met` is the last list a subject came to owe this fill. */
-    last(met: readonly number[]): boolean;
+    /** The subject at `slot` owes the first `n` voices of `met`, which the caller may reuse after. */
+    owe(slot: number, met: readonly number[], n: number): void;
+    /** Whether the first `n` of `met` are the last list a subject came to owe this fill. */
+    last(met: readonly number[], n: number): boolean;
 }

package/dist/owed.js

@@ -31,19 +31,19 @@ export class Owed {
     owesVoice(slot, id) {
         return this.lists[this.at[slot]].includes(id);
     }
-    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
-    owe(slot, met) {
-        if (!this.last(met))
-            this.lists.push(met.slice());
+    /** The subject at `slot` owes the first `n` voices of `met`, which the caller may reuse after. */
+    owe(slot, met, n) {
+        if (!this.last(met, n))
+            this.lists.push(met.slice(0, n));
         this.fill[slot] = this.now;
         this.at[slot] = this.lists.length - 1;
     }
-    /** Whether `met` is the last list a subject came to owe this fill. */
-    last(met) {
+    /** Whether the first `n` of `met` are the last list a subject came to owe this fill. */
+    last(met, n) {
         const last = this.lists[this.lists.length - 1];
-        if (last === undefined || last.length !== met.length)
+        if (last === undefined || last.length !== n)
             return false;
-        for (let i = 0; i < met.length; i++)
+        for (let i = 0; i < n; i++)
             if (last[i] !== met[i])
                 return false;
         return true;

package/dist/owner.d.ts

@@ -24,7 +24,7 @@ export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): voi
 /** A child left: its owner, where that was its last child and it should leave too. */
 export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
 /** A child finished its passes: its owner has played once every child it held has. */
-export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number): void;
+export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number, seq: number): void;
 /** Every voice an owner holds, its children's children included. */
 export declare function descendants<I, O>(owner: Voice<I, O>, visit: (v: Voice<I, O>) => void): void;
 /** Whether any owner above a voice reads a signal for its weight, which lanes cannot fill. */

package/dist/owner.js

@@ -48,10 +48,10 @@ export function orphan(child) {
     return h.children.length === 0 && owner.state !== 'done' ? owner : null;
 }
 /** A child finished its passes: its owner has played once every child it held has. */
-export function childPlayed(owner, at) {
+export function childPlayed(owner, at, seq) {
     const h = owner.holding;
     if (++h.played === h.kids)
-        owner.play(true, at);
+        owner.play(true, at, seq);
 }
 /** Every voice an owner holds, its children's children included. */
 export function descendants(owner, visit) {

package/dist/pace.d.ts

@@ -1,4 +1,8 @@
 import { type Clock } from './clock.js';
+/** A clock in a pace's log, with the frame that set it, which a history store's cut goes by. */
+export interface Paced extends Clock {
+    seq: number;
+}
 /**
  * A mix's own rate, as a clock: mix time as a function of host time, which here means the host's
  * timestamp less what `rebase` took out. Each entry is the clock from the host time it took effect,
@@ -9,7 +13,7 @@ import { type Clock } from './clock.js';
 export declare class Pace {
     private readonly keeps;
     private log;
-    constructor(keeps: boolean, log?: Clock[]);
+    constructor(keeps: boolean, log?: Paced[]);
     private get clock();
     /** Set before the first sync, the clock waits to be anchored there, reading host time until then. */
     private get waiting();
@@ -30,11 +34,15 @@ export declare class Pace {
     /** Whether the mix clock stands still from host time `u` on, short of another change. */
     stopped(u: number): boolean;
     /**
-     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
-     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
-     * time `reach`.
+     * Sets the rate from host time `u`, in frame `seq`, at once or over `over` host ms, the way a
+     * handle sets a voice's. Under history, lets go of the entries a read no longer reaches: those
+     * over before mix time `reach`.
      */
-    change(u: number, rate: number, over: number, reach: number): void;
+    change(u: number, rate: number, over: number, reach: number, seq: number): void;
+    /** Lets go of the clocks over before mix time `reach`, and answers them. */
+    shed(reach: number): Paced[];
+    /** Puts back clocks a history store kept, ahead of the oldest still held. */
+    unshed(back: readonly Paced[]): void;
     /** Lets go of the clocks set after host time `u`, for a seek back to then. */
     cut(u: number): void;
     /** A copy holding the clocks that took effect before host time `u`, for a read back to then. */

package/dist/pace.js

@@ -9,7 +9,9 @@ import { elapsedWith, rateWith, retime, timeWith } from './clock.js';
 export class Pace {
     keeps;
     log;
-    constructor(keeps, log = [{ anchorNow: 0, anchorElapsed: 0, rate: 1, ramp: null }]) {
+    constructor(keeps, log = [
+        { anchorNow: 0, anchorElapsed: 0, rate: 1, ramp: null, seq: Number.NEGATIVE_INFINITY },
+    ]) {
         this.keeps = keeps;
         this.log = log;
     }
@@ -75,13 +77,13 @@ export class Pace {
         return r.to === 0 && !this.waiting && u >= c.anchorNow + r.over;
     }
     /**
-     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
-     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
-     * time `reach`.
+     * Sets the rate from host time `u`, in frame `seq`, at once or over `over` host ms, the way a
+     * handle sets a voice's. Under history, lets go of the entries a read no longer reaches: those
+     * over before mix time `reach`.
      */
-    change(u, rate, over, reach) {
+    change(u, rate, over, reach, seq) {
         const was = this.clock;
-        const next = { ...was };
+        const next = { ...was, seq };
         if (Number.isNaN(u) || this.waiting) {
             const from = this.rateAt(Number.NaN);
             next.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
@@ -96,11 +98,22 @@ export class Pace {
             log.push(next);
         else
             log[log.length - 1] = next;
+        this.shed(reach);
+    }
+    /** Lets go of the clocks over before mix time `reach`, and answers them. */
+    shed(reach) {
+        const log = this.log;
         let drop = 0;
         while (drop + 1 < log.length && log[drop + 1].anchorElapsed <= reach)
             drop++;
-        if (drop > 0)
-            log.splice(0, drop);
+        return drop > 0 ? log.splice(0, drop) : [];
+    }
+    /** Puts back clocks a history store kept, ahead of the oldest still held. */
+    unshed(back) {
+        const first = this.log[0].anchorNow;
+        const older = back.filter((c) => c.anchorNow < first).sort((a, b) => a.anchorNow - b.anchorNow);
+        if (older.length > 0)
+            this.log = [...older, ...this.log];
     }
     /** Lets go of the clocks set after host time `u`, for a seek back to then. */
     cut(u) {

package/dist/pack.d.ts

@@ -11,6 +11,7 @@ export interface PackedRecord {
     state: unknown;
     stepped: number;
     ticks: number;
+    rebuilt: number;
     /**
      * What `setting.keep` held, in the order its owners first kept it. An owner is code, which no
      * store keeps, and a voice revived from a descriptor has new ones; the same code keeps in the same
@@ -19,9 +20,10 @@ export interface PackedRecord {
     kept: unknown[] | null;
     base?: Record<string, unknown>;
     slope?: Record<string, unknown>;
-    snaps?: [at: number, held: PackedRecord][];
+    snaps?: [at: number, seq: number, held: PackedRecord][];
     inputs?: {
         at: number;
+        seq: number;
         value: number;
     }[];
 }

package/dist/pack.js

@@ -1,4 +1,5 @@
 import { clone } from './clone.js';
+import { record } from './record.js';
 /** A voice's record of one subject as plain data, its patch's `pack` taking its state. */
 export function packHeld(voice, h) {
     const patch = voice.patch;
@@ -14,6 +15,7 @@ export function packHeld(voice, h) {
         state: h.state === undefined ? undefined : patch.pack ? patch.pack(h.state) : clone(h.state),
         stepped: h.stepped,
         ticks: h.ticks,
+        rebuilt: h.rebuilt,
         kept: kept.length === 0 ? null : kept.map(clone),
     };
     if (h.base !== undefined)
@@ -21,7 +23,7 @@ export function packHeld(voice, h) {
     if (h.slope !== undefined)
         p.slope = clone(h.slope);
     if (h.snaps !== undefined)
-        p.snaps = h.snaps.map((s) => [s.at, packHeld(voice, s.held)]);
+        p.snaps = h.snaps.map((s) => [s.at, s.seq, packHeld(voice, s.held)]);
     if (h.inputs !== undefined)
         p.inputs = h.inputs.map((e) => ({ ...e }));
     return p;
@@ -29,28 +31,17 @@ export function packHeld(voice, h) {
 /** A record made again from `packHeld`'s data, for `voice`. */
 export function unpackHeld(voice, p) {
     const patch = voice.patch;
-    const h = {
-        reaches: p.reaches,
-        delay: p.delay,
-        since: p.since,
-        shown: p.shown,
-        weight: p.weight,
-        rested: p.rested,
-        bands: p.bands === null ? null : Uint8Array.from(p.bands),
-        state: p.state === undefined ? undefined : patch.unpack ? patch.unpack(p.state) : p.state,
-        stepped: p.stepped,
-        ticks: p.ticks,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const bands = p.bands === null ? null : Uint8Array.from(p.bands);
+    const h = record(voice, p.reaches, p.state === undefined ? undefined : patch.unpack ? patch.unpack(p.state) : p.state);
+    h.delay = p.delay;
+    h.since = p.since;
+    h.shown = p.shown;
+    h.weight = p.weight;
+    h.rested = p.rested;
+    h.bands = bands;
+    h.stepped = p.stepped;
+    h.ticks = p.ticks;
+    h.rebuilt = p.rebuilt;
     if (p.kept !== null)
         h.unkept = p.kept;
     if (p.base !== undefined)
@@ -58,7 +49,7 @@ export function unpackHeld(voice, p) {
     if (p.slope !== undefined)
         h.slope = p.slope;
     if (p.snaps !== undefined)
-        h.snaps = p.snaps.map(([at, held]) => ({ at, held: unpackHeld(voice, held) }));
+        h.snaps = p.snaps.map(([at, seq, held]) => ({ at, seq, held: unpackHeld(voice, held) }));
     if (p.inputs !== undefined)
         h.inputs = p.inputs;
     return h;