@msb235/blits 0.11.0 → 0.12.1

package/dist/mixer.js

@@ -1,6 +1,7 @@
+import { cueArc } from './arcs.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, linkable, relink, unlink } from './chain.js';
-import { lerpInto } from './channels.js';
+import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
+import { lerpInto, scalarOp } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
 import { beginFade, leaveVoice, parting } from './fade.js';
@@ -27,6 +28,7 @@ import { record, unplayable } from './tape.js';
 import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
+import { gave, historyFor, register, unregister } from './watch.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
 /**
  * What a mix takes where its options say nothing. Not exported from the package: the suite turns
@@ -142,6 +144,8 @@ export class Mixer {
      */
     chains = new Store();
     version = 0;
+    /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
+    primed = new Float64Array(3 /* Primed.SIZE */);
     steps = new Steps();
     /** Per subject, the voices whose `subjects` name it, in voice order. */
     named = new Store();
@@ -205,6 +209,8 @@ export class Mixer {
     bounded;
     /** By slot, a stock array channel's in-place `lerp`. */
     lerpsInto;
+    /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
+    scalars;
     /** What a fold with a locus in play gathers into, one per depth of folds under way. */
     locusScratch = [];
     locusDepth = 0;
@@ -215,6 +221,8 @@ export class Mixer {
     bookers = null;
     /** The fit a span being cued takes, which `cue` hands its voice. */
     fitting = null;
+    /** What an arc being cued keeps, which `cue` hands its voice. */
+    arcing = null;
     /** Every owner still in the mix, null until one is cued. */
     owners = null;
     /** With a history store, the key each subject is paged under; null without one. */
@@ -231,6 +239,7 @@ export class Mixer {
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
         this.lerpsInto = this.channels.map((c) => lerpInto(c));
+        this.scalars = this.channels.map((c) => scalarOp(c));
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
@@ -372,6 +381,9 @@ export class Mixer {
             this.fitting = null;
         }
     }
+    arc(spec) {
+        return cueArc(this, spec);
+    }
     sync(timestamp) {
         this.own('sync').sync(timestamp);
     }
@@ -496,6 +508,9 @@ export class Mixer {
         const motion = voice.motion;
         return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
     }
+    close() {
+        unregister(this);
+    }
     mute(opts) {
         for (const voice of this.cued) {
             voice.written = true;
@@ -505,12 +520,14 @@ export class Mixer {
     }
     drop(subject) {
         this.frame = nextFrame();
-        const head = this.chains.get(subject);
+        const head = headOf(this, subject);
         // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
         if (head !== undefined)
             unlink(this, head);
-        if (head !== undefined && head.slot >= 0 && this.lanes !== null)
-            this.lanes.release(head.slot);
+        // A number a seek carried over is released even where its chain is not linked since.
+        const slot = this.chains.get(subject)?.slot ?? -1;
+        if (slot >= 0 && this.lanes !== null)
+            this.lanes.release(slot);
         // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
         if (this.projecting && !(this.pose instanceof Masked))
             this.pose = new Masked(this.pose);
@@ -521,40 +538,24 @@ export class Mixer {
         // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
         // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
         const kept = releasing(this);
-        // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
-        const release = (motion) => {
-            if (!this.projecting)
-                motion.release(subject, ...kept);
-            else if (motion.holds(subject))
-                unplayable('a drop of a subject a motion patch holds');
-        };
-        const forget = (voice) => {
-            leaveVoice(this, voice, subject);
-            voice.subjects.delete(subject);
-            if (voice.motion !== undefined)
-                release(voice.motion);
-            voice.parts?.delete(subject);
-            voice.parted?.delete(subject);
-            voice.blend?.of.reads.delete(subject);
-        };
         for (const voice of this.general)
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
         const named = this.named.get(subject);
         if (named !== undefined)
             for (const voice of [...named])
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         const gone = goneIndex(this);
         for (const voice of gone.general)
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
         const goneNaming = gone.named.get(subject);
         if (goneNaming !== undefined)
             for (const voice of goneNaming)
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         if (this.owners !== null)
             for (const voice of this.owners)
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         for (const voice of this.parters) {
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
             if (voice.parts?.size === 0)
                 voice.parts = null;
             if (voice.parted?.size === 0)
@@ -565,10 +566,30 @@ export class Mixer {
         const strays = this.strays.get(subject);
         if (strays !== undefined)
             for (const motion of strays)
-                release(motion);
+                this.releaseIn(motion, subject, kept);
         this.strays.delete(subject);
         for (const motion of this.strayAll)
-            release(motion);
+            this.releaseIn(motion, subject, kept);
+        this.recordDrop(subject);
+    }
+    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
+    forgetIn(voice, subject, kept) {
+        leaveVoice(this, voice, subject);
+        voice.subjects.delete(subject);
+        if (voice.motion !== undefined)
+            this.releaseIn(voice.motion, subject, kept);
+        voice.parts?.delete(subject);
+        voice.parted?.delete(subject);
+        voice.blend?.of.reads.delete(subject);
+    }
+    // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
+    releaseIn(motion, subject, kept) {
+        if (!this.projecting)
+            motion.release(subject, kept[0], kept[1], kept[2]);
+        else if (motion.holds(subject))
+            unplayable('a drop of a subject a motion patch holds');
+    }
+    recordDrop(subject) {
         record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
     }
     touch(subject) {
@@ -680,6 +701,15 @@ function named(transport, name) {
     if (taken.some((m) => m.name === name))
         throw new Error(`blits: a mix named ${name} is already on this transport, or a seek could bring it back`);
 }
+/** Makes a mix the host asked for, with the registry's history where it names none, and lists it there. */
+export function made(kit, opts, lanes) {
+    const { history, added } = historyFor(opts);
+    const m = new Mixer(kit, added ? { ...opts, history } : opts, lanes);
+    if (added)
+        gave(m.transport);
+    register(m);
+    return m;
+}
 /**
  * The one that ships: every form on the CPU, probed per subject on demand.
  *
@@ -689,7 +719,7 @@ export const mixer = {
     name: 'mixer',
     runs: new Set(['fn', 'keys', 'motion']),
     create(kit, opts) {
-        return new Mixer(kit, opts, Lanes);
+        return made(kit, opts, Lanes);
     },
 };
 /**

package/dist/move.js

@@ -1,7 +1,8 @@
+import { settleArcs } from './arcs.js';
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
 import { byId, popDue, schedule } from './due.js';
-import { detour } from './everyone.js';
+import { detour, outgrow } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
 import { begin } from './held.js';
@@ -129,8 +130,12 @@ function moveTo(mix, now) {
         if (!mix.projecting)
             schedule(mix, voice);
     }
-    if (mix.owners !== null)
+    if (mix.owners !== null) {
         lapse(mix, now);
+        settleArcs(mix, now);
+    }
+    if (mix.sharers.length > 0 && !mix.projecting)
+        outgrow(mix);
     mix.stirred = false;
     if (mix.retired.length > 0)
         prune(mix);

package/dist/numbers.d.ts

@@ -6,7 +6,7 @@ export declare const absent: unique symbol;
  * them, so numbering one never keeps it alive.
  */
 export declare class Numbers<I> {
-    private readonly owner;
+    private owner;
     private next;
     /** Numbers released for reuse; null until one is, as most patches never release one. */
     private free;
@@ -26,6 +26,10 @@ export declare class Numbers<I> {
     constructor(owner: {
         forget(slot: number): void;
     });
+    /** Hands the numbers to a new owner, which hears of every release from now on. */
+    adopt(owner: {
+        forget(slot: number): void;
+    }): void;
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size(): number;
     take(subject: I): number;

package/dist/numbers.js

@@ -29,6 +29,10 @@ export class Numbers {
     constructor(owner) {
         this.owner = owner;
     }
+    /** Hands the numbers to a new owner, which hears of every release from now on. */
+    adopt(owner) {
+        this.owner = owner;
+    }
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size() {
         return this.next;

package/dist/owner.js

@@ -1,3 +1,4 @@
+import { arcShare } from './arcs.js';
 import { backWith, clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
 /** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
 export const ownerPatch = Object.freeze({
@@ -128,8 +129,12 @@ export function ownWeight(owner, now, reduced, base) {
 /** What every owner above a voice multiplies into its weight. */
 export function ownersWeight(voice, now, reduced, base) {
     let w = 1;
-    for (let o = voice.owner; o !== null; o = o.owner)
+    let child = voice;
+    for (let o = voice.owner; o !== null; child = o, o = o.owner) {
         w *= ownWeight(o, now, reduced, base);
+        if (o.arc !== null)
+            w *= arcShare(o, child, now, reduced);
+    }
     return w;
 }
 /**

package/dist/place.d.ts

@@ -10,6 +10,8 @@ export declare function mixAt<I, O>(mix: Mixer<I, O>, u: number): number;
 export declare function pin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, u: number): void;
 /** Puts each pending voice's start, given in host time, where the mix's rate now puts it. */
 export declare function repin<I, O>(mix: Mixer<I, O>): void;
+/** Moves a pending voice's start, its clock with it; false where it is already there. */
+export declare function startAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, start: number): boolean;
 /** Refuses a placement that names a mark twice on one side, or that waits on itself. */
 export declare function checkPlacement<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>, anchor: Placement, owner: Voice<I, O> | null): void;
 /**
@@ -18,3 +20,9 @@ export declare function checkPlacement<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I
  * last gave. Repeated so a chain of anchors settles in one sync.
  */
 export declare function place<I, O>(mix: Mixer<I, O>): void;
+/**
+ * The time an anchor answers on its voice's owner's clock, or undefined while its target has none.
+ * A time before the owner starts answers `before`: undefined, so a start waits, or -Infinity for a
+ * floor, which is no bound at all.
+ */
+export declare function resolve<I, O>(mix: Mixer<I, O>, a: number | NonNullable<Placement['start']>, self: Voice<I, O>, before?: number): number | undefined;

package/dist/place.js

@@ -5,6 +5,7 @@ import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
 import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
+import { refloor } from './spans.js';
 import { none } from './voice.js';
 import { warnOnce } from './warn.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
@@ -35,7 +36,7 @@ export function repin(mix) {
     }
 }
 /** Moves a pending voice's start, its clock with it; false where it is already there. */
-function startAt(mix, voice, start) {
+export function startAt(mix, voice, start) {
     if (start === voice.start)
         return false;
     voice.start = start;
@@ -145,18 +146,23 @@ export function place(mix) {
             }
         }
         if (!moved)
-            return;
+            break;
     }
+    refloor(mix);
 }
-/** The time an anchor answers on its voice's owner's clock, or undefined while its target has none. */
-function resolve(mix, a, self) {
+/**
+ * The time an anchor answers on its voice's owner's clock, or undefined while its target has none.
+ * A time before the owner starts answers `before`: undefined, so a start waits, or -Infinity for a
+ * floor, which is no bound at all.
+ */
+export function resolve(mix, a, self, before) {
     const o = self.owner;
     if (typeof a === 'number')
         return o === null ? mixAt(mix, a - mix.offset) : a;
     if ('all' in a) {
         let latest = Number.NEGATIVE_INFINITY;
         for (const m of a.all) {
-            const t = member(mix, m, self);
+            const t = member(mix, m, self, before);
             if (t === undefined)
                 return undefined;
             latest = Math.max(latest, t);
@@ -169,7 +175,7 @@ function resolve(mix, a, self) {
         let earliest = Number.POSITIVE_INFINITY;
         let unknown = false;
         for (const m of a.any) {
-            const t = member(mix, m, self);
+            const t = member(mix, m, self, before);
             if (t === undefined)
                 unknown = true;
             else
@@ -205,14 +211,16 @@ function resolve(mix, a, self) {
     if (o === null)
         return t + by;
     const local = ownerReading(o, t);
+    if (local === Number.NEGATIVE_INFINITY)
+        return before;
     return Number.isFinite(local) ? local + by : undefined;
 }
 /**
  * What one member of a join answers, or the time it last gave once its target has left, as a lone
  * anchor keeps its voice where its target last put it.
  */
-function member(mix, a, self) {
-    const t = resolve(mix, a, self);
+function member(mix, a, self, before) {
+    const t = resolve(mix, a, self, before);
     if (t === undefined)
         return self.answers?.get(a);
     if (!mix.projecting) {

package/dist/project.js

@@ -1,5 +1,5 @@
 import { ownBlends } from './blend.js';
-import { heldAt } from './chain.js';
+import { headOf, heldAt } from './chain.js';
 import { stepOf } from './clock.js';
 import { open, sighted, weightAt } from './everyone.js';
 import { fadesAt } from './fade.js';
@@ -362,7 +362,7 @@ 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;
+        const slot = headOf(mix, subject)?.slot ?? -1;
         if (!sighted(voice, slot))
             return undefined;
         const all = voice.everyone;
@@ -373,7 +373,7 @@ function recordOf(mix, voice, subject) {
     const held = voice.subjects.get(subject);
     if (held !== undefined || voice.unreachedBits === null)
         return held;
-    return unreached(voice, mix.chains.get(subject)?.slot ?? -1)
+    return unreached(voice, headOf(mix, subject)?.slot ?? -1)
         ? voice.unreached
         : undefined;
 }

package/dist/qualify.d.ts

@@ -1,4 +1,5 @@
 import type { Lanes } from './lanes.js';
+import type { Channel } from './types.js';
 import type { Voice } from './voice.js';
 /** What qualifying needs of one voice: whether its patch and spec can run on a lane, and its channels. */
 export interface Candidate {
@@ -16,6 +17,15 @@ export declare function qualify(numeric: readonly boolean[], voices: readonly Ca
     voices: Set<number>;
 };
 export declare function requalify<I, O>(lanes: Lanes<I, O>, version: number): void;
+/** Whether `keepCallsOff` applies; settable for bench/frame.mjs. */
+export declare let callsOff: boolean;
+export declare function setCallsOff(on: boolean): void;
+/**
+ * A voice whose patch a lane would call, as a fn voice's (no tween, keys or motion), writing only
+ * arrays: a crowd writing a number reads 17% to 25% faster on lanes (bench/frame.mjs `named` under
+ * CALLS_OFF, msb-uai, 2026-10-21).
+ */
+export declare function calls<I, O>(v: Voice<I, O>, channels: readonly Channel<unknown>[]): boolean;
 /**
  * A voice starts playing on a lane or crowd: its epoch. Every subject meets a voice over all of
  * them on its next probe; a voice naming its subjects marks only those.

package/dist/qualify.js

@@ -53,6 +53,8 @@ export function requalify(lanes, version) {
     const numeric = host.channels.map((c) => numericOf(c) !== undefined);
     // A voice writing nothing has no lane to fill, so it stays where its calls are made.
     const fits = present.map((v) => v.slots.length > 0 && host.fits(v));
+    if (callsOff)
+        keepCallsOff(present, fits, host.channels);
     const candidates = () => present.map((v, i) => ({ id: v.id, fits: fits[i], slots: v.slots }));
     let { channels, voices } = qualify(numeric, candidates());
     // A locus folds its members together, so they run on lanes all together or not at all.
@@ -193,6 +195,54 @@ export function requalify(lanes, version) {
     }
     regroup(lanes, members);
 }
+/** Whether `keepCallsOff` applies; settable for bench/frame.mjs. */
+export let callsOff = true;
+export function setCallsOff(on) {
+    callsOff = on;
+}
+/**
+ * A voice whose patch a lane would call, as a fn voice's (no tween, keys or motion), writing only
+ * arrays: a crowd writing a number reads 17% to 25% faster on lanes (bench/frame.mjs `named` under
+ * CALLS_OFF, msb-uai, 2026-10-21).
+ */
+export function calls(v, channels) {
+    return (v.built === null &&
+        v.motion === undefined &&
+        v.slots.every((s) => vector(channels[s])));
+}
+/** A channel folding arrays with a rest, not `last`: what the rule was timed on. */
+function vector(channel) {
+    return Array.isArray(channel.rest) && numericOf(channel)?.op !== 'last';
+}
+/**
+ * Leaves off lanes each voice calling its patch where no other fitting voice writes any of its
+ * channels, but a crowd's other voices: a lane calls such a patch once a subject as the general
+ * path does, and its fill walks the subjects a second time (bench/frame.mjs `fns`, 2.58 ms a frame
+ * on lanes against 1.07 off, studio, 2026-10-21). Two voices over many subjects on one channel
+ * fold faster on lanes (`tweenfn` with three voices).
+ */
+function keepCallsOff(present, fits, channels) {
+    const others = new Array(channels.length).fill(false);
+    const wide = new Array(channels.length).fill(false);
+    present.forEach((v, i) => {
+        if (!fits[i])
+            return;
+        const crowd = crowdable(v);
+        if (!calls(v, channels))
+            for (const s of v.slots)
+                others[s] = true;
+        else if (!crowd)
+            for (const s of v.slots) {
+                if (wide[s])
+                    others[s] = true;
+                wide[s] = true;
+            }
+    });
+    present.forEach((v, i) => {
+        if (fits[i] && calls(v, channels) && !v.slots.some((s) => others[s]))
+            fits[i] = false;
+    });
+}
 /** Whether qualifying laned exactly the channels laned now. */
 function sameChannels(lanes, channels) {
     const by = lanes.bySlot;
@@ -273,7 +323,8 @@ export function retouch(lanes) {
             return qualify();
         const laned = v.slots.some((slot) => lanes.bySlot[slot] !== undefined);
         const fits = v.slots.length > 0 && lanes.host.fits(v);
-        if (!laned && !fits) {
+        // As `keepCallsOff`: with none of its channels laned, no fitting voice but its like writes them.
+        if (!laned && (!fits || (callsOff && crowdable(v) && calls(v, lanes.host.channels)))) {
             lanes.whole = false;
             continue;
         }

package/dist/reading.d.ts

@@ -7,7 +7,8 @@ export declare const reading: {
     live: boolean;
     /**
      * The earliest voice time a read may still ask for; a patch keeping a history may drop what is
-     * older. Infinity where the mix keeps none, so only what plays now is kept.
+     * older. Infinity where the mix keeps none, so only what plays now is kept. Set before a motion
+     * voice's read alone, so another patch finds whatever the last one left.
      */
     horizon: number;
     /**

package/dist/reading.js

@@ -7,7 +7,8 @@ export const reading = {
     live: true,
     /**
      * The earliest voice time a read may still ask for; a patch keeping a history may drop what is
-     * older. Infinity where the mix keeps none, so only what plays now is kept.
+     * older. Infinity where the mix keeps none, so only what plays now is kept. Set before a motion
+     * voice's read alone, so another patch finds whatever the last one left.
      */
     horizon: Number.POSITIVE_INFINITY,
     /**

package/dist/record.d.ts

@@ -1,4 +1,9 @@
 import type { Subject } from './voice.js';
+/** A record with every field written out, optional ones too, as every record in a mix is built. */
+export type WholeRecord = {
+    [K in Field]: Subject<unknown>[K];
+};
+type Field = keyof Subject<unknown>;
 /**
  * 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
@@ -7,3 +12,4 @@ import type { Subject } from './voice.js';
  * does not inline would box.
  */
 export declare function record(voice: object | null, reaches: boolean, state: unknown): Subject<unknown>;
+export {};

package/dist/record.js

@@ -40,5 +40,6 @@ export function record(voice, reaches, state) {
         slot: -1,
         run: -1,
         freed: -1,
+        restored: null,
     };
 }

package/dist/restored.d.ts

@@ -2,43 +2,92 @@ import type { Leavings } from './leavings.js';
 import { Store } from './store.js';
 import type { Cut } from './transport.js';
 import type { Subject } from './voice.js';
+/**
+ * The seeks back after the one a record was last put back, written or deleted at, which every
+ * record stamped then shares. The next seek fills it; a later seek to as early a moment joins it
+ * to its own, so the root it reaches holds the earliest moment sought since. Only records and the
+ * stamps joined beneath it hold it, so it is collected with the last record that can read it.
+ */
+/** A moment sought, the end of frame `seq`. */
+export interface Moment {
+    readonly t: number;
+    readonly seq: number;
+}
+export interface Stamp extends Moment {
+    /** On a root: the earliest moment sought since, and the frame that ended. */
+    t: number;
+    seq: number;
+    /** The stamp this one was joined to, null on a root. */
+    up: Stamp | null;
+    /** A bound on how deep the stamps joined beneath it go, so joining the lower keeps paths short. */
+    rank: number;
+    /** The records subjects left with after this seek's moment, and where it cut; null for none. */
+    left: Leavings<unknown> | null;
+    cut: Cut | null;
+    /** The store that made it; null on `gone`. */
+    readonly of: object | null;
+}
 /**
  * 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 declare class Restored<I> extends Store<I, Subject<unknown>> {
     private readonly own;
     private readonly now;
     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. */
+    /** What a record put back now is stamped with, filled by the next seek. */
+    private stamp;
+    /** What a record never stamped reads as: the first seek's. */
+    private readonly first;
+    /**
+     * 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.
+     */
     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.
+     * 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.
+     */
+    private roots;
+    private kept;
+    /**
+     * 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.
      */
-    private readonly least;
-    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
-    private futures;
+    private ready;
+    private aging;
     /** The latest seek's moment. */
-    private t;
+    top: number;
     /**
      * `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: 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);
+    constructor(own: Store<I, Subject<unknown>>, now: (key: I, held: Subject<unknown> | undefined, at: Moment) => Subject<unknown> | undefined, make: (live: Subject<unknown>, at: Moment, mine: boolean) => 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, and the frame it ended. */
-    private since;
+    /** The next seek's stamp, from a batch made a batch of seeks ago, twice as many each time to 64. */
+    private fresh;
+    /**
+     * 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.
+     */
+    private sure;
     get(key: I): Subject<unknown> | undefined;
+    /** A chain's record for a subject, found again without a lookup where this store stamped it. */
+    find(key: I, guess: Subject<unknown>): Subject<unknown> | undefined;
+    /** `get`, given what `own` holds for `key`. */
+    private from;
     set(key: I, value: Subject<unknown>): void;
     delete(key: I): void;
+    /** Lets go of the record held for `key`, stamping it `gone`. */
+    private shed;
     clear(): void;
 }