@msb235/blits 0.11.0 → 0.12.1

package/dist/restored.js

@@ -1,33 +1,70 @@
 import { Store } from './store.js';
+const stamp = (of) => ({
+    t: Number.NaN,
+    seq: 0,
+    up: null,
+    rank: 0,
+    left: null,
+    cut: null,
+    of,
+});
+/** What a reaching record a store has let go of is stamped with, so setting it again is seen. */
+const gone = stamp(null);
+/** The root `s` was joined to, halving the path there for the next read. */
+function rootOf(s) {
+    let x = s;
+    let up = x.up;
+    while (up !== null) {
+        const next = up.up;
+        if (next === null)
+            return up;
+        x.up = next;
+        x = next;
+        up = x.up;
+    }
+    return x;
+}
 /**
  * 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.
+ * It is one store however many seeks there are: by subject it keeps the stamp of the seek its
+ * record was last put back at, 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;
     now;
     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. */
+    /** What a record put back now is stamped with, filled by the next seek. */
+    stamp = stamp(this);
+    /** What a record never stamped reads as: the first seek's. */
+    first = this.stamp;
+    /**
+     * By subject, the stamp its record was last put back, written or deleted at; none reads as
+     * `first`. A record that reaches its subject is its own, and holds it as `restored` instead,
+     * sparing a write here per subject a seek puts back; one that does not may stand for many.
+     */
     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.
+     * The roots, each moment earlier than the next, held weakly: one no record can reach is never
+     * read again, and those are cleared out once the list doubles.
+     */
+    roots = [];
+    kept = 0;
+    /**
+     * Stamps made a batch ahead of their seeks: one made at its seek is young when every old record
+     * is written with it, and V8 notes each such write for its next scavenge.
      */
-    least = [];
-    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
-    futures = null;
+    ready = [];
+    aging = [];
     /** The latest seek's moment. */
-    t = Number.NaN;
+    top = Number.NaN;
     /**
      * `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.
+     * that has not left since and is not reached has there, as a seek to `at` takes it. `make` puts
+     * a record back as it stood at `at`, undefined where it had none then; `mine` says `live` is the
+     * record this store held, which nothing else does.
      */
     constructor(own, now, make) {
         super();
@@ -37,57 +74,130 @@ export class Restored extends Store {
     }
     /** 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, seq: cut.seq });
-        this.t = t;
+        const s = this.stamp;
         if (left !== null) {
-            this.futures ??= new Map();
-            this.futures.set(n, { left, cut });
+            s.left = left;
+            s.cut = cut;
+        }
+        // Every root at or after `t` now reads `t`, so they and `s` are joined under one.
+        const roots = this.roots;
+        let root = s;
+        let ref = null;
+        while (roots.length > 0) {
+            const r = roots[roots.length - 1].deref();
+            if (r !== undefined && r.t < t)
+                break;
+            const w = roots.pop();
+            if (r === undefined)
+                continue;
+            if (r.rank > root.rank) {
+                root.up = r;
+                root = r;
+                ref = w;
+            }
+            else {
+                r.up = root;
+                if (r.rank === root.rank)
+                    root.rank++;
+            }
+        }
+        root.t = t;
+        root.seq = cut.seq;
+        roots.push(ref ?? new WeakRef(root));
+        if (roots.length > 2 * this.kept + 16) {
+            this.roots = roots.filter((w) => w.deref() !== undefined);
+            this.kept = this.roots.length;
         }
+        this.stamp = this.fresh();
+        this.top = t;
     }
-    /** 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;
-        let hi = least.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (least[mid].n >= from)
-                hi = mid;
-            else
-                lo = mid + 1;
+    /** The next seek's stamp, from a batch made a batch of seeks ago, twice as many each time to 64. */
+    fresh() {
+        if (this.ready.length === 0) {
+            const n = Math.min(64, Math.max(1, this.aging.length * 2));
+            this.ready = this.aging.reverse();
+            this.aging = [];
+            for (let i = 0; i < n; i++)
+                this.aging.push(stamp(this));
         }
-        return least[lo];
+        return this.ready.pop() ?? stamp(this);
     }
+    /**
+     * Whether a reaching record stamped by this store is still its record for the key it was found
+     * under: every record let go is stamped `gone`, copies are stamped with nothing, and this turns
+     * false if a stamped record is set again, which could put it under a second key.
+     */
+    sure = true;
     get(key) {
-        const at = this.at.get(key) ?? 0;
-        if (at === this.n)
-            return this.own.get(key);
-        this.at.set(key, this.n);
+        return this.from(key, this.own.get(key));
+    }
+    /** A chain's record for a subject, found again without a lookup where this store stamped it. */
+    find(key, guess) {
+        const s = guess.restored;
+        return s !== null && s.of === this && this.sure ? this.from(key, guess) : this.get(key);
+    }
+    /** `get`, given what `own` holds for `key`. */
+    from(key, own) {
+        const mark = own !== undefined && own.reaches;
+        const at = (mark ? own.restored : this.at.get(key)) ?? this.first;
+        const now = this.stamp;
+        if (at === now)
+            return own;
+        if (mark)
+            own.restored = now;
+        else
+            this.at.set(key, now);
         // 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 { 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
-            this.own.set(key, made);
+        const root = rootOf(at);
+        const left = at.left?.at(key, at.cut);
+        const live = left ?? this.now(key, own, root);
+        const made = live && this.make(live, root, left === undefined);
+        // Looked up again, not taken from `own`: a call made while it was put back may have set it.
+        if (made === undefined) {
+            this.shed(key);
+            if (mark)
+                this.at.set(key, now);
+        }
+        else if (made !== own)
+            this.set(key, made);
+        else if (!made.reaches)
+            this.at.set(key, now);
         return made;
     }
     set(key, value) {
+        const old = this.own.get(key);
+        if (old === value) {
+            if (value.reaches)
+                value.restored = this.stamp;
+            else
+                this.at.set(key, this.stamp);
+            return;
+        }
+        if (old?.reaches)
+            old.restored = gone;
+        // Stamped already, it may be in a chain under another key.
+        if (value.reaches && value.restored !== null)
+            this.sure = false;
         this.own.set(key, value);
-        this.at.set(key, this.n);
+        if (value.reaches)
+            value.restored = this.stamp;
+        else
+            this.at.set(key, this.stamp);
     }
     delete(key) {
+        this.shed(key);
+        this.at.set(key, this.stamp);
+    }
+    /** Lets go of the record held for `key`, stamping it `gone`. */
+    shed(key) {
+        const old = this.own.get(key);
+        if (old?.reaches)
+            old.restored = gone;
         this.own.delete(key);
-        this.at.set(key, this.n);
     }
     clear() {
+        this.sure = false;
         this.own.clear();
         this.at.clear();
     }

package/dist/revive.d.ts

@@ -24,6 +24,7 @@ interface PackedVoice {
     outOver: number;
     outSet: boolean;
     rebuilds: number;
+    hold: number;
     past: number;
     clocks: Past[] | null;
     cuedAt: number;

package/dist/revive.js

@@ -83,6 +83,7 @@ function packVoice(voice, keys) {
         outOver: voice.outOver,
         outSet: voice.outSet,
         rebuilds: voice.rebuilds,
+        hold: voice.hold,
         past: voice.clocks?.length ?? 0,
         clocks: voice.clocks,
         cuedAt: voice.cuedAt,

package/dist/roster.js

@@ -4,7 +4,8 @@ import { Store } from './store.js';
 function tally(mix, voice, by) {
     if (voice.spec.locus !== undefined)
         mix.loci += by;
-    if (voice.spec.anchor !== undefined)
+    const e = voice.spec.earliest;
+    if (voice.spec.anchor !== undefined || (e !== undefined && typeof e !== 'number'))
         mix.anchored += by;
 }
 /** Counts a voice just put in the list into everything a sync and a fold skip work by. */

package/dist/seek.js

@@ -2,7 +2,7 @@ import { heldAt } from './chain.js';
 import { schedule } from './due.js';
 import { fadesAt } from './fade.js';
 import { origin } from './held.js';
-import { apart, copyHeld, last, lastWithin } from './history.js';
+import { apart, copyHeld, copyHeldInto, lastIndex, lastWithin, unread } from './history.js';
 import { laneHost } from './hosts.js';
 import { Leavings } from './leavings.js';
 import { move, nextFrame } from './move.js';
@@ -22,12 +22,15 @@ import { cover, coverFrame, cut } from './unpage.js';
  * probe by `t` read is not kept, and a lane holds it apart from the record, so the record reads 0
  * until the next probe.
  */
-function restore(mix, voice, live, t, every) {
+function restore(mix, voice, live, at, every, mine) {
+    // Read here, not passed: a double passed to a call is boxed, once per record put back.
+    const t = at.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);
+        // Nothing a step or `setting.keep` holds: what it keeps does not move with time. One record
+        // stands for every subject a voice does not reach, so that one is copied.
+        const h = mine && live.reaches ? unread(live) : 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.
@@ -38,37 +41,84 @@ function restore(mix, voice, live, t, every) {
             origin(mix, voice, h);
         return h;
     }
-    const snap = last(snaps, t, true);
-    if (snap === undefined)
+    // A seek back to just before now finds its copy among the newest, looked at before searching.
+    const n = snaps.length;
+    const i = n > 0 && snaps[n - 1].at <= t
+        ? n - 1
+        : n > 1 && snaps[n - 2].at <= t
+            ? n - 2
+            : lastIndex(snaps, t, true);
+    if (i < 0)
         return undefined;
-    const h = copyHeld(voice, snap.held);
+    const snap = snaps[i];
+    // What the record replaced held, which a record put back over it would lose.
+    const { ticks, since, rebuilt, state, slot, restored } = live;
+    let h;
+    if (mine && live.reaches) {
+        // Its chain may still read its number from it, and its store has just stamped it.
+        h = copyHeldInto(voice, snap.held, live, true);
+        h.slot = slot;
+        h.restored = restored;
+    }
+    else
+        h = copyHeld(voice, snap.held, true);
     h.weight = 0;
     if (snap.at < t)
         h.copied = true;
-    h.snaps = snaps.slice(0, snaps.indexOf(snap) + 1);
+    const kept = i + 1;
+    // The record replaced is let go, so its list is cut where it stands.
+    if (mine)
+        trim(voice, snaps, kept);
+    else
+        for (let i = 0; i < kept; i++)
+            snaps[i].shared = true;
+    h.snaps = mine ? snaps : snaps.slice(0, kept);
     h.inputs = inputs;
     // A start still ahead when the copy was kept may have moved before `t`, with no copy between.
     if (!(h.since <= snap.at))
         origin(mix, voice, h);
-    if (voice.patch.step !== undefined && (snap.ahead !== undefined || t - snap.at >= every)) {
-        const ahead = snap.ahead;
+    // The record a seek replaces, stepped on from this copy with nothing since rebuilding or moving
+    // its start, holds the copy's state at its own `ticks`, which a probe there need not step to.
+    const was = mine && ticks > h.ticks && since === h.since && rebuilt === h.rebuilt;
+    if (voice.patch.step !== undefined && (snap.ahead !== undefined || t - snap.at >= every || was)) {
+        let ahead = snap.ahead;
         // Steps counted from a start that has moved since are not this record's.
-        if (ahead === undefined || ahead.since !== h.since)
-            snap.ahead = {
+        if (ahead === undefined || ahead.since !== h.since) {
+            ahead = {
                 put: h,
                 sought: t,
                 since: h.since,
                 at: snap.at,
                 ticks: h.ticks,
                 state: undefined,
+                leftTicks: 0,
+                left: undefined,
             };
+            snap.ahead = ahead;
+        }
         else {
             ahead.put = h;
             ahead.sought = t;
         }
+        if (was) {
+            // Nothing else holds the record replaced, so its state is taken, not copied.
+            ahead.leftTicks = ticks;
+            ahead.left = state;
+        }
     }
     return h;
 }
+/** Cuts a record's list of copies to its first `kept`, keeping those no other list holds as spares. */
+function trim(voice, snaps, kept) {
+    while (snaps.length > kept) {
+        const snap = snaps.pop();
+        if (snap.shared)
+            continue;
+        snap.ahead = undefined;
+        voice.spares ??= [];
+        voice.spares.push(snap);
+    }
+}
 /** 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;
@@ -122,6 +172,7 @@ function restoreVoice(mix, voice, t, seq) {
     voice.unreached = null;
     voice.unreachedBits = null;
     voice.seeks++;
+    voice.spares = null;
     const left = voice.left?.all() ?? [];
     if (voice.left !== null)
         fadesAt(voice, voice.left.after(cut), seq);
@@ -130,21 +181,22 @@ function restoreVoice(mix, voice, t, seq) {
     let records = voice.subjects;
     if (!(records instanceof Restored)) {
         const every = apart(mix.opts.history);
-        const now = (subject, held, least, seq) => heldAt(voice, subject, held, least, seq);
-        records = new Restored(records, now, (live, least, top) => {
-            const h = restore(mix, voice, live, least, every);
+        const now = (subject, held, at) => heldAt(voice, subject, held, at.t, at.seq);
+        const restored = new Restored(records, now, (live, at, mine) => {
+            const h = restore(mix, voice, live, at, every, mine);
             if (h === undefined)
                 return h;
             if (h.reaches)
                 voice.seen++;
             if (h.rested)
                 voice.restedCount++;
-            if (!(h.since <= top)) {
+            if (!(h.since <= restored.top)) {
                 voice.early ??= [];
                 voice.early.push(h);
             }
             return h;
         });
+        records = restored;
         voice.subjects = records;
     }
     records.back(t, cut, future);
@@ -277,10 +329,12 @@ function back(mix, t, seq, on) {
             voice.holding.back(seq);
         }
     // Rebuilt from the voices that are back: the lanes, the chains and every count the fold reads.
+    // Subject numbers carry over, and with them the chains that hold them, each linked afresh.
     const oldLanes = mix.lanes;
     if (oldLanes !== null && mix.lanesOf !== null)
-        mix.lanes = new mix.lanesOf(laneHost(mix));
-    mix.chains = new Store();
+        mix.lanes = new mix.lanesOf(laneHost(mix), oldLanes);
+    else
+        mix.chains = new Store();
     mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
     recount(mix);
     mix.parters.clear();

package/dist/shared.d.ts

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

package/dist/shared.js

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

package/dist/spans.d.ts

@@ -22,6 +22,11 @@ export declare function checkChild<I, O>(spec: VoiceSpec<I, O>, child: Voice<I,
  * after.
  */
 export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?: number): void;
+/**
+ * Fits again each span with a child still to start whose anchored `earliest` answers differently
+ * than at its last fit: an anchor that has come to have an answer, or moved.
+ */
+export declare function refloor<I, O>(mix: Mixer<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. */

package/dist/spans.js

@@ -1,3 +1,4 @@
+import { arcEnd } from './arcs.js';
 import { elapsedWith, retime } from './clock.js';
 import { retire } from './fade.js';
 import { defaultFit, layout, settle } from './fit.js';
@@ -6,6 +7,7 @@ import { noted } from './history.js';
 import { nextFrame } from './move.js';
 import { leave } from './origin.js';
 import { ownerReading } from './owner.js';
+import { resolve } from './place.js';
 /** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
 export class Fitting {
     budget;
@@ -39,9 +41,13 @@ export class Fitting {
 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.arc !== null) {
+        if (!Number.isFinite(arcEnd(child)))
+            throw new Error('blits: a span cannot fit an arc held open, which never ends');
+    }
+    else if (child.holding !== null) {
         if (child.fitting === null)
-            throw new Error('blits: a span holds voices and spans, not owners');
+            throw new Error('blits: a span holds voices, spans and arcs, not owners');
     }
     else if (!Number.isFinite(child.span))
         throw new Error('blits: a span cannot fit a voice that never ends');
@@ -59,7 +65,7 @@ function elapsedIn(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;
+    const length = child.fitting !== null ? child.fitting.end : child.arc !== null ? arcEnd(child) : child.span;
     return Math.max(0, length - elapsedIn(child, local));
 }
 /**
@@ -73,10 +79,11 @@ export function refit(mix, span, from = mix.now) {
     if (mix.projecting || span.state === 'done')
         return;
     const local = clockOf(span, from);
-    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 { kids, floors, waiting } = lineUp(mix, span, local);
+    const claims = kids.map((c, i) => {
         const s = c.spec;
         return {
+            floor: floors[i],
             natural: leftOf(c, local) / (s.rate ?? 1),
             state: c.state === 'pending' ? 'pending' : 'playing',
             faster: Math.max(1, s.faster ?? 1),
@@ -127,6 +134,17 @@ export function refit(mix, span, from = mix.now) {
             noted(mix, c);
         }
     });
+    for (const c of waiting) {
+        if (c.start === Number.POSITIVE_INFINITY)
+            continue;
+        c.start = Number.POSITIVE_INFINITY;
+        c.anchorNow = Number.POSITIVE_INFINITY;
+        c.anchorElapsed = 0;
+        c.clocks = null;
+        mix.frame = nextFrame();
+        reorigin(mix, c, mix.now);
+        noted(mix, c);
+    }
     if (kids.length > 0)
         mix.lanes?.refill();
     const reach = local + length;
@@ -147,6 +165,58 @@ export function refit(mix, span, from = mix.now) {
             refit(mix, span.owner, from);
     }
 }
+/**
+ * A span's children still to fit, in the order it lays them out: those playing first, as cued, then
+ * those still to start by rank. Each pending one's floor is where its `earliest` answers, span ms
+ * from `local`, and before `local` only in the frame it was cued. One whose anchor has no answer yet waits unplaced, and under `queue` or `stagger`
+ * so does every child after it, since each is laid out from the one before.
+ */
+function lineUp(mix, span, local) {
+    const live = (span.holding?.children ?? []).filter((c) => c.state !== 'done' && c.state !== 'frozen' && c.state !== 'fading' && leftOf(c, local) > 0);
+    const kids = live.filter((c) => c.state !== 'pending');
+    const floors = kids.map(() => undefined);
+    const waiting = [];
+    const pending = live
+        .filter((c) => c.state === 'pending')
+        .sort((a, b) => (a.spec.rank ?? 0) - (b.spec.rank ?? 0));
+    const chained = span.fitting.claim.order !== 'together';
+    for (const c of pending) {
+        const e = c.spec.earliest;
+        const t = e === undefined ? undefined : resolve(mix, e, c, Number.NEGATIVE_INFINITY);
+        c.floorSeen = t ?? Number.NaN;
+        if ((e !== undefined && t === undefined) || (chained && waiting.length > 0)) {
+            waiting.push(c);
+            continue;
+        }
+        kids.push(c);
+        // An anchor that answered before the span began has no time on its clock: no bound.
+        const floor = t === undefined || t === Number.NEGATIVE_INFINITY ? undefined : t - local;
+        // A past floor places a child only as it is cued: one waiting since waits on those before it.
+        floors.push(floor === undefined || c.cuedSeq === mix.transport.seq ? floor : Math.max(0, floor));
+    }
+    return { kids, floors, waiting };
+}
+/**
+ * Fits again each span with a child still to start whose anchored `earliest` answers differently
+ * than at its last fit: an anchor that has come to have an answer, or moved.
+ */
+export function refloor(mix) {
+    if (mix.projecting)
+        return;
+    for (const span of mix.owners ?? []) {
+        if (span.fitting === null || span.state === 'done')
+            continue;
+        const moved = (span.holding?.children ?? []).some((c) => {
+            const e = c.spec.earliest;
+            if (c.state !== 'pending' || e === undefined || typeof e === 'number')
+                return false;
+            const t = resolve(mix, e, c, Number.NEGATIVE_INFINITY) ?? Number.NaN;
+            return !Object.is(t, c.floorSeen);
+        });
+        if (moved)
+            refit(mix, span);
+    }
+}
 /** 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;

package/dist/store.d.ts

@@ -16,6 +16,8 @@ export declare class Store<K, V> {
     private oneValue;
     get(key: K): V | undefined;
     set(key: K, value: V): void;
+    /** As `get`, where `guess` may be the value for `key`, which a store that can tell spares a lookup. */
+    find(key: K, _guess: V): V | undefined;
     has(key: K): boolean;
     delete(key: K): void;
     clear(): void;

package/dist/store.js

@@ -43,6 +43,10 @@ export class Store {
         }
         this.strong.set(key, value);
     }
+    /** As `get`, where `guess` may be the value for `key`, which a store that can tell spares a lookup. */
+    find(key, _guess) {
+        return this.get(key);
+    }
     has(key) {
         return this.get(key) !== undefined;
     }

package/dist/touch.js

@@ -1,3 +1,4 @@
+import { headOf } from './chain.js';
 import { restamp } from './everyone.js';
 import { nextFrame } from './move.js';
 /**
@@ -16,10 +17,10 @@ export function touch(mix, subject) {
     }
     else {
         // No voice's `seeks` is below 0, so no record stamped with it reads as current.
-        let held = mix.chains.get(subject) ?? null;
+        let held = headOf(mix, subject) ?? null;
         for (; held !== null; held = held.next)
             held.seeks = -1;
-        const slot = mix.chains.get(subject)?.slot ?? -1;
+        const slot = headOf(mix, subject)?.slot ?? -1;
         for (const voice of mix.sharers)
             restamp(voice, slot);
     }