@msb235/blits 0.11.0 → 0.12.0

package/dist/departed.js

@@ -1,19 +1,30 @@
 import { markOf, voiceMarks } from './marks.js';
 import { none } from './voice.js';
+/** A departed voice's marks: its five as fields, so it stays in fast mode, on no prototype. */
+class Marks {
+    start = undefined;
+    in = undefined;
+    coast = undefined;
+    out = undefined;
+    end = undefined;
+}
+Object.setPrototypeOf(Marks.prototype, null);
 /**
  * The departed voices a query could still pick: for each name, tag and channel within a score and
  * owner, the first and the last to leave. It grows with those, never with how many voices left.
  */
 export class DepartedIndex {
-    ends = new Map();
+    scopes = new Map();
     all = new Set();
     add(mix, voice) {
         // Nothing can be cued beside a voice whose owner has gone, so nothing will ask for it.
         if (voice.owner?.state === 'done')
             return;
-        const marks = Object.create(null);
-        for (const mark of voiceMarks)
+        const marks = new Marks();
+        for (let i = 0; i < voiceMarks.length; i++) {
+            const mark = voiceMarks[i];
             marks[mark] = markOf(mix, voice, mark);
+        }
         const inner = voice.spec.marks;
         if (inner !== undefined)
             for (const mark of Object.keys(inner))
@@ -28,25 +39,19 @@ export class DepartedIndex {
             marks,
             held: 0,
         };
-        const base = `${d.score ?? ''}\u0000${d.owner}\u0000`;
-        const keys = [`${base}w`];
-        if (d.name !== undefined)
-            keys.push(`${base}n\u0000${d.name}`);
-        for (const tag of d.tags)
-            keys.push(`${base}t\u0000${tag}`);
-        for (const ch of d.writes)
-            keys.push(`${base}c\u0000${String(ch)}`);
-        for (const key of keys) {
-            const end = this.ends.get(key);
-            if (end === undefined) {
-                this.ends.set(key, { first: d, last: d });
-                d.held += 2;
-                continue;
-            }
-            this.release(end.last);
-            end.last = d;
-            d.held++;
+        const scope = this.scopeOf(d.score, d.owner);
+        if (scope.whole === undefined) {
+            scope.whole = { first: d, last: d };
+            d.held += 2;
         }
+        else
+            this.hold(scope.whole, d);
+        if (d.name !== undefined)
+            this.keep(scope.names, d.name, d);
+        for (let i = 0; i < d.tags.length; i++)
+            this.keep(scope.tags, d.tags[i], d);
+        for (let i = 0; i < d.writes.length; i++)
+            this.keep(scope.writes, d.writes[i], d);
         if (d.held > 0)
             this.all.add(d);
         if (voice.holding !== null)
@@ -54,12 +59,51 @@ export class DepartedIndex {
     }
     /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
     dropOwner(owner) {
-        for (const [key, end] of this.ends)
-            if (end.first.owner === owner) {
-                this.ends.delete(key);
-                this.all.delete(end.first);
-                this.all.delete(end.last);
-            }
+        for (const owners of this.scopes.values()) {
+            const scope = owners.get(owner);
+            if (scope === undefined)
+                continue;
+            owners.delete(owner);
+            if (scope.whole !== undefined)
+                this.forget(scope.whole);
+            for (const end of scope.names.values())
+                this.forget(end);
+            for (const end of scope.tags.values())
+                this.forget(end);
+            for (const end of scope.writes.values())
+                this.forget(end);
+        }
+    }
+    scopeOf(score, owner) {
+        let owners = this.scopes.get(score);
+        if (owners === undefined) {
+            owners = new Map();
+            this.scopes.set(score, owners);
+        }
+        let scope = owners.get(owner);
+        if (scope === undefined) {
+            scope = { whole: undefined, names: new Map(), tags: new Map(), writes: new Map() };
+            owners.set(owner, scope);
+        }
+        return scope;
+    }
+    keep(ends, key, d) {
+        const end = ends.get(key);
+        if (end === undefined) {
+            ends.set(key, { first: d, last: d });
+            d.held += 2;
+        }
+        else
+            this.hold(end, d);
+    }
+    hold(end, d) {
+        this.release(end.last);
+        end.last = d;
+        d.held++;
+    }
+    forget(end) {
+        this.all.delete(end.first);
+        this.all.delete(end.last);
     }
     release(d) {
         if (--d.held === 0)

package/dist/easing.d.ts

@@ -1,9 +1,20 @@
 import type { Easing } from './types.js';
+/**
+ * A curve on 0..1: the function an easing stands for.
+ *
+ * @category patch
+ */
 export type Curve = (u: number) => number;
 /**
  * How fast a curve leaves 0, for bending a retarget to the speed the subject had: Infinity where
  * the curve jumps or leaves vertically, so no finite bend can match it.
  */
 export declare function startSlope(c: Curve): number;
-/** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
+/**
+ * The function an easing names: a CSS name, a `bezier` or `steps`, or a function, which comes back
+ * as it is. Call it once where a curve is built, not per frame; the same name or easing object
+ * gives the same function each time.
+ *
+ * @category patch
+ */
 export declare function curve(easing: Easing): Curve;

package/dist/easing.js

@@ -71,7 +71,13 @@ export function startSlope(c) {
     // Past a thousandth of the way within a millionth of the time: a jump, not a slope.
     return v > 1e-3 ? Number.POSITIVE_INFINITY : v / h;
 }
-/** The function an easing names. Resolved once where a patch or voice is built, not per frame. */
+/**
+ * The function an easing names: a CSS name, a `bezier` or `steps`, or a function, which comes back
+ * as it is. Call it once where a curve is built, not per frame; the same name or easing object
+ * gives the same function each time.
+ *
+ * @category patch
+ */
 export function curve(easing) {
     if (typeof easing === 'function')
         return easing;

package/dist/everyone.d.ts

@@ -10,9 +10,22 @@ import type { Subject, Voice } from './voice.js';
  * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
  * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
  * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
- * through `setting.keep`) turns it back with `unshare`.
+ * through `setting.keep`) turns it back with `unshare`, and so does playing `shareFrames` frames.
  */
 export declare function shares<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): boolean;
+/**
+ * How many frames a voice plays sharing one record before it takes one a subject. Sharing saves a
+ * voice cued and gone within a few frames a record per subject, but costs a read more than a record
+ * of the subject's own: 0.13 ms a frame for one voice over 10,000 subjects (`glowbase`, teitou,
+ * 2026-10-21), against about 2 MB allocated once to stop. Settable for bench/same.mjs.
+ */
+export declare let shareFrames: number;
+export declare function setShareFrames(n: number): void;
+/**
+ * Turns back each voice that has played `shareFrames` frames sharing one record. Not a keys voice,
+ * whose record `open` never points at a subject, so it costs no read more.
+ */
+export declare function outgrow<I, O>(mix: Mixer<I, O>): void;
 /**
  * A sharing voice's one record, made when a chain first asks; null where its origin is still
  * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.

package/dist/everyone.js

@@ -1,3 +1,4 @@
+import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { record } from './record.js';
 /**
@@ -10,7 +11,7 @@ import { record } from './record.js';
  * and `shut` takes back after. About 32 B a subject where a record and its place in the voice's
  * store took about 370 (bench/allocs.mjs on the `swap` row, 2026-10-09). It needs lanes for the
  * numbers. What only shows later (a subject faded out of it alone, a fade at rest, state kept
- * through `setting.keep`) turns it back with `unshare`.
+ * through `setting.keep`) turns it back with `unshare`, and so does playing `shareFrames` frames.
  */
 export function shares(mix, voice) {
     const spec = voice.spec;
@@ -38,6 +39,30 @@ export function shares(mix, voice) {
             return channel.rest !== undefined && numericOf(channel)?.op !== 'last';
         }));
 }
+/**
+ * How many frames a voice plays sharing one record before it takes one a subject. Sharing saves a
+ * voice cued and gone within a few frames a record per subject, but costs a read more than a record
+ * of the subject's own: 0.13 ms a frame for one voice over 10,000 subjects (`glowbase`, teitou,
+ * 2026-10-21), against about 2 MB allocated once to stop. Settable for bench/same.mjs.
+ */
+export let shareFrames = 60;
+export function setShareFrames(n) {
+    shareFrames = n;
+}
+/**
+ * Turns back each voice that has played `shareFrames` frames sharing one record. Not a keys voice,
+ * whose record `open` never points at a subject, so it costs no read more.
+ */
+export function outgrow(mix) {
+    const sharers = mix.sharers;
+    for (let i = sharers.length - 1; i >= 0; i--) {
+        const voice = sharers[i];
+        if (voice.built !== null || voice.state === 'pending' || voice.state === 'done')
+            continue;
+        if (++voice.shared >= shareFrames)
+            unshare(mix, voice);
+    }
+}
 /**
  * A sharing voice's one record, made when a chain first asks; null where its origin is still
  * ahead, which a record of its own per subject follows as the clock moves, so it shares no more.
@@ -191,7 +216,7 @@ export function unshare(mix, voice, kept = false, keeper) {
     const at = mix.sharers.indexOf(voice);
     if (at >= 0)
         mix.sharers.splice(at, 1);
-    const slot = kept ? (mix.chains.get(keeper)?.slot ?? -1) : -1;
+    const slot = kept ? (headOf(mix, keeper)?.slot ?? -1) : -1;
     // A projection numbers no subject, so its copy's record is the keeper's without being asked.
     if (all !== null && kept && (mix.projecting || sighted(voice, slot))) {
         if (slot >= 0)

package/dist/fade.js

@@ -1,4 +1,4 @@
-import { changed, unlink } from './chain.js';
+import { changed, headOf, unlink } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
 import { unshare, unsight } from './everyone.js';
@@ -63,7 +63,7 @@ export function unpart(mix, voice, subject) {
     voice.parted.delete(subject);
     if (voice.parted.size === 0)
         voice.parted = null;
-    const slot = mix.chains.get(subject)?.slot ?? -1;
+    const slot = headOf(mix, subject)?.slot ?? -1;
     if (slot >= 0)
         mix.lanes?.rejoin(slot);
 }
@@ -99,7 +99,7 @@ export function fadesAt(fades, left, seq) {
 }
 /** Drops a voice's record of a subject and relinks the subject's chain without it. */
 function forgetIn(mix, voice, subject) {
-    const head = mix.chains.get(subject);
+    const head = headOf(mix, subject);
     if (head !== undefined && head.slot >= 0) {
         unreach(voice, head.slot, false);
         // What the voice kept for the subject while it shared one record, which `weightOf` reads.

package/dist/fill.js

@@ -6,7 +6,6 @@ import { open as openRecord, shut as shutRecord } from './everyone.js';
 import { unband } from './fold.js';
 import { foldLocus, gatherLocus } from './gather.js';
 import { runKeys } from './keyfill.js';
-import { frozenAt } from './lane.js';
 import { reach } from './meet.js';
 import { absent } from './numbers.js';
 import { AT, NOTHING, readKeys, seg, segment, shifted } from './patch.js';
@@ -184,8 +183,6 @@ export function wake(lanes, lane) {
  */
 export function signalled(voice, slot, rec) {
     const arg = this.arg;
-    const elapsed = arg[1 /* Arg.ELAPSED */];
-    const pass = arg[3 /* Arg.PASS */];
     const fade = arg[5 /* Arg.FADE */];
     if (Number.isNaN(rec.probed)) {
         this.late.push(slot);
@@ -196,8 +193,8 @@ export function signalled(voice, slot, rec) {
         arg[0 /* Arg.WEIGHT */] = 0;
         return true;
     }
-    const base = this.host.signal(voice, subject, rec, elapsed, pass, slot);
-    arg[0 /* Arg.WEIGHT */] = weighed(base, fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
+    this.host.signal(voice, subject, rec, slot);
+    arg[0 /* Arg.WEIGHT */] = weighed(arg[0 /* Arg.WEIGHT */], fade, voice.parts === null ? 1 : this.host.parting(voice, subject));
     return true;
 }
 /** What a subject's own ramp out of a voice leaves of its weight: 1 with none. */
@@ -299,7 +296,19 @@ export function one(lane, p, slot) {
     if (this.lately >= 0 && this.unread(slot))
         return false;
     const delay = data[o + 0 /* Row.DELAY */];
-    const elapsed = frozenAt(voice, elapsedNow - delay);
+    const raw = elapsedNow - delay;
+    // `frozenAt` written out: V8 leaves it out of line here, a call a subject.
+    const elapsed = !(raw >= 0)
+        ? voice.freezesBefore
+            ? 0
+            : Number.NaN
+        : raw > voice.span
+            ? voice.hidesPast
+                ? Number.NaN
+                : voice.freezesAfter
+                    ? voice.span
+                    : raw
+            : raw;
     if (!(elapsed >= 0)) {
         data[o + 2 /* Row.WEIGHT */] = 0;
         unband(lane.records[p]);
@@ -418,9 +427,7 @@ export function readKeyed(voice, phase, delta, scratch) {
  */
 export function call(voice, chans, rec, slot) {
     const arg = this.arg;
-    const elapsed = arg[1 /* Arg.ELAPSED */];
     const phase = arg[2 /* Arg.PHASE */];
-    const pass = arg[3 /* Arg.PASS */];
     const delay = arg[4 /* Arg.DELAY */];
     const w = arg[0 /* Arg.WEIGHT */];
     const host = this.host;
@@ -436,7 +443,7 @@ export function call(voice, chans, rec, slot) {
     if (silent(voice, w))
         return false;
     const kept = reading.kept;
-    host.ready(voice, subject, rec, elapsed, pass, w);
+    host.ready(voice, subject, rec);
     if (this.keeps)
         host.horizon(voice, delay);
     else

package/dist/fit.d.ts

@@ -30,6 +30,11 @@ export interface Claim {
     /** Whether it may jump to its end instead of playing. */
     ballast: boolean;
     priority: Strength;
+    /**
+     * Span ms from now before which it may not start, from its `earliest`; absent for none. Below 0
+     * where it has passed, which places the child there.
+     */
+    floor?: number;
 }
 /**
  * The span as a fit sees it.
@@ -75,7 +80,9 @@ export declare function shareOf(order: Order, stagger: number): number;
 export declare function plain(span: SpanClaim, kids: readonly Claim[]): FitPlan;
 /**
  * Where a plan puts each child, span ms from now, and how long they take together. A playing child
- * is where it is, at 0; each pending one starts its share through the one before it.
+ * is where it is, at 0; each pending one starts its share through the one before it, or at its
+ * floor where that is later. A floor already past places a child before now, so it starts partway
+ * through; one without a floor starts no sooner than now.
  *
  * @category score
  */

package/dist/fit.js

@@ -17,7 +17,9 @@ export function plain(span, kids) {
 }
 /**
  * Where a plan puts each child, span ms from now, and how long they take together. A playing child
- * is where it is, at 0; each pending one starts its share through the one before it.
+ * is where it is, at 0; each pending one starts its share through the one before it, or at its
+ * floor where that is later. A floor already past places a child before now, so it starts partway
+ * through; one without a floor starts no sooner than now.
  *
  * @category score
  */
@@ -29,9 +31,11 @@ export function layout(span, kids, plan) {
     let prevLen = 0;
     kids.forEach((k, i) => {
         const len = plan.skip[i] ? 0 : k.natural / plan.rate[i];
-        const t = k.state === 'playing' || i === 0
+        const t = k.state === 'playing'
             ? 0
-            : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen;
+            : Math.max(i === 0
+                ? Number.NEGATIVE_INFINITY
+                : prevAt + (k.overlap ? Math.min(plan.share, base) : base) * prevLen, k.floor ?? 0);
         at.push(t);
         length = Math.max(length, t + len);
         prevAt = t;

package/dist/fold.js

@@ -1,3 +1,4 @@
+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';
@@ -82,7 +83,11 @@ export function contribution(voice, subject, now, held) {
     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.
@@ -102,7 +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);
+    // 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.
@@ -111,18 +118,21 @@ 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);
             }
             const tick = stepOf(this, voice);
-            if (tick !== undefined) {
-                // Never probed, it may be a record a seek put back.
-                if (Number.isNaN(held.probed) && held.snaps !== undefined)
-                    ahead(this, voice, subject, held, held.snaps, tick, to);
+            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)
                     setting.dt = this.capped(to - held.stepped);
@@ -130,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
@@ -193,10 +205,12 @@ function dueBy(held, tick, to) {
     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 state that copy was last
- * stepped ahead to, where the steps due now run past it, and 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. Only
- * where the same steps give the same state: a fixed interval, no `maxDt`, no host field read.
+ * 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];
@@ -212,7 +226,16 @@ function ahead(mix, voice, subject, held, snaps, tick, to) {
     if (held.ticks !== was.ticks || held.since !== got.since || held.rebuilt !== was.rebuilt)
         return;
     const at = got.sought;
-    const usable = got.state !== undefined && got.ticks <= dueBy(held, tick, to);
+    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;
@@ -221,11 +244,24 @@ function ahead(mix, voice, subject, held, snaps, tick, to) {
     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
@@ -338,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.
@@ -421,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/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,6 +16,7 @@ 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 through `h`, which `again` makes once more where a seek replays
@@ -63,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

@@ -141,6 +141,14 @@ export class VoiceHandle {
         this.#host.rise(voice, 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;
         return voice === null ? 0 : this.#host.weightOf(voice, subject);

package/dist/held.d.ts

@@ -2,8 +2,11 @@ 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