@msb235/blits 0.15.0 → 0.16.0

package/dist/columns.js

@@ -1,9 +1,4 @@
-export function clampRun(out, at, n, [lo, hi]) {
-    for (let i = at; i < at + n; i++) {
-        const x = out[i];
-        out[i] = x < lo ? lo : x > hi ? hi : x;
-    }
-}
+import { clampRun } from './pull.js';
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
  * each position's remembered chain head was current when the mix's `relinks` read `since`: what
@@ -26,15 +21,8 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
     // Nothing in `pullRun` makes a subject owe a voice, so one with nobody owing need not ask.
     const owing = lanes.owed.any();
     const current = since === Number.POSITIVE_INFINITY;
-    if (columns !== lanes.queuedFor) {
-        flush(lanes);
-        lanes.queuedFor = columns;
-    }
+    queueFor(lanes, columns, slots);
     room(lanes, lanes.queued + list.length - from);
-    const qSlots = lanes.queueSlots;
-    const qRows = lanes.queueRows;
-    const qCounts = lanes.queueCounts;
-    let k = lanes.queued;
     let n = from;
     // The run being gathered: its first slot and row, and how far it has reached.
     let first = -1;
@@ -60,23 +48,14 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
         if (holds)
             subjects[slot] = subject;
         if (slot !== first + (n - start)) {
-            if (first >= 0) {
-                qSlots[k] = first;
-                qRows[k] = start;
-                qCounts[k] = n - start;
-                k++;
-            }
+            if (first >= 0)
+                add(lanes, first, start, n - start);
             first = slot;
             start = n;
         }
     }
-    if (first >= 0) {
-        qSlots[k] = first;
-        qRows[k] = start;
-        qCounts[k] = n - start;
-        k++;
-    }
-    lanes.queued = k;
+    if (first >= 0)
+        add(lanes, first, start, n - start);
     if (n > from && holds)
         lanes.holding = true;
     return n;
@@ -85,24 +64,43 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
  * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
  * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A
  * channel no lane holds is at rest. Anything queued is written before the lanes fill again.
+ * `slots` holds each row's lane slot, `slot` among them.
  */
-export function writeLater(lanes, slot, columns, n) {
-    queue(lanes, columns, slot, n, 1);
+export function writeLater(lanes, slot, columns, n, slots) {
+    queueFor(lanes, columns, slots);
+    add(lanes, slot, n, 1);
 }
-/** Queues `count` subjects from lane slot `slot` for rows from `row`, one apart in both. */
-function queue(lanes, columns, slot, row, count) {
-    if (columns !== lanes.queuedFor) {
-        flush(lanes);
-        lanes.queuedFor = columns;
-    }
+/** Writes what is queued for other columns or another array of slots before queuing for these. */
+function queueFor(lanes, columns, slots) {
+    if (columns === lanes.queuedFor && slots === lanes.queueFrom)
+        return;
+    flush(lanes);
+    lanes.queuedFor = columns;
+    lanes.queueFrom = slots;
+}
+/**
+ * The shortest run `flush` copies as a block from consecutive slots. A shorter one, as a list kept
+ * dense by swap-remove leaves its slots, joins the rows before it in one run whose slots `flush`
+ * reads row by row, so a run's cost is paid once a stretch of rows rather than once a few.
+ */
+const BLOCK = 16;
+/** Queues `count` rows from `row`, whose slots follow one apart from `slot`. */
+function add(lanes, slot, row, count) {
     const k = lanes.queued;
     if (k > 0) {
         const last = k - 1;
         const had = lanes.queueCounts[last];
-        if (slot === lanes.queueSlots[last] + had &&
-            row === lanes.queueRows[last] + had) {
-            lanes.queueCounts[last] = had + count;
-            return;
+        if (row === lanes.queueRows[last] + had) {
+            const first = lanes.queueSlots[last];
+            if (first >= 0 && slot === first + had) {
+                lanes.queueCounts[last] = had + count;
+                return;
+            }
+            if (count < BLOCK && (first < 0 || had < BLOCK)) {
+                lanes.queueSlots[last] = -1;
+                lanes.queueCounts[last] = had + count;
+                return;
+            }
         }
     }
     room(lanes, k + 1);
@@ -173,16 +171,33 @@ function rests(lanes, c, runs) {
 }
 /** The longest run of values `copies` copies itself: `set` takes a view, an object a run. */
 const VIEWED = 256;
-/** Copies a laned channel's values for every queued run into its rows. */
+/** Copies a laned channel's values for every queued run into its rows, a block or row by row. */
 function copies(lanes, c, values, runs) {
     const slots = lanes.queueSlots;
     const rows = lanes.queueRows;
     const counts = lanes.queueCounts;
     const out = c.out;
     const axes = c.axes;
+    const from = lanes.queueFrom;
     for (let r = 0; r < runs; r++) {
+        const first = slots[r];
+        if (first < 0) {
+            const row = rows[r];
+            const end = row + counts[r];
+            if (axes === 1)
+                for (let i = row; i < end; i++)
+                    out[i] = values[from[i]];
+            else
+                for (let i = row; i < end; i++) {
+                    const at = i * axes;
+                    const base = from[i] * axes;
+                    for (let a = 0; a < axes; a++)
+                        out[at + a] = values[base + a];
+                }
+            continue;
+        }
         const at = rows[r] * axes;
-        const base = slots[r] * axes;
+        const base = first * axes;
         const span = counts[r] * axes;
         if (span > VIEWED)
             out.set(values.subarray(base, base + span), at);

package/dist/crowd.d.ts

@@ -6,12 +6,6 @@ import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject } from './subject.js';
 import type { Voice } from './voice.js';
-/**
- * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export declare function crowdable<I, O>(v: Voice<I, O>): boolean;
 /** The law of a row that has none, a keys or fn voice's. */
 export declare const none: Float64Array<ArrayBuffer>;
 /** Per row of a crowd's `hot`: what the fill reads of the row's voice and its current stretch. */
@@ -25,10 +19,15 @@ export declare const enum Hot {
     SEEKS = 5,
     EPOCH = 6,
     ID = 7,
-    AT = 8,
-    MS = 9,
+    /**
+     * A `Flag.READY` row's mix time from which its tween has landed, so a fill folds its `to` as it
+     * stands; Infinity until `bareRows` sees it land at a positive rate. Unread on any other row.
+     */
+    LANDED = 8,
+    AT = 9,
+    MS = 10,
     /** `x0`, `v0` and `to`, `axes` numbers each. */
-    X0 = 10
+    X0 = 11
 }
 /** A crowd row's flags, at `Hot.FLAGS`. */
 export declare const enum Flag {
@@ -86,7 +85,6 @@ export declare class Crowd<I, O> implements Positions<I, O> {
     eases: (Curve | undefined)[];
     /** Each row's patch law, one array shared by every row whose law is the same. */
     laws: Float64Array[];
-    readonly rowOf: Map<number, number>;
     idle: boolean;
     readonly line: {
         stop: number;

package/dist/crowd.js

@@ -2,19 +2,8 @@ import { bareRows, clock, unbare } from './bare.js';
 import { clampWeight, passAt, phaseAt, weighed } from './clock.js';
 import { closed } from './closed.js';
 import { KeyRows } from './keyrows.js';
-import { frozenAt, keepProbed, SPARSE } from './lane.js';
+import { keepProbed, SPARSE } from './lane.js';
 import { move } from './sample.js';
-/**
- * Whether a laned voice belongs in a crowd: one naming a single subject, which shares nothing
- * across subjects for a lane to save. A motion voice writes one channel; a keys or fn voice may
- * write several, and joins the crowd of voices writing those same channels.
- */
-export function crowdable(v) {
-    return (v.named !== null &&
-        v.named.size === 1 &&
-        v.spec.role === undefined &&
-        (v.slots.length === 1 || v.motion === undefined));
-}
 /** The law of a row that has none, a keys or fn voice's. */
 export const none = new Float64Array(0);
 /** Whether a row's flags let `bareRows` take it. */
@@ -45,7 +34,6 @@ export class Crowd {
     eases = [];
     /** Each row's patch law, one array shared by every row whose law is the same. */
     laws = [];
-    rowOf = new Map();
     idle = false;
     line = SPARSE.other;
     /** Where the fill now under way has reached. */
@@ -69,7 +57,7 @@ export class Crowd {
     constructor(chans, axes) {
         this.chans = chans;
         this.axes = axes;
-        this.stride = 10 /* Hot.X0 */ + 3 * axes;
+        this.stride = 11 /* Hot.X0 */ + 3 * axes;
         this.xs = new Float64Array(axes);
         this.vs = new Float64Array(axes);
     }
@@ -218,8 +206,19 @@ function rows(lanes, c, first, id) {
         const voice = c.voices[p];
         const elapsedNow = fast ? clock(hot, h, now) : voice.elapsedAt(now);
         let elapsed = elapsedNow - delay;
+        // Its freezes applied as `one` applies them, written out: a function for it stays out of line.
         if ((f & 256 /* Flag.FREEZES */) !== 0)
-            elapsed = frozenAt(voice, elapsed);
+            elapsed = !(elapsed >= 0)
+                ? voice.freezesBefore
+                    ? 0
+                    : Number.NaN
+                : elapsed > voice.span
+                    ? voice.hidesPast
+                        ? Number.NaN
+                        : voice.freezesAfter
+                            ? voice.span
+                            : elapsed
+                    : elapsed;
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             continue;
@@ -244,7 +243,7 @@ function rows(lanes, c, first, id) {
         data[o + 2 /* Row.WEIGHT */] = w;
         if ((f & 512 /* Flag.FLAT */) !== 0) {
             if (w > 0)
-                c.keys.fold(hot[h + 8 /* Hot.AT */], phaseAt(elapsed, hot[h + 10 /* Hot.X0 */], hot[h + 9 /* Hot.MS */]), c.chans, slot, w);
+                c.keys.fold(hot[h + 9 /* Hot.AT */], phaseAt(elapsed, hot[h + 11 /* Hot.X0 */], hot[h + 10 /* Hot.MS */]), c.chans, slot, w);
             continue;
         }
         arg[1 /* Arg.ELAPSED */] = elapsed;
@@ -274,7 +273,7 @@ function rows(lanes, c, first, id) {
                 c.restale(p, hot[h + 0 /* Hot.FLAGS */]);
             continue;
         }
-        closed(c.laws[p], c.eases[p], n, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */], hot, h + 10 /* Hot.X0 */, hot, h + 10 /* Hot.X0 */ + n, hot, h + 10 /* Hot.X0 */ + 2 * n, elapsed, xs, vs);
+        closed(c.laws[p], c.eases[p], n, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */], hot, h + 11 /* Hot.X0 */, hot, h + 11 /* Hot.X0 */ + n, hot, h + 11 /* Hot.X0 */ + 2 * n, elapsed, xs, vs);
         for (let a = 0; a < n; a++)
             samples[p * n + a] = xs[a];
         if (c.deltas[p] !== null)
@@ -371,7 +370,7 @@ function copyStretch(c, p, ms) {
     const h = p * c.stride;
     let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(4 /* Flag.STALE */ | 8 /* Flag.BARE */ | 32 /* Flag.FOLDS */);
     const ch = c.chans[0];
-    if (run.n === c.axes && run.stretchInto(ms, c.hot, h + 8 /* Hot.AT */)) {
+    if (run.n === c.axes && run.stretchInto(ms, c.hot, h + 9 /* Hot.AT */)) {
         f |= 8 /* Flag.BARE */;
         if (run.scalar(ms) === ch.scalar && ch.plain)
             f |= 32 /* Flag.FOLDS */;

package/dist/cue.js

@@ -3,8 +3,8 @@ import { checkHits } from './book.js';
 import { bind, checkWithin } from './bound.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
+import { roundsHue } from './color.js';
 import { schedule } from './due.js';
-import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
@@ -158,11 +158,14 @@ export function playable(mix, spec) {
     const motion = motionOf(patch);
     if (motion !== undefined) {
         const channel = patch.writes[0];
-        const rest = mix.kit[channel].rest;
+        const ch = mix.kit[channel];
+        const rest = ch.rest;
         if (typeof rest === 'number')
             motion.cuedOn(String(channel), true);
         else if (Array.isArray(rest) || ArrayBuffer.isView(rest))
-            motion.cuedOn(String(channel), false);
+            motion.cuedOn(String(channel), false, roundsHue(ch));
+        else if (roundsHue(ch))
+            motion.cuedOn(String(channel), false, true);
     }
     if (patch.reads) {
         const host = mix.opts.host;
@@ -250,7 +253,7 @@ function enter(mix, voice) {
         i--;
     cued.splice(i, 0, voice);
     scoredAdd(mix, voice);
-    voice.sharing = shares(mix, voice);
+    voice.sharing = mix.share?.shares(mix, voice) === true;
     enlist(mix, voice);
     changed(mix, voice);
     mix.stir();

package/dist/delay.d.ts

@@ -0,0 +1,3 @@
+import type { Voice } from './voice.js';
+/** A subject's `stagger` answer: as asked at cue for a voice naming its subjects, else asked now. */
+export declare function delayOf<I, O>(voice: Voice<I, O>, subject: I): number;

package/dist/delay.js

@@ -0,0 +1,7 @@
+/** A subject's `stagger` answer: as asked at cue for a voice naming its subjects, else asked now. */
+export function delayOf(voice, subject) {
+    const known = voice.named?.delays?.get(subject);
+    if (known !== undefined)
+        return known;
+    return voice.spec.stagger ? voice.spec.stagger(subject) : 0;
+}

package/dist/due.js

@@ -159,7 +159,7 @@ function dueOf(mix, voice) {
 export function schedule(mix, voice) {
     if (mix.projecting)
         return;
-    mix.lanes?.voiceChanged(voice.id);
+    mix.lanes?.voiceChanged(voice);
     const token = ++voice.dueToken;
     const due = dueOf(mix, voice);
     if (due === Number.POSITIVE_INFINITY)

package/dist/easing.d.ts

@@ -5,6 +5,8 @@ import type { Easing } from './types.js';
  * @category patch
  */
 export type Curve = (u: number) => number;
+/** Whether a segment eased by `c` runs in a straight line: no easing, or `linear`. */
+export declare function straight(c: Curve | undefined): boolean;
 /**
  * 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.

package/dist/easing.js

@@ -1,4 +1,8 @@
 const linear = (u) => u;
+/** Whether a segment eased by `c` runs in a straight line: no easing, or `linear`. */
+export function straight(c) {
+    return c === undefined || c === linear;
+}
 /** A CSS `cubic-bezier`: solves x(t) = u for t, then reads y(t). */
 function bezier(x1, y1, x2, y2) {
     const cx = 3 * x1;

package/dist/everyone.d.ts

@@ -51,6 +51,11 @@ export declare function open<I, O>(voice: Voice<I, O>, rec: Subject<unknown>, sl
 export declare function shut<I, O>(voice: Voice<I, O>, rec: Subject<unknown>, slot: number, cap: number): void;
 /** Makes stale what a sharing voice last read for the subject numbered `slot`, as `touch` asks. */
 export declare function restamp<I, O>(voice: Voice<I, O>, slot: number): void;
+/**
+ * The subject numbered `from` is numbered `to` now, a number let go of: what the voice keeps for it
+ * moves along, and `from` is left as `unsight` leaves it.
+ */
+export declare function resight<I, O>(voice: Voice<I, O>, from: number, to: number, cap: number): void;
 /** A subject's number was let go of: the next subject to take it is one the voice has not seen. */
 export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
 /**
@@ -60,11 +65,22 @@ export declare function unsight<I, O>(voice: Voice<I, O>, slot: number): void;
  * positions take their own records now, since each held the one.
  */
 export declare function unshare<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, kept?: boolean, keeper?: I): void;
-/**
- * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
- * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
- * `foldWith` asks one number.
- */
-export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export declare function inherit<I, O>(voice: Voice<I, O>, held: Subject<unknown>, slot: number): void;
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export declare const share: {
+    shares: typeof shares;
+    outgrow: typeof outgrow;
+    everyoneOf: typeof everyoneOf;
+    sighted: typeof sighted;
+    sight: typeof sight;
+    weightAt: typeof weightAt;
+    weighAt: typeof weighAt;
+    open: typeof open;
+    shut: typeof shut;
+    restamp: typeof restamp;
+    unsight: typeof unsight;
+    unshare: typeof unshare;
+    inherit: typeof inherit;
+};
+export type Share = typeof share;

package/dist/everyone.js

@@ -1,6 +1,7 @@
 import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
 import { record } from './record.js';
+import { detour } from './roster.js';
 /**
  * Whether a voice can keep one record for every subject, decided when it is cued. A record holds
  * what a voice knows of one subject; where the voice is over every subject with no stagger, keeps
@@ -185,6 +186,36 @@ export function restamp(voice, slot) {
     if (voice.built !== null && voice.everyone !== null)
         voice.everyone.seeks = -1;
 }
+/**
+ * The subject numbered `from` is numbered `to` now, a number let go of: what the voice keeps for it
+ * moves along, and `from` is left as `unsight` leaves it.
+ */
+export function resight(voice, from, to, cap) {
+    if (sighted(voice, from)) {
+        const seen = voice.seen;
+        sight(voice, to, cap);
+        voice.seen = seen;
+    }
+    const w = weightAt(voice, from);
+    if (w !== 0 || (voice.weights !== null && to < voice.weights.length))
+        weighAt(voice, to, w, cap);
+    let stamps = voice.stamps;
+    const o = from * 2 /* Stamp.SIZE */;
+    if (stamps !== null && o < stamps.length) {
+        const t = to * 2 /* Stamp.SIZE */;
+        if (t >= stamps.length) {
+            const grown = new Float64Array(Math.max(to + 1, cap) * 2 /* Stamp.SIZE */).fill(Number.NaN);
+            grown.set(stamps);
+            voice.stamps = grown;
+            stamps = grown;
+        }
+        stamps[t + 0 /* Stamp.PROBED */] = stamps[o + 0 /* Stamp.PROBED */];
+        stamps[t + 1 /* Stamp.SEEKS */] = stamps[o + 1 /* Stamp.SEEKS */];
+        const deltas = voice.deltas;
+        deltas[to] = deltas[from] ?? null;
+    }
+    unsight(voice, from);
+}
 /** A subject's number was let go of: the next subject to take it is one the voice has not seen. */
 export function unsight(voice, slot) {
     const bits = voice.sighted;
@@ -233,17 +264,25 @@ export function unshare(mix, voice, kept = false, keeper) {
     detour(mix);
     mix.lanes?.refill();
 }
-/**
- * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
- * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
- * `foldWith` asks one number.
- */
-export function detour(mix) {
-    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
-}
 /** Gives a record just made for a subject a sharing voice had seen what the voice kept for it. */
 export function inherit(voice, held, slot) {
     held.weight = weightAt(voice, slot);
     open(voice, held, slot);
     unsight(voice, slot);
 }
+/** What the general path calls on a sharing voice, reached through `Lanes`, so a lean bundle leaves it out. */
+export const share = {
+    shares,
+    outgrow,
+    everyoneOf,
+    sighted,
+    sight,
+    weightAt,
+    weighAt,
+    open,
+    shut,
+    restamp,
+    unsight,
+    unshare,
+    inherit,
+};

package/dist/fade.d.ts

@@ -30,7 +30,13 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
     at?: 'rest';
     deadline?: number;
     back?: boolean;
+    stays?: boolean;
 }, at?: number): void;
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner leaves at `at` if it holds no child still playing.
+ */
+export declare function stay<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number): void;
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
  * curve, at the whole curve per `over` ms. A fade waiting for rest is taken back at once. A voice
@@ -44,5 +50,10 @@ export declare function beginRise<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
  * exactly there; at or behind now, the fade began then and is partway.
  */
 export declare function fadeAt<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at: number, over: number | undefined): void;
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export declare function rouse<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
 /** Removes a voice, recording that it left at `at`, default now. */
 export declare function retire<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, at?: number): void;

package/dist/fade.js

@@ -1,10 +1,9 @@
 import { changed, headOf, unlink } from './chain.js';
 import { envelope } from './clock.js';
 import { schedule } from './due.js';
-import { unshare, unsight } from './everyone.js';
 import { leave, noted, releasing } from './history.js';
 import { markOf } from './marks.js';
-import { orphan, ownerReading } from './owner.js';
+import { orphan, ownerReading, plays } from './owner.js';
 import { startOf } from './place.js';
 import { isRested } from './record.js';
 import { scoreTouched } from './scored.js';
@@ -14,7 +13,7 @@ import { unreach } from './unreached.js';
 export function fadeSubject(mix, voice, subject, over) {
     if (voice.state === 'done' || voice.parted?.has(subject) || voice.parts?.has(subject))
         return;
-    unshare(mix, voice);
+    mix.share?.unshare(mix, voice);
     mix.stir();
     const ms = mix.reduced ? 0 : (over ?? voice.fade.out ?? 0);
     const at = Number.isNaN(mix.now) ? startOf(voice) : mix.now;
@@ -104,7 +103,7 @@ function forgetIn(mix, voice, 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.
-        unsight(voice, head.slot);
+        mix.share?.unsight(voice, head.slot);
     }
     const held = voice.subjects.get(subject);
     if (held !== undefined) {
@@ -135,7 +134,7 @@ export function beginFade(mix, voice, opts, at) {
     // A fade at rest marks each subject's record as it comes to rest, at its next read: one already
     // read this frame is read again, as after `touch`.
     if (opts.at === 'rest') {
-        unshare(mix, voice);
+        mix.share?.unshare(mix, voice);
         voice.seeks++;
     }
     voice.state = 'fading';
@@ -148,14 +147,36 @@ export function beginFade(mix, voice, opts, at) {
     };
     if (opts.back)
         voice.out.back = true;
+    if (opts.stays)
+        voice.out.stays = true;
     noted(mix, voice);
     // A fade at rest, from a voice's start, or of a voice yet to start takes it off its lane.
     if (opts.at === 'rest' || opts.back || waiting)
         mix.lanes?.invalidate();
     else
         mix.lanes?.refill();
-    if (over === 0 && opts.at !== 'rest')
-        retire(mix, voice, voice.out.at);
+    if (over === 0 && opts.at !== 'rest') {
+        if (opts.stays)
+            stay(mix, voice, voice.out.at);
+        else
+            retire(mix, voice, voice.out.at);
+    }
+}
+/**
+ * Keeps a voice faded at the end of its passes with its owner, live and quiet, rather than letting
+ * it leave; the owner leaves at `at` if it holds no child still playing.
+ */
+export function stay(mix, voice, at) {
+    voice.state = 'live';
+    mix.lanes?.refill();
+    const owner = voice.owner;
+    if (owner.state === 'done')
+        return;
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    if (!plays(owner, now) && !lingers(owner, at))
+        retire(mix, owner, at);
+    else if (owner.fitting !== null && !voice.skipped)
+        refit(mix, owner, at);
 }
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same
@@ -211,6 +232,21 @@ export function fadeAt(mix, voice, at, over) {
     voice.outSet = true;
     noted(mix, voice);
 }
+/**
+ * Brings back a voice kept quiet past its passes, its clock back in them by mix time `now`: it
+ * climbs from nothing over the fade it left over, from when its clock reached them.
+ */
+export function rouse(mix, voice, now) {
+    const out = voice.out;
+    const edge = out.back === true ? voice.soonest : voice.span + voice.latest;
+    const reached = voice.reaches(edge);
+    const at = Math.max(out.at + out.over, reached <= now ? reached : now);
+    const over = mix.reduced ? 0 : out.over;
+    voice.out = null;
+    voice.back = over > 0 ? { from: 0, at, over } : null;
+    noted(mix, voice);
+    mix.lanes?.refill();
+}
 /** Whether a motion patch still asks this voice of this mix for its time. */
 function asks(mix, motion, voice) {
     return motion.owner === mix.owner && motion.ownerId === voice.id;
@@ -248,7 +284,7 @@ export function retire(mix, voice, at) {
     if (voice.owner !== null) {
         const span = voice.owner;
         leaving(mix, voice);
-        const owner = orphan(voice);
+        const owner = orphan(voice, now);
         if (owner !== null && !lingers(owner, voice.doneAt))
             retire(mix, owner, voice.doneAt);
         // A child the fit skipped had no time in it, so the rest of the fit stands: fitting again

package/dist/fill.js

@@ -313,7 +313,7 @@ export function one(lane, p, slot) {
         return false;
     const delay = data[o + 0 /* Row.DELAY */];
     const raw = elapsedNow - delay;
-    // `frozenAt` written out: V8 leaves it out of line here, a call a subject.
+    // Its freezes applied, written out: V8 left a function for it out of line here, a call a subject.
     const elapsed = !(raw >= 0)
         ? voice.freezesBefore
             ? 0

package/dist/fold.js

@@ -1,10 +1,7 @@
 import { foldNumber } from './channels.js';
 import { copy as copyValue, first } from './clone.js';
-import { open as openRecord, shut as shutRecord, weighAt } from './everyone.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;
-const shut = shutRecord;
 /** A record's band state, made when a rest-less channel first asks. */
 function bandsFor(held, n) {
     const bands = new Uint8Array(n);
@@ -107,9 +104,9 @@ export function shared(voice, slot, rec, q) {
         // A projection numbers no subject, and keeps nothing by subject.
         if (slot < 0)
             return q;
-        const cap = this.lanes.cap;
-        weighAt(voice, slot, rec.weight, cap);
-        shut(voice, rec, slot, cap);
+        const lanes = this.lanes;
+        this.share.weighAt(voice, slot, rec.weight, lanes.cap);
+        this.share.shut(voice, rec, slot, lanes.cap);
         return q;
     }
     const sharers = this.sharers;
@@ -265,7 +262,7 @@ export function foldSharers(pose, subject, head, q, before, laned, dry, except,
             continue;
         if (voice.id === except || voice.state === 'done')
             continue;
-        open(voice, rec, head.slot);
+        this.share.open(voice, rec, head.slot);
         const delta = this.read(voice, subject, now, dry, rec);
         if (owed >= 0 && voice.laned)
             this.lanes.paid(voice.id, owed, rec.weight);