@msb235/blits 0.15.0 → 0.15.1

package/CHANGELOG.md

@@ -4,6 +4,50 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.15.1
+
+### Added
+
+- `mix.trace(from, to, { grid })` reads the mix over a window of mix time without moving it, and
+  `trace.of(subject, channel)` gives a channel of one number as a `Run`: points joined by straight
+  lines, two points at one time for a jump, and `exact` where the lines are the mix's own values
+  throughout. Where every voice feeding the channel is a `keys` voice of known shape (plain number
+  stops eased `linear`, a number weight, a steady rate, no fade under way), the points are its own
+  breakpoints; elsewhere the run is read every `grid` ms, default 5. One trace shares its reads
+  across subjects. `Run`, `Trace`, `TraceOptions` and `NumberChannel` are exported.
+
+### Changed
+
+- A voice cued with `subjects` asks `stagger` for each of them at `cue`, not on first sight, and a
+  finite loop ends once its latest-staggered subject is done whether or not the host has read that
+  subject yet. A read ahead now sees the same end as the live mix. A voice reaching its subjects by
+  `target` still ends by the subjects it has met.
+
+### Fixed
+
+- One-subject tween voices cost about a fifth less a frame once they have landed: a fill folds a
+  landed tween's end as it stands, without reading its clock or easing it, until its voice, its
+  stretch or its subject's delay changes or the clock reads earlier than when it landed. 10,000 of
+  them read by `pull` (`tweens^`) take 0.235 ms a frame against 0.296, `churn^` 0.301 against
+  0.356 and `turnover^` 0.419 against 0.458 (studio, medians of seven runs of 5,000 frames, each in
+  its own process); one tween voice over 10,000 subjects (`weasel^`) is unchanged.
+- A crowd of one-subject `keys` or `fn` voices applies its voices' freezes in the fill's own loop
+  rather than through a call a row. 10,000 `keys` voices read by `pull` (`keyses^`) take 0.449 ms
+  a frame against 0.479, and allocate 6 kB a frame against 162 (studio, medians of seven runs of
+  1,500 frames, each in its own process); the same voices freezing at both ends (`frozen`,
+  `frozen^`) are unchanged.
+- `pull` over a list whose order has drifted from the order the mix first saw it in, as a list
+  kept dense by swap-remove does, writes rests in a few runs, not one per short stretch of
+  subjects. With one subject leaving and one arriving every frame (`turnover^`), a frame takes
+  0.253 ms against 0.262. Teitou, medians of seven runs of 5,000 frames, each in its own process.
+  Other rows are unchanged.
+- A list kept dense by swap-remove stays in the mix's own order for `pull`: a subject moved into
+  the place a dropped one left takes the number the drop freed, so `pull` reads the list in long
+  runs. `turnover^` takes 0.223 ms a frame against 0.263, close to the 0.210 of `churn^`, which
+  replaces voices without reordering anything (teitou with the node to itself, medians of seven
+  runs). The other rows are unchanged. A mix that keeps history, or has roles or a bound on its
+  lanes, keeps the old order.
+
 ## 0.15.0
 
 ### Breaking

package/README.md

@@ -151,7 +151,7 @@ do yet.
 
 ## Status
 
-v0.15.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.15.1, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.

package/dist/bare.js

@@ -48,9 +48,15 @@ export function bareRows(lanes, c, p, id) {
             !(per[q + 3 /* Per.LANE_PROBE */] > lately ||
                 per[q + 4 /* Per.GENERAL_PROBE */] > lately))
             break;
-        const elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
-        if (!(elapsed >= 0))
-            break;
+        // Every step from `now` to a sample's progress rounds monotonically, so a row seen landed at a
+        // positive rate is landed at any later `now` while it stays ready, and folds its `to` as it is.
+        const landed = ready && now >= hot[h + 8 /* Hot.LANDED */];
+        let elapsed = 0;
+        if (!landed) {
+            elapsed = clock(hot, h, now) - data[o + 0 /* Row.DELAY */];
+            if (!(elapsed >= 0))
+                break;
+        }
         keepProbed(data, o, per, q, fills);
         const w = hot[h + 4 /* Hot.WEIGHT */];
         data[o + 2 /* Row.WEIGHT */] = w;
@@ -60,14 +66,23 @@ export function bareRows(lanes, c, p, id) {
                 c.deltas[p] = null;
             }
             hot[h + 0 /* Hot.FLAGS */] = f | 2048 /* Flag.READY */;
+            hot[h + 8 /* Hot.LANDED */] = Number.POSITIVE_INFINITY;
         }
         if (w <= 0)
             continue;
-        const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
         const values = ch.values;
         const base = slot * n;
-        const x = h + 10 /* Hot.X0 */;
+        const x = h + 11 /* Hot.X0 */;
         const g = x + 2 * n;
+        if (landed) {
+            for (let a = 0; a < n; a++)
+                values[base + a] = foldNumber(op, values[base + a], hot[g + a], w);
+            continue;
+        }
+        const u = progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]);
+        const share = left(c.eases[p], u);
+        if (u >= 1 && hot[h + 3 /* Hot.RATE */] > 0)
+            hot[h + 8 /* Hot.LANDED */] = now;
         for (let a = 0; a < n; a++)
             values[base + a] = foldNumber(op, values[base + a], between(hot[x + a], hot[g + a], share), w);
     }
@@ -87,8 +102,8 @@ export function unbare(c, p) {
     hot[h + 0 /* Hot.FLAGS */] = hot[h + 0 /* Hot.FLAGS */] & ~2048 /* Flag.READY */;
     const n = c.axes;
     const elapsed = clock(hot, h, c.bareNow) - data[o + 0 /* Row.DELAY */];
-    const share = left(c.eases[p], progress(elapsed, hot[h + 8 /* Hot.AT */], hot[h + 9 /* Hot.MS */]));
-    const x = h + 10 /* Hot.X0 */;
+    const share = left(c.eases[p], progress(elapsed, hot[h + 9 /* Hot.AT */], hot[h + 10 /* Hot.MS */]));
+    const x = h + 11 /* Hot.X0 */;
     const g = x + 2 * n;
     for (let a = 0; a < n; a++)
         c.samples[p * n + a] = between(hot[x + a], hot[g + a], share);

package/dist/columns.d.ts

@@ -22,7 +22,8 @@ export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, lis
  * 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 declare function writeLater<I, O>(lanes: Lanes<I, O>, slot: number, columns: readonly Column[], n: number): void;
+export declare function writeLater<I, O>(lanes: Lanes<I, O>, slot: number, columns: readonly Column[], n: number, slots: Int32Array): void;
 /** Writes every queued run into its columns: a channel's values as a block, a rest as a fill. */
 export declare function flush<I, O>(lanes: Lanes<I, O>): void;

package/dist/columns.js

@@ -26,15 +26,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 +53,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 +69,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 +176,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

@@ -25,10 +25,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 +91,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,7 +2,7 @@ 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
@@ -45,7 +45,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 +68,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 +217,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 +254,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 +284,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 +381,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/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;
 /**

package/dist/everyone.js

@@ -185,6 +185,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;

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/held.js

@@ -1,5 +1,6 @@
 import { changed } from './chain.js';
 import { stepOf } from './clock.js';
+import { delayOf } from './delay.js';
 import { schedule } from './due.js';
 import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
@@ -50,7 +51,7 @@ export function held(voice, subject, slot, guess = null) {
         voice.keyed ??= new Set();
         voice.keyed.add(this.keys.key(subject));
     }
-    const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
+    const delay = delayOf(voice, subject);
     const since = this.sinceOf(voice, delay);
     const shown = this.shownOf(voice, since);
     held = record(voice, true, voice.patch.state ? voice.patch.state(subject) : undefined);

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, AnnounceOptions, ArcHandle, ArcPart, ArcSpec, ArcVoice, Band, BlendMember, BookedHit, Booker, BookOptions, Channel, Circle, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, Finder, FitResult, GlideSpec, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Probed, Projection, Pulled, Query, Registry, RegistryChange, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, SpringSpec, SubjectFade, Taken, Tape, TapeBranch, TapeMaker, TapeOp, TapeOptions, Transport, TransportOptions, TransportProjection, TweenSpec, VoiceFade, VoiceSpec, Watched, WatchedFrame, WatchedHistory, WatchedVoice, } from './types.js';
+export type { Anchor, AnnounceOptions, ArcHandle, ArcPart, ArcSpec, ArcVoice, Band, BlendMember, BookedHit, Booker, BookOptions, Channel, Circle, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, Finder, FitResult, GlideSpec, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, NumberChannel, OwnerSpec, Paged, PagedStream, Patch, Placement, Probed, Projection, Pulled, Query, Registry, RegistryChange, Run, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, SpringSpec, SubjectFade, Taken, Tape, TapeBranch, TapeMaker, TapeOp, TapeOptions, Trace, TraceOptions, Transport, TransportOptions, TransportProjection, TweenSpec, VoiceFade, VoiceSpec, Watched, WatchedFrame, WatchedHistory, WatchedVoice, } from './types.js';
 export { watched } from './watch.js';
 export type { WaveOptions, WaveShape } from './wave.js';
 export { wave, waveAt } from './wave.js';

package/dist/lane.d.ts

@@ -260,11 +260,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
     reserve(n: number, cap: number): void;
     /** Gives a subject the voice reaches a position, from what its record fixed on first sight. */
     add(slot: number, held: Subject<unknown>): void;
+    /** The subject numbered `from` is numbered `to` now, a number no position holds: same position. */
+    renumber(from: number, to: number): void;
     /** A subject lost its number: the last position moves into its place. */
     remove(slot: number): void;
 }
-/**
- * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing, as past its end running back.
- */
-export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -1,5 +1,4 @@
 import { unbareLane } from './bare.js';
-import { frozenTime } from './clock.js';
 import { motionOf } from './motion.js';
 /**
  * Keeps the weight a probe read from the last fill as `Row.PROBED`, for `weightOf`, before a fill
@@ -185,6 +184,20 @@ export class Lane {
         this.records[p] = held;
         this.deltas[p] = null;
     }
+    /** The subject numbered `from` is numbered `to` now, a number no position holds: same position. */
+    renumber(from, to) {
+        const p = this.positionOf(from);
+        if (p < 0)
+            return;
+        if (to >= this.at.length) {
+            const at = new Int32Array(Math.max(to + 1, this.at.length * 2, 64));
+            at.set(this.at);
+            this.at = at;
+        }
+        this.list[p] = to;
+        this.at[to] = p + 1;
+        this.at[from] = 0;
+    }
     /** A subject lost its number: the last position moves into its place. */
     remove(slot) {
         const p = this.positionOf(slot);
@@ -214,12 +227,3 @@ export class Lane {
         this.deltas[last] = null;
     }
 }
-/**
- * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing, as past its end running back.
- */
-export function frozenAt(voice, elapsed) {
-    if (elapsed > voice.span && voice.hidesPast)
-        return Number.NaN;
-    return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
-}

package/dist/lanes.d.ts

@@ -7,6 +7,7 @@ import { type Lane, type Laned, type Role } from './lane.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
 import { Placed } from './placed.js';
+import { type Seat } from './seat.js';
 import type { Watcher } from './stretch.js';
 import type { Subject } from './subject.js';
 import type { Channel } from './types.js';
@@ -70,7 +71,7 @@ export declare class Lanes<I, O> implements Watcher {
     readonly byId: Map<number, Lane<I, O>>;
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
-    readonly crowdOf: Map<number, Crowd<I, O>>;
+    readonly seats: Map<number, Seat<I, O>>;
     /** Which crowd voices' rows are placed on each subject. */
     readonly placed: Placed;
     /**
@@ -161,14 +162,16 @@ export declare class Lanes<I, O> implements Watcher {
      */
     readonly late: number[];
     /**
-     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs: each run's first
-     * lane slot, the row it goes to, and how many subjects follow both one apart.
+     * What `writeLater` and `pullRun` have queued, for one set of columns, as runs of rows: each
+     * run's first row and how many follow, and its first lane slot where its slots follow one apart
+     * too, else -1, when each row's slot is read from `queueFrom` by row.
      */
     queueSlots: Int32Array<ArrayBuffer>;
     queueRows: Int32Array<ArrayBuffer>;
     queueCounts: Int32Array<ArrayBuffer>;
     queued: number;
     queuedFor: readonly Column[] | null;
+    queueFrom: Int32Array | null;
     keeps: boolean;
     now: number;
     filledAt: number;
@@ -285,7 +288,7 @@ export declare class Lanes<I, O> implements Watcher {
     /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
     reshown(id: number): void;
     /** Something on a voice changed: a crowd copies it again at the next fill. */
-    voiceChanged(id: number): void;
+    voiceChanged(voice: Voice<I, O>): void;
 }
 declare const methods: {
     copy: typeof copy;