@msb235/blits 0.10.0 → 0.12.0

package/dist/fold.js

@@ -1,12 +1,14 @@
-import { passAt, phaseAt, phaseBefore, silent } from './clock.js';
+import { foldNumber } from './channels.js';
+import { passAt, phaseAt, phaseBefore, silent, stepOf } from './clock.js';
 import { copy as copyValue, first } from './clone.js';
 import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
-import { recordHost, remember } from './history.js';
+import { apart, copyState, recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
 import { locusScratch } from './locus.js';
 import { moved } from './moved.js';
 import { readKeys } from './patch.js';
 import { reading } from './reading.js';
+import { checkWrites } from './voice.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
 const copy = copyValue;
 const open = openRecord;
@@ -74,12 +76,18 @@ export function contribution(voice, subject, now, held) {
     if (early && !voice.holdsFirst)
         return null;
     const elapsed = voice.shownAt(raw);
+    if (Number.isNaN(elapsed))
+        return null;
     // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
     const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
     const phase = elapsed < 0 ? phaseBefore(elapsed, duration) : phaseAt(elapsed, duration, voice.passes);
     const pass = passAt(elapsed, duration, voice.passes);
-    this.prime(voice, held, now, elapsed, pass);
+    const primed = this.primed;
+    primed[0 /* Primed.NOW */] = now;
+    primed[1 /* Primed.ELAPSED */] = elapsed;
+    primed[2 /* Primed.PASS */] = pass;
+    this.prime(voice, held);
     const setting = voice.setting;
     // A signal that keeps state makes its voice stateful, as a patch that does: a lane would call
     // it for subjects no probe asked about.
@@ -99,8 +107,9 @@ export function contribution(voice, subject, now, held) {
     const history = this.opts.history;
     if (history?.inputs && voice.patch.reads !== undefined && !this.projecting)
         recordHost(this, now);
-    reading.horizon = this.horizonFor(voice, held.delay, now);
-    const tick = this.opts.stepMs;
+    // Only a motion reads it.
+    if (voice.motion !== undefined)
+        reading.horizon = this.horizonFor(voice, held.delay, now);
     if (voice.patch.step && held.probed !== now) {
         // Frozen after, it steps once more to where its last pass ended, and no further; run back
         // past its start, to where it reached it. Before a start it has yet to reach, it does not step.
@@ -109,12 +118,20 @@ export function contribution(voice, subject, now, held) {
             : still === 1
                 ? voice.timeAt(held.delay + voice.span)
                 : voice.ranBackTo(held.delay, now);
+        // Never probed, it may be a record a seek put back, sharing its copy's state until it steps.
+        const snaps = held.snaps;
+        const sought = Number.isNaN(held.probed) && snaps !== undefined;
         if (!Number.isNaN(to)) {
             if (held.stepped < held.since) {
                 held.stepped = held.since;
                 setting.dt = this.capped(now - held.since);
             }
-            if (tick !== undefined && tick > 0 && !this.reducedNow)
+            const tick = stepOf(this, voice);
+            if (tick !== undefined && sought)
+                ahead(this, voice, subject, held, snaps, tick, to);
+            if (sought)
+                own(voice, held);
+            if (tick !== undefined)
                 this.tick(voice, subject, held, tick, to);
             else if (still === 0 ? now !== held.stepped : to > held.stepped) {
                 if (still !== 0)
@@ -123,6 +140,8 @@ export function contribution(voice, subject, now, held) {
                 held.stepped = to;
             }
         }
+        else if (sought)
+            own(voice, held);
     }
     let delta = null;
     // A keys voice in a locus reads at weight 0 too: having a delta makes it a member, and the
@@ -143,6 +162,8 @@ export function contribution(voice, subject, now, held) {
     }
     else {
         delta = voice.patch.at(phase, subject, setting);
+        if (voice.unchecked)
+            checkWrites(voice, delta);
     }
     held.delta = delta;
     held.probed = now;
@@ -178,6 +199,69 @@ export function keyed(voice, subject, held) {
         voice.holder = held;
     return delta;
 }
+/** How many whole intervals of `tick` a subject's step grid holds by mix time `to`. */
+function dueBy(held, tick, to) {
+    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
+    return Math.floor((to - held.since) / tick + 1e-9);
+}
+/**
+ * The first step of a record a seek put back from a copy: takes up the furthest state stepped on
+ * from that copy that the steps due now run past, the one the record the seek replaced reached or
+ * the one the copy was last stepped ahead to, and otherwise keeps the copy's stepped ahead to the
+ * moment sought, so a mix sought back time after time does not step from the copy each time, nor a
+ * mix sought back and returned step again to where it was. Only where the same steps give the same
+ * state: a fixed interval, no `maxDt`, no host field read.
+ */
+function ahead(mix, voice, subject, held, snaps, tick, to) {
+    const from = snaps[snaps.length - 1];
+    const got = from?.ahead;
+    if (from === undefined || got === undefined || got.put !== held)
+        return;
+    got.put = null;
+    const reads = voice.patch.reads;
+    if (mix.opts.maxDt !== undefined || (reads !== undefined && reads.length > 0))
+        return;
+    // Stepped, rebuilt or placed anew since it was put back, its steps are no longer the copy's.
+    const was = from.held;
+    if (held.ticks !== was.ticks || held.since !== got.since || held.rebuilt !== was.rebuilt)
+        return;
+    const at = got.sought;
+    const due = dueBy(held, tick, to);
+    const usable = got.state !== undefined && got.ticks <= due;
+    if (got.left !== undefined && got.leftTicks <= due && !(usable && got.ticks > got.leftTicks)) {
+        // Taken, not copied: the next seek back keeps the state this record steps on to in its place.
+        held.state = got.left;
+        got.left = undefined;
+        voice.setting.state = held.state;
+        held.ticks = got.leftTicks;
+        return;
+    }
+    if (usable) {
+        held.state = copyState(voice, got.state);
+        voice.setting.state = held.state;
+        held.ticks = got.ticks;
+    }
+    const last = usable ? got.at : from.at;
+    if (!(at < to) || at - last < apart(mix.opts.history))
+        return;
+    own(voice, held);
+    mix.tick(voice, subject, held, tick, at);
+    got.state = copyState(voice, held.state);
+    got.ticks = held.ticks;
+    got.at = at;
+}
+/**
+ * A record a seek put back shares the state of the copy it was made from, which no read changes,
+ * until its first probe: before it steps, it takes a copy of its own.
+ */
+function own(voice, held) {
+    const snaps = held.snaps;
+    const from = snaps[snaps.length - 1];
+    if (from !== undefined && held.state !== undefined && held.state === from.held.state) {
+        held.state = copyState(voice, held.state);
+        voice.setting.state = held.state;
+    }
+}
 /**
  * Runs `step` once per whole interval between where this subject last stopped and now, on a grid
  * counted from when its delay ran out, and leaves the remainder for the next sample. Counting
@@ -188,8 +272,7 @@ export function tick(voice, subject, held, tick, to) {
     const setting = voice.setting;
     const frameDt = setting.dt;
     let n = held.ticks;
-    // The epsilon keeps an interval like 1000 / 120 from landing a hair short of a whole count.
-    const due = Math.floor((to - held.since) / tick + 1e-9);
+    const due = dueBy(held, tick, to);
     const cap = this.opts.maxDt;
     if (cap !== undefined) {
         const most = Math.floor(cap / tick);
@@ -291,6 +374,12 @@ export function apply(pose, voice, held, delta, weight) {
         const value = delta[key];
         if (value === undefined)
             continue;
+        const op = this.scalars[slot];
+        if (op !== undefined && typeof value === 'number') {
+            // Called through the channel, `scale` boxes the double it hands `merge`.
+            pose[key] = foldNumber(op, pose[key], value, weight);
+            continue;
+        }
         const channel = this.channels[slot];
         if (channel.rest !== undefined && channel.scale) {
             // pose[key] is the copy of rest this fold made, so it is ours to write into.
@@ -374,8 +463,22 @@ export function folded(subject, out, dry = false, except) {
  */
 export function linked(subject) {
     const head = Number.isNaN(this.now) ? null : this.chain(subject);
+    const lanes = this.lanes;
+    // What `prepare` answers once this frame's qualify left nothing laned, without calling it.
+    if (head !== null &&
+        lanes !== null &&
+        lanes.laned.length === 0 &&
+        lanes.frameAt === this.now &&
+        lanes.qualifiedVersion === this.version &&
+        lanes.touched.length === 0 &&
+        !lanes.filling) {
+        if (head.slot >= 0)
+            lanes.per[head.slot * 6 /* Per.SLOT */ + 4 /* Per.GENERAL_PROBE */] = ++lanes.probes;
+        this.linkedLaned = false;
+        return head;
+    }
     this.linkedLaned =
-        head !== null && this.lanes?.prepare(head.slot, subject, this.version, head) === true;
+        head !== null && lanes?.prepare(head.slot, subject, this.version, head) === true;
     return head;
 }
 /** The fold after a subject's chain is linked and its lanes asked whether it reads from them. */

package/dist/frames.d.ts

@@ -15,6 +15,8 @@ export declare class Frames {
      * since rate 0 can hold the clock at `t` for many.
      */
     at(t: number): Frame | undefined;
+    /** The frame numbered `seq`, if it is still held. */
+    numbered(seq: number): Frame | undefined;
     /** Every frame held, oldest first. */
     all(): Frame[];
     set(frames: Frame[]): void;

package/dist/frames.js

@@ -48,6 +48,23 @@ export class Frames {
         }
         return found;
     }
+    /** The frame numbered `seq`, if it is still held. */
+    numbered(seq) {
+        const list = this.list;
+        let lo = this.head;
+        let hi = list.length - 1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            const f = list[mid];
+            if (f.seq === seq)
+                return f;
+            if (f.seq < seq)
+                lo = mid + 1;
+            else
+                hi = mid - 1;
+        }
+        return undefined;
+    }
     /** Every frame held, oldest first. */
     all() {
         return this.list.slice(this.head);

package/dist/gather.js

@@ -154,18 +154,49 @@ export function fold(lane, slot) {
  */
 export function foldDelta(chans, slot, delta) {
     const n = chans.length;
+    const arg = this.arg;
+    // A plain number is folded where it is read: passed to a `foldInto` V8 did not inline, it is
+    // boxed, 16 bytes a channel a subject, and whether V8 inlines it turns on the order its compiles
+    // ran (bench/allocs.mjs, 2026-10-20).
     let ch = chans[0];
-    if (n > 0)
-        this.foldInto(ch, slot, delta[ch.name]);
+    if (n > 0) {
+        const v = delta[ch.name];
+        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
+            const values = ch.values;
+            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        }
+        else
+            this.foldInto(ch, slot, v);
+    }
     ch = chans[1];
-    if (n > 1)
-        this.foldInto(ch, slot, delta[ch.name]);
+    if (n > 1) {
+        const v = delta[ch.name];
+        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
+            const values = ch.values;
+            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        }
+        else
+            this.foldInto(ch, slot, v);
+    }
     ch = chans[2];
-    if (n > 2)
-        this.foldInto(ch, slot, delta[ch.name]);
+    if (n > 2) {
+        const v = delta[ch.name];
+        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
+            const values = ch.values;
+            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        }
+        else
+            this.foldInto(ch, slot, v);
+    }
     for (let i = 3; i < n; i++) {
         ch = chans[i];
-        this.foldInto(ch, slot, delta[ch.name]);
+        const v = delta[ch.name];
+        if (typeof v === 'number' && ch.scalar && ch.plain && this.into === null) {
+            const values = ch.values;
+            values[slot] = foldNumber(ch.op, values[slot], v, arg[0 /* Arg.WEIGHT */]);
+        }
+        else
+            this.foldInto(ch, slot, v);
     }
 }
 /** Folds a motion sample's axes, kept apart from `foldInto` so neither reads two array kinds. */

package/dist/handle.d.ts

@@ -16,9 +16,13 @@ export interface HandleHost<I, O> {
     rise(voice: Voice<I, O>, opts: {
         over?: number;
     } | undefined): void;
+    release(voice: Voice<I, O>): void;
     weightOf(voice: Voice<I, O>, subject: I): number;
-    /** Records a write the host made, which `again` makes once more where a seek replays it. */
-    record(label: string, again: () => void): void;
+    /**
+     * Records a write the host made through `h`, which `again` makes once more where a seek replays
+     * it, on the handle it is given: `h`, or a read ahead's handle on its copy of the voice.
+     */
+    record(h: VoiceHandle<I, O>, label: string, again: (h: VoiceHandle<I, O>) => void): void;
 }
 /** Refuses a voice rate no clock can run at. */
 export declare function finiteRate(rate: number): void;
@@ -60,6 +64,7 @@ export declare class VoiceHandle<I, O> implements Handle<I> {
     rise(opts?: {
         over?: number;
     }): void;
+    release(): void;
     weightOf(subject: I): number;
     to(subject: I, target: Value, at?: number): void;
     push(subject: I, velocity: Value, at?: number): void;

package/dist/handle.js

@@ -59,17 +59,25 @@ export class VoiceHandle {
     get weight() {
         return this.#voice?.weight ?? this.#gone?.weight ?? 0;
     }
-    // A write to a paged voice changes nothing: it had left when the host made it, as it has on replay.
+    /**
+     * The voice a write reaches: none while a history store holds it, or a seek back to before its
+     * cue has it waiting. It had left, or was yet to be cued, when the host made the write, as on
+     * replay, so the write changes nothing and the tape does not take it.
+     */
+    get #cued() {
+        const voice = this.#voice;
+        return voice === null || voice.parked ? null : voice;
+    }
     set weight(w) {
         plainWeight(w);
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         voice.weight = w;
         this.#host.changed(voice);
-        this.#host.record('weight', () => {
-            this.weight = w;
+        this.#host.record(this, 'weight', (h) => {
+            h.weight = w;
         });
     }
     get rate() {
@@ -81,7 +89,7 @@ export class VoiceHandle {
     }
     ramp(r, over) {
         finiteRate(r);
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
@@ -97,10 +105,10 @@ export class VoiceHandle {
             retime(voice, now, r, over);
         }
         this.#host.changed(voice);
-        this.#host.record('rate', () => this.ramp(r, over));
+        this.#host.record(this, 'rate', (h) => h.ramp(r, over));
     }
     seek(elapsed, opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return 'exact';
         voice.written = true;
@@ -114,24 +122,32 @@ export class VoiceHandle {
         voice.seeks++;
         const doubt = this.#host.sought(voice, opts?.state !== 'keep');
         this.#host.changed(voice);
-        this.#host.record('seek', () => this.seek(elapsed, opts));
+        this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));
         return doubt;
     }
     fade(opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         this.#host.fade(voice, opts);
-        this.#host.record('fade', () => this.fade(opts));
+        this.#host.record(this, 'fade', (h) => h.fade(opts));
     }
     rise(opts) {
-        const voice = this.#voice;
+        const voice = this.#cued;
         if (voice === null)
             return;
         voice.written = true;
         this.#host.rise(voice, opts);
-        this.#host.record('rise', () => this.rise(opts));
+        this.#host.record(this, 'rise', (h) => h.rise(opts));
+    }
+    release() {
+        const voice = this.#cued;
+        if (voice === null)
+            return;
+        voice.written = true;
+        this.#host.release(voice);
+        this.#host.record(this, 'release', (h) => h.release());
     }
     weightOf(subject) {
         const voice = this.#voice;

package/dist/held.d.ts

@@ -2,8 +2,17 @@ import type { Mixer } from './mixer.js';
 import type { Subject, Voice } from './voice.js';
 /** The record a voice gives every subject it does not reach. */
 export declare function unreachedOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): Subject<unknown>;
-/** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number): Subject<unknown>;
+/**
+ * What this voice holds for this subject, made on first sight with `target` and `stagger` asked
+ * once; `guess` is a record it may be, from the subject's chain as last linked.
+ */
+export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number, guess?: Subject<unknown> | null): Subject<unknown>;
+/**
+ * Where a new record met at `now` starts stepping: from its `since`, or from `now` for a voice that
+ * catches up `fresh`, on the `stepMs` grid. True where that skipped steps, so the state depends on
+ * when the subject was first probed.
+ */
+export declare function meet<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>, now: number): boolean;
 /**
  * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
  * counts from its last seek that rebuilt state, as its records do.
@@ -20,6 +29,8 @@ export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, sin
  * while it waited is made again for where its clock is.
  */
 export declare function begin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
+/** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
+export declare function origin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>): void;
 /**
  * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
  * ahead count from where its clock now puts them.

package/dist/held.js

@@ -1,4 +1,5 @@
 import { changed } from './chain.js';
+import { stepOf } from './clock.js';
 import { schedule } from './due.js';
 import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
@@ -16,8 +17,11 @@ export function unreachedOf(voice, now) {
     voice.unreached = none;
     return none;
 }
-/** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
-export function held(voice, subject, slot) {
+/**
+ * What this voice holds for this subject, made on first sight with `target` and `stagger` asked
+ * once; `guess` is a record it may be, from the subject's chain as last linked.
+ */
+export function held(voice, subject, slot, guess = null) {
     if (voice.sharing) {
         const all = everyoneOf(this, voice);
         if (all !== null)
@@ -25,7 +29,7 @@ export function held(voice, subject, slot) {
     }
     if (unreached(voice, slot))
         return voice.unreached;
-    let held = voice.subjects.get(subject);
+    let held = (guess === null ? voice.subjects.get(subject) : voice.subjects.find(subject, guess));
     if (held !== undefined)
         return held;
     const now = this.now;
@@ -53,11 +57,11 @@ export function held(voice, subject, slot) {
     held.delay = delay;
     held.since = since;
     held.shown = shown;
-    held.stepped = since < now ? since : now;
+    const fresh = meet(this, voice, held, now);
     held.rebuilt = voice.rebuilds;
     if (this.projecting) {
         held.from = held.stepped;
-        held.unknown = this.backward && voice.spec.from === 'current';
+        held.unknown = (this.backward && voice.spec.from === 'current') || fresh;
     }
     voice.subjects.set(subject, held);
     if (!(since <= now)) {
@@ -91,6 +95,30 @@ export function held(voice, subject, slot) {
     }
     return held;
 }
+/**
+ * Where a new record met at `now` starts stepping: from its `since`, or from `now` for a voice that
+ * catches up `fresh`, on the `stepMs` grid. True where that skipped steps, so the state depends on
+ * when the subject was first probed.
+ */
+export function meet(mix, voice, held, now) {
+    const since = held.since;
+    if (!(since < now)) {
+        held.stepped = now;
+        return false;
+    }
+    if (voice.spec.catchUp !== 'fresh' || voice.patch.step === undefined) {
+        held.stepped = since;
+        return false;
+    }
+    const tick = stepOf(mix, voice);
+    if (tick === undefined)
+        held.stepped = now;
+    else {
+        held.ticks = Math.floor((now - since) / tick + 1e-9);
+        held.stepped = since + held.ticks * tick;
+    }
+    return held.stepped > since;
+}
 /**
  * The mix time the voice clock first read `delay`, or will by its controls now. A stateful voice
  * counts from its last seek that rebuilt state, as its records do.
@@ -118,10 +146,19 @@ export function begin(mix, voice, now) {
     if (voice.anchorElapsed !== 0) {
         voice.seeks++;
         voice.rebuilds++;
+        // Kept with its controls, so a seek back to after this puts back the count its records hold.
+        voice.note(now, mix.transport.seq, true);
     }
     reorigin(mix, voice, now);
     changed(mix, voice);
 }
+/** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
+export function origin(mix, voice, held) {
+    held.since = mix.sinceOf(voice, held.delay);
+    held.shown = mix.shownOf(voice, held.since);
+    if (held.ticks === 0 && held.stepped > held.since)
+        held.stepped = held.since;
+}
 /**
  * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
  * ahead count from where its clock now puts them.
@@ -132,10 +169,7 @@ export function reorigin(mix, voice, now) {
         return;
     let kept = 0;
     for (const held of early) {
-        held.since = mix.sinceOf(voice, held.delay);
-        held.shown = mix.shownOf(voice, held.since);
-        if (held.ticks === 0 && held.stepped > held.since)
-            held.stepped = held.since;
+        origin(mix, voice, held);
         if (!(held.since <= now))
             early[kept++] = held;
     }

package/dist/history.d.ts

@@ -5,6 +5,10 @@ import { type Subject, type Voice } from './voice.js';
 export declare function last<T extends {
     at: number;
 }>(list: readonly T[], t: number, inclusive: boolean | ((e: T) => boolean)): T | undefined;
+/** Where `last` finds its entry in the list, -1 where it finds none. */
+export declare function lastIndex<T extends {
+    at: number;
+}>(list: readonly T[], t: number, inclusive: boolean | ((e: T) => boolean)): number;
 /**
  * The last entry of a list kept in the order it was made that falls inside `cut`, an entry made
  * before its frame was read counting as `early`.
@@ -19,12 +23,31 @@ export declare function same(a: unknown, b: unknown): boolean;
 export declare function elapsedThen<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, t: number): number;
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
 export declare function noted<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
-/** A copy of a subject's record that shares nothing a read could change. */
-export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>): Subject<unknown>;
+/** A copy of the state a voice's patch keeps for a subject. */
+export declare function copyState<I, O>(voice: Voice<I, O>, state: unknown): unknown;
+/**
+ * A copy of a subject's record that shares nothing a read could change; with `shared`, its state is
+ * the record's own, for a copy that takes one of its own before it steps.
+ */
+export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>, shared?: boolean): Subject<unknown>;
+/**
+ * As `copyHeld`, written over `into`, a record nothing else holds, so a copy made in its place
+ * leaves nothing new to collect. test/history.test.ts holds this to `copyHeld` field by field.
+ */
+export declare function copyHeldInto<I, O>(voice: Voice<I, O>, h: Subject<unknown>, into: Subject<unknown>, shared?: boolean): Subject<unknown>;
+/**
+ * Lets go of what a record holds from its last probe and its place in a chain, as a copy of it
+ * starts: a seek puts back a record nothing else holds this way, in place of a copy.
+ */
+export declare function unread(h: Subject<unknown>): Subject<unknown>;
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
 export declare function recordHost<I, O>(mix: Mixer<I, O>, now: number): void;
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
 export declare function record<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, value: number): void;
+/** How far apart, in mix ms, a record's copies are kept. */
+export declare function apart(history: {
+    readonly every?: number;
+}): number;
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
 export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
 /**