@msb235/blits 0.7.0 → 0.8.0

package/dist/project.js

@@ -1,14 +1,16 @@
 import { ownBlends } from './blend.js';
-import { index } from './chain.js';
-import { copyHeld, last, leftAt } from './history.js';
+import { open, sighted, weightAt } from './everyone.js';
+import { copyHeld, last, lastWithin } from './history.js';
 import { Mixer } from './mixer.js';
 import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
 import { pin } from './place.js';
 import { reading } from './reading.js';
-import { Store } from './store.js';
+import { record } from './record.js';
+import { recount } from './roster.js';
+import { copyStanding, stands } from './standing.js';
 import { hostAt } from './tape.js';
-import { Transport } from './transport.js';
+import { Transport, within } from './transport.js';
 import { cover } from './unpage.js';
 import { unreached } from './unreached.js';
 /**
@@ -18,24 +20,36 @@ import { unreached } from './unreached.js';
 export function projectAll(transport, t) {
     const ahead = Number.isNaN(transport.now) || t >= transport.now;
     const tape = transport.tape;
-    const next = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+    const stamp = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+    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`);
-    if (!ahead) {
-        const history = transport.history;
-        if (!history)
-            throw new Error('blits: reading back needs a mix made with history');
+    // 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;
+    if (!ahead && kept) {
         cover(transport, t);
+        const frame = transport.frameAt(t);
+        if (frame !== undefined) {
+            cut = { seq: frame.seq, strict: frame.at === t };
+            if (frame.at === t)
+                u = frame.u;
+        }
     }
-    const u = hostAt(transport, t);
-    const pace = transport.pace;
+    else if (!ahead)
+        stands(transport, t);
     const c = new Transport(undefined, true);
     c.offset = transport.offset;
     c.u = u;
     c.nextId = transport.nextId;
     c.now = ahead ? transport.now : t;
-    c.pace = pace === null ? null : pace.until(ahead ? Number.POSITIVE_INFINITY : u);
-    c.announced = (ahead ? transport.announced : transport.announced.filter((a) => a.made < t)).map((a) => ({ ...a }));
+    c.pace =
+        pace === null || !within(cut, transport.pacedSeq)
+            ? null
+            : pace.until(ahead ? Number.POSITIVE_INFINITY : u);
+    c.announced = (ahead ? transport.announced : transport.announced.filter((a) => within(cut, a.seq))).map((a) => ({ ...a }));
     const copies = new Map();
     for (const mix of transport.members) {
         const copy = new Mixer(mix.kit, {
@@ -49,8 +63,10 @@ export function projectAll(transport, t) {
         copies.set(mix, copy);
         if (ahead)
             copyAhead(mix, copy);
+        else if (kept)
+            copyBack(mix, copy, t, cut);
         else
-            copyBack(mix, copy, t);
+            copyStanding(mix, copy, t, cut);
     }
     if (ahead)
         for (const copy of copies.values())
@@ -83,13 +99,11 @@ 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. */
 function copyAhead(mix, c) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
+    mirror(mix, c);
     c.cued = mix.cued
         .filter((v) => v.state !== 'done')
         .map((v) => {
-        const copy = v.copy((subject) => carry(mix, v, subject));
+        const copy = v.copy((subject) => carry(mix, v, subject, c, copy), undefined, true);
         const at = mix.pins?.get(v);
         if (at !== undefined)
             pin(c, copy, at);
@@ -98,15 +112,14 @@ function copyAhead(mix, c) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued);
-    count(c);
+    recount(c);
 }
-/** A mix's copy for a read back to `t`: its voices then, from the controls and copies kept. */
-function copyBack(mix, c, t) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
+/** A mix's copy for a read back to `t`, cut at `cut`: its voices then, from the controls and copies kept. */
+function copyBack(mix, c, t, cut) {
+    mirror(mix, c);
     c.backward = true;
-    const was = last(mix.hostLog, t, true);
+    // Copied as the frame's first probe began, so its own frame shows it.
+    const was = lastWithin(mix.hostLog, { seq: cut.seq, strict: false });
     const host = mix.opts.host;
     const then = was && typeof host === 'object' && host !== null
         ? Object.assign(Object.create(host), was.fields)
@@ -114,11 +127,11 @@ function copyBack(mix, c, t) {
     if (was)
         c.hostThen = was;
     c.cued = [...mix.cued, ...mix.gone]
-        .filter((v) => v.cuedAt <= t && v.doneAt > t)
+        .filter((v) => v.cuedSeq <= cut.seq && !within(cut, v.doneSeq, true))
         .sort((a, b) => a.id - b.id)
         .map((v) => {
         const log = v.log;
-        const copy = v.copy((subject) => recall(mix, v, subject, t), last(log, t, (e) => e.sync) ?? log[0]);
+        const copy = v.copy((subject) => recall(mix, v, subject, t, cut), lastWithin(log, cut) ?? log[0]);
         if (then !== undefined)
             copy.setting.host = then;
         return copy;
@@ -126,30 +139,39 @@ function copyBack(mix, c, t) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued);
+    stateAt(c, t);
+    recount(c);
+}
+/** Sets each copied voice's state to what its clock and fade make it at `t`. */
+export function stateAt(c, t) {
     for (const copy of c.cued)
-        copy.state =
-            (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
+        copy.state = copy.out
+            ? 'fading'
+            : (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
                 ? 'pending'
-                : copy.out && copy.out.at <= t
-                    ? 'fading'
-                    : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                        ? 'frozen'
-                        : 'live';
-    count(c);
+                : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                    ? 'frozen'
+                    : 'live';
 }
-/** Recounts what the fold's shortcuts depend on, for a projection's freshly copied voices. */
-function count(mix) {
-    mix.named = new Store();
-    mix.naming = 0;
-    mix.general = [];
-    for (const voice of mix.cued)
-        index(mix, voice);
-    mix.loci = mix.cued.filter((v) => v.spec.locus !== undefined).length;
-    mix.anchored = mix.cued.filter((v) => v.spec.anchor !== undefined).length;
-    mix.steps.push(null, ++mix.version);
+/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
+export function mirror(mix, c) {
+    c.pose = mix.pose;
+    c.wantsPose = mix.wantsPose;
+    c.reducedNow = mix.reducedNow;
 }
 /** A voice's record of a subject, the one it shares among those it does not reach included. */
 function recordOf(mix, voice, subject) {
+    // A voice sharing one record has that for every subject a chain has asked it about, pointed at
+    // the subject for the caller to copy from.
+    if (voice.sharing) {
+        const slot = mix.chains.get(subject)?.slot ?? -1;
+        if (!sighted(voice, slot))
+            return undefined;
+        const all = voice.everyone;
+        open(voice, all, slot);
+        all.weight = weightAt(voice, slot);
+        return all;
+    }
     const held = voice.subjects.get(subject);
     if (held !== undefined || voice.unreachedBits === null)
         return held;
@@ -157,12 +179,19 @@ function recordOf(mix, voice, subject) {
         ? voice.unreached
         : undefined;
 }
-/** A projection ahead starts each subject from where the live mix holds it. */
-function carry(mix, voice, subject) {
+/**
+ * A projection ahead starts each subject from where the live mix holds it, its `since` worked out
+ * again where it was still ahead, since the copy's clock may have moved it.
+ */
+function carry(mix, voice, subject, c, copy) {
     const live = recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const h = copyHeld(voice, live);
+    if (h.reaches && !(h.since <= mix.now)) {
+        h.since = c.sinceOf(copy, h.delay);
+        h.shown = c.shownOf(copy, h.since);
+    }
     h.from = h.stepped;
     return h;
 }
@@ -170,8 +199,8 @@ function carry(mix, voice, subject) {
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
-function recall(mix, voice, subject, t) {
-    const live = leftAt(voice.left, subject, t) ?? recordOf(mix, voice, subject);
+export function recall(mix, voice, subject, t, cut) {
+    const live = voice.left?.at(subject, cut) ?? recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
@@ -182,33 +211,18 @@ function recall(mix, voice, subject, t) {
         return h;
     }
     const stepped = live.since < t ? live.since : t;
-    return {
-        reaches: live.reaches,
-        delay: live.delay,
-        since: live.since,
-        shown: live.shown,
-        weight: 0,
-        rested: false,
-        bands: null,
-        state: live.reaches && voice.patch.state
-            ? voice.patch.state(subject)
-            : undefined,
-        stepped,
-        ticks: 0,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-        from: stepped,
-        unknown: voice.spec.from === 'current',
-        replay: live.inputs,
-    };
+    const h = record(voice, live.reaches, live.reaches && voice.patch.state
+        ? voice.patch.state(subject)
+        : undefined);
+    h.delay = live.delay;
+    h.since = live.since;
+    h.shown = live.shown;
+    h.stepped = stepped;
+    h.rebuilt = voice.rebuilds;
+    h.from = stepped;
+    h.unknown = voice.spec.from === 'current';
+    h.replay = live.inputs;
+    return h;
 }
 /** Per channel, the least sure voice that fed it this frame. */
 function doubts(mix, subject) {
@@ -231,19 +245,23 @@ function doubts(mix, subject) {
         for (const slot of voice.slots)
             out[mix.names[slot]] = 'held';
     }
-    for (let held = mix.chain(subject); held !== null; held = held.next) {
-        const voice = held.voice;
-        if (voice === null || voice.state === 'done')
-            continue;
-        if (held.weight <= 0)
-            continue;
+    const feed = (voice, held) => {
+        if (voice.state === 'done' || held.weight <= 0)
+            return;
         const d = doubtOf(mix, voice, held);
         for (const slot of voice.slots) {
             const name = mix.names[slot];
             if (rank[d] > rank[out[name]])
                 out[name] = d;
         }
-    }
+    };
+    for (let held = mix.chain(subject); held !== null; held = held.next)
+        if (held.voice !== null)
+            feed(held.voice, held);
+    // A voice sharing one record is in no chain; its record holds the weight the fold just gave.
+    for (const voice of mix.sharers)
+        if (voice.everyone !== null && voice.state !== 'pending')
+            feed(voice, voice.everyone);
     return out;
 }
 function doubtOf(mix, voice, held) {

package/dist/pull.d.ts

@@ -3,3 +3,5 @@ import type { Columns } from './types.js';
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
 export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;
+/** Forgets the array `pull` last read, whose heads a seek has made stale. */
+export declare function unpull<I, O>(mix: Mixer<I, O>): void;

package/dist/pull.js

@@ -174,3 +174,11 @@ function columnsOf(mix, into) {
     }
     return columns;
 }
+/** Forgets the array `pull` last read, whose heads a seek has made stale. */
+export function unpull(mix) {
+    mix.pulled = [];
+    mix.pulledHeads = [];
+    mix.pulledSlots = new Int32Array(0);
+    mix.pulledVersion = Number.NaN;
+    mix.pulledRelinks = -1;
+}

package/dist/qualify.js

@@ -1,6 +1,7 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
 import { crowdable } from './crowd.js';
+import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 import { Lane } from './lane.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
@@ -169,6 +170,9 @@ export function requalify(lanes, version) {
         const ch = {
             name: host.names[slot],
             op: n.op,
+            plain: n.op !== 'last' && n.op !== 'own' && n.turn === undefined,
+            turn: n.turn ?? 0,
+            channel,
             scalar,
             rest: typeof rest === 'number' ? rest : rest[0],
             axes: n.axes,
@@ -332,8 +336,12 @@ function leave(lanes, lane) {
             const rec = lane.records[p];
             const slot = lane.list[p];
             const w = done ? undefined : lanes.reported(lane, slot);
-            if (rec !== undefined && w !== undefined)
-                rec.weight = w;
+            if (rec !== undefined && w !== undefined) {
+                if (lane.voice.sharing)
+                    weighAt(lane.voice, slot, w, lanes.cap);
+                else
+                    rec.weight = w;
+            }
             if (rec !== undefined && lane.motion !== undefined)
                 settle(lanes, lane, p, slot, rec);
         }

package/dist/reading.d.ts

@@ -20,4 +20,9 @@ export declare const reading: {
      * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
      */
     moved: number;
+    /**
+     * How many changes an `input` signal has reported, in any mix, so a fill can tell an input moved
+     * since it read it. One count for every mix, as `moved` is.
+     */
+    inputs: number;
 };

package/dist/reading.js

@@ -20,4 +20,9 @@ export const reading = {
      * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
      */
     moved: 0,
+    /**
+     * How many changes an `input` signal has reported, in any mix, so a fill can tell an input moved
+     * since it read it. One count for every mix, as `moved` is.
+     */
+    inputs: 0,
 };

package/dist/record.d.ts

@@ -0,0 +1,9 @@
+import type { Subject } from './voice.js';
+/**
+ * A subject's record for `voice` holding every field one can come to hold, in one order, so every
+ * record in a mix shares one hidden class: a record built elsewhere, or given `base`, `snaps` or
+ * `from` later, took a class of its own, and a fold walking a chain of several kinds reads each
+ * field the slow way. The caller sets what it knows; nothing here takes a number, which a call V8
+ * does not inline would box.
+ */
+export declare function record(voice: object | null, reaches: boolean, state: unknown): Subject<unknown>;

package/dist/record.js

@@ -0,0 +1,42 @@
+/**
+ * A subject's record for `voice` holding every field one can come to hold, in one order, so every
+ * record in a mix shares one hidden class: a record built elsewhere, or given `base`, `snaps` or
+ * `from` later, took a class of its own, and a fold walking a chain of several kinds reads each
+ * field the slow way. The caller sets what it knows; nothing here takes a number, which a call V8
+ * does not inline would box.
+ */
+export function record(voice, reaches, state) {
+    return {
+        reaches,
+        delay: 0,
+        since: 0,
+        shown: 0,
+        weight: 0,
+        rested: false,
+        bands: null,
+        state,
+        stepped: 0,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        rebuilt: 0,
+        base: undefined,
+        slope: undefined,
+        kept: null,
+        unkept: undefined,
+        snaps: undefined,
+        from: undefined,
+        unknown: undefined,
+        inputs: undefined,
+        replay: undefined,
+        voice,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+        run: -1,
+        freed: -1,
+    };
+}

package/dist/relink.d.ts

@@ -3,12 +3,16 @@ import type { Subject } from './voice.js';
 interface Ordered {
     readonly id: number;
 }
+/** What `patch` asks a mix: a voice's record for a subject where a full relink would link it. */
+interface Linker<V, I> {
+    linkable(voice: V, subject: I, slot: number): Subject<unknown> | null;
+}
 /**
  * The voices over every subject behind each step of a mix's `version`, so a chain linked a few
  * steps back can be brought up to date by those voices alone; null for a step that changed
  * anything else, after which every chain links afresh.
  */
-export declare class Steps<V extends Ordered> {
+export declare class Steps<V extends Ordered, I> {
     private list;
     /** The version before `list[0]`. */
     private from;
@@ -16,10 +20,12 @@ export declare class Steps<V extends Ordered> {
     push(voice: V | null, version: number): void;
     /**
      * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
-     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
-     * voice's record where a full relink would link it and null where it would not. undefined where
-     * the steps since do not say, so the chain must link afresh.
+     * stepped since taken off it or put on at its place in voice order by `mix.linkable`, which gives
+     * the voice's record where a full relink would link it and null where it would not. undefined
+     * where the steps since do not say, so the chain must link afresh. It takes the mix and the
+     * subject, not a function closed over them: a closure and its context a subject cost the `swap`
+     * row about 138 B each (bench/allocs.mjs, 2026-10-09).
      */
-    patch(head: Subject<unknown> | null, version: number, reach: (voice: V) => Subject<unknown> | null): Subject<unknown> | null | undefined;
+    patch(head: Subject<unknown> | null, version: number, mix: Linker<V, I>, subject: I, slot: number): Subject<unknown> | null | undefined;
 }
 export {};

package/dist/relink.js

@@ -21,11 +21,13 @@ export class Steps {
     }
     /**
      * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
-     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
-     * voice's record where a full relink would link it and null where it would not. undefined where
-     * the steps since do not say, so the chain must link afresh.
+     * stepped since taken off it or put on at its place in voice order by `mix.linkable`, which gives
+     * the voice's record where a full relink would link it and null where it would not. undefined
+     * where the steps since do not say, so the chain must link afresh. It takes the mix and the
+     * subject, not a function closed over them: a closure and its context a subject cost the `swap`
+     * row about 138 B each (bench/allocs.mjs, 2026-10-09).
      */
-    patch(head, version, reach) {
+    patch(head, version, mix, subject, slot) {
         if (!(version >= this.from))
             return undefined;
         const list = this.list;
@@ -40,7 +42,7 @@ export class Steps {
                 at = at.next;
             }
             const here = at !== null && at.voice === voice ? at : null;
-            const want = reach(voice);
+            const want = mix.linkable(voice, subject, slot);
             if (want === here)
                 continue;
             const after = here === null ? at : here.next;

package/dist/restored.d.ts

@@ -0,0 +1,41 @@
+import type { Leavings } from './leavings.js';
+import { Store } from './store.js';
+import type { Cut } from './transport.js';
+import type { Subject } from './voice.js';
+/**
+ * A voice's records once a seek has gone back: each subject's is put back from the record it had,
+ * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
+ * It is one store however many seeks there are: by subject it keeps how many seeks its record has
+ * been put back for, and a record behind is put back to the earliest moment sought since, as a
+ * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ */
+export declare class Restored<I> extends Store<I, Subject<unknown>> {
+    private readonly own;
+    private readonly make;
+    /** Seeks back so far. */
+    private n;
+    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    private readonly at;
+    /**
+     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
+     * moment sought since seek `n` is that of the first here at or after it.
+     */
+    private readonly least;
+    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
+    private futures;
+    /** 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.
+     */
+    constructor(own: Store<I, Subject<unknown>>, 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. */
+    private since;
+    get(key: I): Subject<unknown> | undefined;
+    set(key: I, value: Subject<unknown>): void;
+    delete(key: I): void;
+    clear(): void;
+}

package/dist/restored.js

@@ -0,0 +1,91 @@
+import { Store } from './store.js';
+/**
+ * A voice's records once a seek has gone back: each subject's is put back from the record it had,
+ * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
+ * It is one store however many seeks there are: by subject it keeps how many seeks its record has
+ * been put back for, and a record behind is put back to the earliest moment sought since, as a
+ * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ */
+export class Restored extends Store {
+    own;
+    make;
+    /** Seeks back so far. */
+    n = 0;
+    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    at = new Store();
+    /**
+     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
+     * moment sought since seek `n` is that of the first here at or after it.
+     */
+    least = [];
+    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
+    futures = null;
+    /** 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.
+     */
+    constructor(own, make) {
+        super();
+        this.own = own;
+        this.make = make;
+    }
+    /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
+    back(t, cut, left) {
+        const n = ++this.n;
+        const least = this.least;
+        while (least.length > 0 && least[least.length - 1].t >= t)
+            least.pop();
+        least.push({ n, t });
+        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. */
+    since(from) {
+        const least = this.least;
+        let lo = 0;
+        let hi = least.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (least[mid].n >= from)
+                hi = mid;
+            else
+                lo = mid + 1;
+        }
+        return least[lo].t;
+    }
+    get(key) {
+        const at = this.at.get(key) ?? 0;
+        if (at === this.n)
+            return this.own.get(key);
+        this.at.set(key, this.n);
+        // 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);
+        if (made === undefined)
+            this.own.delete(key);
+        else
+            this.own.set(key, made);
+        return made;
+    }
+    set(key, value) {
+        this.own.set(key, value);
+        this.at.set(key, this.n);
+    }
+    delete(key) {
+        this.own.delete(key);
+        this.at.set(key, this.n);
+    }
+    clear() {
+        this.own.clear();
+        this.at.clear();
+    }
+}

package/dist/revive.d.ts

@@ -1,5 +1,6 @@
 import type { Mixer } from './mixer.js';
 import type { Run } from './motions.js';
+import type { Past } from './origin.js';
 import { type PackedRecord } from './pack.js';
 import { type Key } from './paging.js';
 import type { Described } from './types.js';
@@ -22,8 +23,13 @@ interface PackedVoice {
     outAt: number;
     outOver: number;
     outSet: boolean;
+    rebuilds: number;
+    past: number;
+    clocks: Past[] | null;
     cuedAt: number;
+    cuedSeq: number;
     doneAt: number;
+    doneSeq: number;
     opened: number;
     pinned: number;
     latest: number;
@@ -32,11 +38,12 @@ interface PackedVoice {
     log: Controls[] | null;
     played: boolean | undefined;
     playedAt: number;
+    playedSeq: number;
     records: [Key, PackedRecord][];
     runs: [Key, Run][];
-    left: [Key, number, PackedRecord][];
-    parts: [Key, number, number][];
-    parted: [Key, number][];
+    left: [Key, number, number, PackedRecord, boolean][];
+    parts: [Key, number, number, number][];
+    parted: [Key, number, number][];
 }
 /**
  * Voices a history store holds whose handles something still holds, by id: a seek that revives