@msb235/blits 0.10.0 → 0.12.0

package/dist/project.js

@@ -1,37 +1,52 @@
 import { ownBlends } from './blend.js';
+import { headOf, heldAt } from './chain.js';
+import { stepOf } from './clock.js';
 import { open, sighted, weightAt } from './everyone.js';
+import { fadesAt } from './fade.js';
+import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
+import { markOf, voiceMarks } from './marks.js';
 import { Mixer } from './mixer.js';
 import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
-import { pin } from './place.js';
+import { pin, place } from './place.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
 import { copyStanding, stands } from './standing.js';
-import { hostAt } from './tape.js';
+import { hostAhead, hostAt, replay } from './tape.js';
 import { Transport, within } from './transport.js';
-import { cover } from './unpage.js';
+import { cover, coverFrame } from './unpage.js';
 import { unreached } from './unreached.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
- * own, moved together so an anchor across mixes answers as it would live.
+ * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
+ * known event on the way, and a subject asked about is read at each before `t`.
  */
-export function projectAll(transport, t) {
-    const ahead = Number.isNaN(transport.now) || t >= transport.now;
-    const tape = transport.tape;
-    const stamp = ahead && tape !== undefined ? tape.timestampAt(tape.undoDepth()) : undefined;
+export function projectAll(transport, at) {
+    const kept = transport.history !== undefined;
+    let t;
+    let numbered;
+    if (typeof at === 'number')
+        t = at;
+    else {
+        if (!kept)
+            throw new Error('blits: reading a frame back needs a mix made with history');
+        numbered = coverFrame(transport, at.frame);
+        t = numbered.at;
+    }
+    // The frame being played reads as the mix's own time does; any other is behind, whatever its time.
+    const ahead = numbered !== undefined
+        ? numbered.seq === transport.seq
+        : Number.isNaN(transport.now) || t >= transport.now;
     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`);
     // 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;
+    let u = ahead ? hostAhead(transport, t) : hostAt(transport, t);
     if (!ahead && kept) {
-        cover(transport, t);
-        const frame = transport.frames.at(t);
+        if (numbered === undefined)
+            cover(transport, t);
+        const frame = numbered ?? transport.frames.at(t);
         if (frame !== undefined) {
             cut = { seq: frame.seq, strict: frame.at === t };
             if (frame.at === t)
@@ -57,7 +72,7 @@ export function projectAll(transport, t) {
             history: undefined,
             lanes: false,
             transport: c,
-        });
+        }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
         copies.set(mix, copy);
@@ -70,28 +85,50 @@ export function projectAll(transport, t) {
     }
     // A read at the mix's own time lands nothing, as a probe does not: what the host has done since
     // the last sync shows at the next one.
-    if (ahead && t !== transport.now)
-        for (const copy of copies.values())
-            move(copy, t);
+    let stood = c;
+    let earlier = null;
+    if (ahead && t !== transport.now) {
+        earlier = new Map();
+        stood = playAhead(transport, c, copies, t, earlier);
+    }
     const read = (f) => {
         reading.live = false;
+        reading.ahead = stood.ahead.size > 0 ? stood.ahead : null;
         try {
             return f();
         }
         finally {
             reading.live = true;
+            reading.ahead = null;
         }
     };
     return {
         timestamp: t,
         of(mix) {
-            const copy = copies.get(mix);
+            const key = mix;
+            const copy = copies.get(key);
             if (copy === undefined)
                 throw new Error('blits: that mix is not on this transport');
+            const stages = earlier?.get(key);
+            // A subject asked about is read at every stop first, in order, so the state it carries
+            // crosses each event as a frame there would carry it.
+            const warm = stages === undefined
+                ? null
+                : (subject) => {
+                    if (stages.met.has(subject))
+                        return;
+                    stages.met.add(subject);
+                    for (const stage of stages.at)
+                        stage.fold(subject);
+                };
             return {
                 timestamp: t,
-                probe: (subject, out) => read(() => copy.fold(subject, out)),
+                probe: (subject, out) => read(() => {
+                    warm?.(subject);
+                    return copy.fold(subject, out);
+                }),
                 assess: (subject) => read(() => {
+                    warm?.(subject);
                     copy.fold(subject);
                     return doubts(copy, subject);
                 }),
@@ -99,7 +136,150 @@ 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. */
+/**
+ * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
+ * there makes them on the mixes. While a voice could carry state across it, it stops at each known
+ * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
+ * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
+ * transport they stand on, and puts the tape back where it stood.
+ */
+function playAhead(transport, c, copies, t, earlier) {
+    const tape = transport.tape;
+    const depth = tape?.undoDepth() ?? 0;
+    let played = false;
+    try {
+        for (;;) {
+            const e = nextEvent(tape, c, t);
+            if (!(e < t))
+                break;
+            played = playTo(transport, c, copies, e) || played;
+            if (!carries(c))
+                continue;
+            // Placed now, as the next move would place them, while a target that has just left is here.
+            for (const m of c.members)
+                if (m.anchored > 0)
+                    place(m);
+            const next = restage(c);
+            for (const [mix, copy] of copies) {
+                const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
+                on.slot = copy.slot;
+                on.projecting = true;
+                copyAhead(copy, on);
+                const stages = earlier.get(mix);
+                if (stages === undefined)
+                    earlier.set(mix, { at: [copy], met: new Set() });
+                else
+                    stages.at.push(copy);
+                copies.set(mix, on);
+            }
+            c = next;
+        }
+        played = playTo(transport, c, copies, t) || played;
+    }
+    finally {
+        if (played)
+            tape?.goto(depth);
+    }
+    return c;
+}
+/**
+ * Whether a voice on a read ahead's copies could carry state from one known event to the next: a
+ * patch that steps, or a weight given by a signal, which may keep state. Where none could, a read
+ * crosses the events in one go, as fast as one with none.
+ */
+function carries(c) {
+    for (const m of c.members)
+        for (const v of m.cued)
+            if (v.state !== 'done' && (v.patch.step !== undefined || typeof v.spec.weight === 'function'))
+                return true;
+    return false;
+}
+/**
+ * The earliest known event a read ahead's copies have yet to reach before `t`, mix time: the next
+ * call the tape holds, and while a voice could carry state across one, a mark of a voice or one
+ * announced. Infinity where there is none.
+ */
+function nextEvent(tape, c, t) {
+    const now = c.now;
+    let e = Number.POSITIVE_INFINITY;
+    const call = tape?.timestampAt(tape.undoDepth());
+    if (call !== undefined)
+        e = c.pace === null ? call : c.pace.reading(call);
+    if (!carries(c))
+        return e < t ? e : Number.POSITIVE_INFINITY;
+    for (const m of c.members)
+        for (const v of m.cued) {
+            if (v.state === 'done')
+                continue;
+            for (const mark of voiceMarks) {
+                const at = markOf(m, v, mark);
+                if (at !== undefined && at > now && at < e)
+                    e = at;
+            }
+            const inner = v.spec.marks;
+            if (inner !== undefined)
+                for (const mark of Object.keys(inner)) {
+                    const at = markOf(m, v, mark);
+                    if (at !== undefined && at > now && at < e)
+                        e = at;
+                }
+        }
+    for (const a of c.announced) {
+        const at = c.pace === null ? a.at : c.pace.at(a.at, c.u);
+        if (at > now && at < e)
+            e = at;
+    }
+    return e < t ? e : Number.POSITIVE_INFINITY;
+}
+/**
+ * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
+ * there. Answers whether it moved the tape.
+ */
+function playTo(transport, c, copies, to) {
+    const tape = transport.tape;
+    const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
+    const next = tape?.timestampAt(tape.undoDepth());
+    c.u = hostAhead(c, to);
+    let played = false;
+    if (next !== undefined && due(next)) {
+        // A call may write what a copy shares with the voice it was copied from.
+        for (const copy of c.members)
+            for (const v of copy.cued) {
+                if (v.parts !== null)
+                    v.parts = new Map(v.parts);
+                if (v.parted !== null)
+                    v.parted = new Map(v.parted);
+            }
+        played = true;
+        const last = replay(transport, due, c, {
+            transport: () => c,
+            mix: (of) => copies.get(of),
+        });
+        c.u = Math.max(last, hostAhead(c, to));
+    }
+    // A call played at `to` itself moved the copies there before it, as a sync does.
+    if (!(c.now >= to))
+        for (const copy of c.members)
+            move(copy, to);
+    return played;
+}
+/** A transport for a read ahead's copies to go on from where those on `c` stand. */
+function restage(c) {
+    const next = new Transport(undefined, true);
+    next.offset = c.offset;
+    next.u = c.u;
+    next.nextId = c.nextId;
+    next.now = c.now;
+    next.pace = c.pace === null ? null : c.pace.until(Number.POSITIVE_INFINITY);
+    next.announced = c.announced.map((a) => ({ ...a }));
+    // The retargets and pushes the tape made carry their times, so every stop shares one list.
+    next.ahead = c.ahead;
+    return next;
+}
+/**
+ * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
+ * or from the copy at the known event before.
+ */
 function copyAhead(mix, c) {
     mirror(mix, c);
     c.cued = mix.cued
@@ -112,7 +292,8 @@ function copyAhead(mix, c) {
         return copy;
     });
     ownBlends(c.cued);
-    if (mix.owners !== null)
+    // A copy keeps no list of owners, so the one before says only by its voices.
+    if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))
         relink(c.cued);
     recount(c);
 }
@@ -136,11 +317,26 @@ function copyBack(mix, c, t, cut) {
         const copy = v.copy((subject) => recall(mix, v, subject, t, cut, c, copy), lastWithin(log, cut) ?? log[0]);
         if (then !== undefined)
             copy.setting.host = then;
+        // Its own, which a fade the copy plays out writes to.
+        if (v.parts !== null)
+            copy.parts = new Map(v.parts);
+        if (v.parted !== null)
+            copy.parted = new Map(v.parted);
+        if (v.left !== null)
+            fadesAt(copy, v.left.after(cut), cut.seq);
+        if (copy.parted !== null)
+            for (const [subject, p] of copy.parted) {
+                // A ramp that has ended since was still running at `t`.
+                if (p.ramp === undefined || !(t < p.at))
+                    continue;
+                copy.parts ??= new Map();
+                copy.parts.set(subject, p.ramp);
+            }
         return copy;
     });
     ownBlends(c.cued);
     if (mix.owners !== null)
-        relink(c.cued);
+        relink(c.cued, cut.seq);
     stateAt(c, t);
     recount(c);
 }
@@ -166,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;
@@ -177,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;
 }
@@ -202,12 +398,16 @@ function carry(mix, voice, subject, c, copy) {
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
 export function recall(mix, voice, subject, t, cut, c, copy) {
-    const live = voice.left?.at(subject, cut) ?? recordOf(mix, voice, subject);
+    const live = voice.left?.at(subject, cut) ??
+        heldAt(voice, subject, recordOf(mix, voice, subject), t, cut.seq);
     if (live === undefined)
         return undefined;
     const snap = live.snaps && last(live.snaps, t, true);
     if (snap) {
         const h = copyHeld(voice, snap.held);
+        // A start still ahead when the copy was kept may have moved before `t`, with no copy between.
+        if (c !== undefined && copy !== undefined && !(h.since <= snap.at))
+            origin(c, copy, h);
         h.from = h.stepped;
         h.replay = live.inputs;
         return h;
@@ -215,17 +415,16 @@ export function recall(mix, voice, subject, t, cut, c, copy) {
     // Its origin by the controls the voice had then: a seek or an anchor has moved a waiting
     // voice's since.
     const since = c === undefined || copy === undefined ? live.since : c.sinceOf(copy, live.delay);
-    const stepped = since < t ? since : t;
     const h = record(voice, live.reaches, live.reaches && voice.patch.state
         ? voice.patch.state(subject)
         : undefined);
     h.delay = live.delay;
     h.since = since;
     h.shown = c === undefined || copy === undefined ? live.shown : c.shownOf(copy, since);
-    h.stepped = stepped;
+    const fresh = meet(mix, voice, h, t);
     h.rebuilt = voice.rebuilds;
-    h.from = stepped;
-    h.unknown = voice.spec.from === 'current';
+    h.from = h.stepped;
+    h.unknown = voice.spec.from === 'current' || fresh;
     h.replay = live.inputs;
     return h;
 }
@@ -286,10 +485,15 @@ function doubtOf(mix, voice, held) {
             return 'held';
     }
     if (mix.now > (held.from ?? mix.now)) {
-        const tick = mix.opts.stepMs;
-        const fixed = tick !== undefined && tick > 0 && !mix.reducedNow;
-        if ((voice.patch.step && !fixed) || (held.kept !== null && held.kept.size > 0 && !replayed))
+        const fixed = stepOf(mix, voice) !== undefined;
+        // A read ahead reads a signal's state at every known event, and one step across a stretch
+        // with none in it is as good as any number; a read back steps it from a copy in one go.
+        const kept = held.kept !== null && held.kept.size > 0 && !replayed && mix.backward;
+        if ((voice.patch.step && !fixed) || kept)
             return 'stepped';
     }
+    // A seek stepped it from a copy, and what it keeps now goes on from there.
+    if (held.copied && held.kept !== null && held.kept.size > 0 && !replayed)
+        return 'stepped';
     return 'exact';
 }

package/dist/pull.js

@@ -1,6 +1,8 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
 import { clampRun, flush, pullRun, writeLater } from './columns.js';
+/** What `pull` remembers at a position it has read no subject at. */
+const UNREAD = Symbol('unread');
 /** Writes a folded pose's value into subject `n`'s places in a column. */
 function writeValue(c, v, n) {
     const at = n * c.axes;
@@ -76,19 +78,33 @@ export function pull(mix, subjects, into) {
     // all of them at once while nothing has relinked since the last pull, else one by one.
     const was = mix.pulled;
     const heads = mix.pulledHeads;
-    was.length = list.length;
-    heads.length = list.length;
     if (mix.pulledSlots.length < list.length) {
-        const slots = new Int32Array(Math.max(64, list.length));
+        const slots = new Int32Array(Math.max(64, list.length)).fill(-1);
         slots.set(mix.pulledSlots);
         mix.pulledSlots = slots;
     }
+    // A position the list no longer has, or has anew, holds no head: its slot says so.
+    if (list.length < was.length)
+        mix.pulledSlots.fill(-1, list.length, was.length);
+    // A new position holds a mark no subject equals: a hole would read as `undefined`, a subject.
+    for (let n = was.length; n < list.length; n++)
+        was.push(UNREAD);
+    was.length = list.length;
+    heads.length = list.length;
     const version = mix.version;
     const relinks = mix.relinks;
     const live = !Number.isNaN(now);
     const current = live && mix.pulledVersion === version && mix.pulledRelinks === relinks;
+    // Which remembered heads `pullRun` takes as current: all while nothing has changed; those
+    // `unlink` has not stamped since `pulledRelinks` while the version they were linked at stands;
+    // none otherwise.
+    const since = current
+        ? Number.POSITIVE_INFINITY
+        : live && mix.pulledVersion === version
+            ? mix.pulledRelinks
+            : -1;
     try {
-        readAll(mix, list, columns, live, current, whole);
+        readAll(mix, list, columns, live, current, since, whole);
     }
     finally {
         if (lanes !== null)
@@ -104,7 +120,7 @@ export function pull(mix, subjects, into) {
  * compile the loop on the stack does not leave `pull`'s own code compiled before its tail had run:
  * under churn that code deoptimized at the tail on every frame.
  */
-function readAll(mix, list, columns, live, current, whole) {
+function readAll(mix, list, columns, live, current, since, whole) {
     const lanes = mix.lanes;
     const now = mix.now;
     const scratch = mix.scratch;
@@ -116,7 +132,7 @@ function readAll(mix, list, columns, live, current, whole) {
     const runs = live && whole;
     for (let n = 0; n < list.length; n++) {
         if (runs) {
-            n = pullRun(lanes, slots, list, was, current ? null : heads, n, columns, now, mix.version);
+            n = pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
             if (n === list.length)
                 break;
         }
@@ -149,13 +165,24 @@ function readAll(mix, list, columns, live, current, whole) {
             writeValue(c, pose[c.key], n);
     }
 }
-/** The kit slot, width, rest and bounds of every channel `pull` was handed an array for. */
+/**
+ * The kit slot, width, rest and bounds of every channel `pull` was handed an array for: one record
+ * a channel for the mix's life, pointed at the array this call was handed.
+ */
 function columnsOf(mix, into) {
     const columns = [];
+    mix.pullColumns ??= new Map();
+    const known = mix.pullColumns;
     for (const key of Object.keys(into)) {
         const out = into[key];
         if (out === undefined)
             continue;
+        const had = known.get(key);
+        if (had !== undefined) {
+            had.out = out;
+            columns.push(had);
+            continue;
+        }
         const slot = mix.slotOf.get(key);
         if (slot === undefined)
             throw new Error(`blits: pull was handed ${key}, which the kit lacks`);
@@ -170,7 +197,9 @@ function columnsOf(mix, into) {
             at.set(rest);
         if (bounds !== undefined)
             clampRun(at, 0, axes, bounds);
-        columns.push({ key, slot, axes, out, rest: at, bounds });
+        const column = { key, slot, axes, out, rest: at, bounds };
+        known.set(key, column);
+        columns.push(column);
     }
     return columns;
 }

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

@@ -1,6 +1,7 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
 import { crowdable } from './crowd.js';
+import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 import { Lane } from './lane.js';
@@ -52,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.
@@ -192,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;
@@ -231,8 +282,13 @@ export function open(lanes, v) {
  * A crowd a quarter empty rows is compacted.
  */
 export function retouch(lanes) {
-    const touched = [...new Set(lanes.touched)].sort((a, b) => a.id - b.id);
-    lanes.touched.length = 0;
+    const touched = byId(lanes.touched);
+    lanes.touched = [];
+    let kept = 0;
+    for (let i = 0; i < touched.length; i++)
+        if (i === 0 || touched[i] !== touched[i - 1])
+            touched[kept++] = touched[i];
+    touched.length = kept;
     // The qualify a false answer calls takes up every touched voice, crowd rows starting included.
     const qualify = () => {
         lanes.touched = touched;
@@ -267,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;
     /**
@@ -25,4 +26,10 @@ export declare const reading: {
      * since it read it. One count for every mix, as `moved` is.
      */
     inputs: number;
+    /**
+     * While a read ahead that played its tape's calls reads: the retargets and pushes those calls
+     * made, by motion patch and then subject, in time order. A patch applies them with its own and
+     * commits none. Null for every other read.
+     */
+    ahead: Map<object, Map<unknown, unknown[]>> | null;
 };

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,
     /**
@@ -25,4 +26,10 @@ export const reading = {
      * since it read it. One count for every mix, as `moved` is.
      */
     inputs: 0,
+    /**
+     * While a read ahead that played its tape's calls reads: the retargets and pushes those calls
+     * made, by motion patch and then subject, in time order. A patch applies them with its own and
+     * commits none. Null for every other read.
+     */
+    ahead: null,
 };

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 {};