@msb235/blits 0.14.0 → 0.15.1

package/dist/changes.js

@@ -0,0 +1,189 @@
+import { absent } from './numbers.js';
+import { reading } from './reading.js';
+import { numbers } from './stretch.js';
+const PENDING = 2 /* RunFlag.PENDING */;
+const OLDER = 4 /* RunFlag.OLDER */;
+/** Where `applied` reads a stretch at the time a change lands; copied out before it returns. */
+let landing = { x: new Float64Array(4), v: new Float64Array(4) };
+/**
+ * Queues a retarget, set or push, untimed at the latest frame, for `subject`'s next read past its time.
+ * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
+ */
+export function change(subject, c) {
+    const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
+    const s = this.slot(subject);
+    this.check(c.to, this.n);
+    this.check(c.x, this.n);
+    this.check(c.v, this.n);
+    c.made = this.owner === null ? Number.NaN : this.owner.now();
+    c.seq = this.owner === null ? Number.NaN : this.owner.seq();
+    c.early = this.owner?.early() === true;
+    if (c.at === undefined) {
+        const at = this.frame(subject);
+        if (!Number.isNaN(at))
+            c.at = at;
+        else if (!Number.isNaN(back))
+            c.at = back;
+    }
+    const list = this.pending?.[s];
+    if (list === undefined) {
+        if (this.pending === null)
+            this.pending = [undefined];
+        this.pending[s] = [c];
+        this.flag(s, PENDING, true);
+    }
+    else if (c.at === undefined)
+        list.push(c);
+    else
+        this.queue(list, c, c.at);
+    reading.moved++;
+    const made = { at: c.at, to: c.to, x: c.x, v: c.v };
+    this.owner?.changed(this.ownerId, this, subject, made);
+}
+/** Files a change with a time after every one due by then, ahead of those still waiting for one. */
+export function queue(list, c, at) {
+    let i = list.length;
+    while (i > 0) {
+        const before = list[i - 1].at;
+        if (before !== undefined && before <= at)
+            break;
+        i--;
+    }
+    list.splice(i, 0, c);
+}
+/** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
+export function peek(s, t, xo, vo) {
+    let seg = this.playing(s, t);
+    const list = this.dueTo(s);
+    if (list !== undefined)
+        for (const change of list) {
+            const a = change.at;
+            if (a === undefined || !(a <= t))
+                break;
+            if (a >= seg.at)
+                seg = this.applied(this.numbers.subject(s), seg, change, a);
+        }
+    this.evaluateSegment(seg, t, xo, vo);
+}
+/** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+export function dueTo(s) {
+    const own = this.pending?.[s];
+    const ahead = reading.ahead?.get(this);
+    if (ahead === undefined)
+        return own;
+    const subject = this.numbers.subject(s);
+    const made = subject === absent ? undefined : ahead.get(subject);
+    if (made === undefined)
+        return own;
+    if (own === undefined)
+        return made;
+    // The patch's own were made first, and a stable sort keeps them first at one time.
+    return [...own.filter((c) => c.at !== undefined), ...made].sort((a, b) => a.at - b.at);
+}
+/**
+ * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
+ * kept, with the changes made by then queued to be applied again.
+ */
+export function rewind(seq) {
+    this.unrelease(seq);
+    for (let s = 0; s < this.numbers.size; s++)
+        if (this.numbers.subject(s) !== absent)
+            this.cut(s, seq);
+}
+export function cut(s, seq) {
+    const older = this.older?.[s];
+    const pending = this.pending?.[s];
+    const current = this.latest(s);
+    const stretches = older === undefined ? [current] : [...older, current];
+    const kept = [];
+    let cut = false;
+    for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
+        if (c === undefined || c.seq === undefined || !(c.seq > seq)) {
+            if (c !== undefined)
+                kept.push(c);
+        }
+        else
+            cut = true;
+    if (!cut)
+        return;
+    if (older !== undefined) {
+        this.older[s] = undefined;
+        this.flag(s, OLDER, false);
+    }
+    this.write(s, stretches[0]);
+    // Applied again in the order they take effect; one never stamped waits for the next read.
+    const timed = kept
+        .filter((c) => c.at !== undefined)
+        .sort((a, b) => a.at - b.at);
+    const list = [...timed, ...kept.filter((c) => c.at === undefined)];
+    if (list.length === 0) {
+        if (pending !== undefined) {
+            this.pending[s] = undefined;
+            this.flag(s, PENDING, false);
+        }
+        return;
+    }
+    if (this.pending === null)
+        this.pending = [undefined];
+    this.pending[s] = list;
+    this.flag(s, PENDING, true);
+}
+/** The stretch `change` releases from `seg` at `at`, for `subject` or one no longer numbered. */
+export function applied(subject, seg, change, at) {
+    const n = this.n;
+    if (landing.x.length < n)
+        landing = { x: new Float64Array(n), v: new Float64Array(n) };
+    const { x, v } = landing;
+    this.evaluateSegment(seg, at, x, v);
+    const xs = change.x ?? numbers(x, 0, n);
+    const vs = change.v ?? numbers(v, 0, n);
+    const known = subject === absent ? undefined : subject;
+    const put = change.x !== undefined && change.v === undefined;
+    const to = this.shape.aim(xs, vs, change.to ?? seg.to, known, put);
+    const ms = subject === absent ? seg.ms : (this.shape.ms?.(known) ?? 0);
+    return { at, ms, x0: xs, v0: vs, to, change };
+}
+export function commit(s, t) {
+    const list = this.pending[s];
+    // The first read of a subject no frame had met: those waiting for a time take this one.
+    if (list[list.length - 1].at === undefined) {
+        let i = list.length;
+        while (i > 0 && list[i - 1].at === undefined)
+            i--;
+        for (const c of list.splice(i)) {
+            c.at = t;
+            this.queue(list, c, t);
+        }
+    }
+    while (list.length > 0) {
+        const change = list[0];
+        const a = change.at;
+        if (a > t)
+            break;
+        list.shift();
+        this.insert(s, this.applied(this.numbers.subject(s), this.playing(s, a), change, a));
+    }
+    if (list.length === 0) {
+        this.pending[s] = undefined;
+        this.flag(s, PENDING, false);
+    }
+}
+export function insert(s, seg) {
+    let list = this.older?.[s];
+    if (list === undefined) {
+        list = [];
+        if (this.older === null)
+            this.older = [undefined];
+        this.older[s] = list;
+        this.flag(s, OLDER, true);
+    }
+    if (seg.at >= this.runs[this.base(s)]) {
+        list.push(this.latest(s));
+        this.write(s, seg);
+        return;
+    }
+    let i = list.length;
+    while (i > 0 && list[i - 1].at > seg.at)
+        i--;
+    list.splice(i, 0, seg);
+}

package/dist/channels.d.ts

@@ -26,6 +26,11 @@ export interface Numeric {
     axes: number;
     /** An angle's full turn: each value is taken the short way round before it folds. */
     turn?: number;
+    /**
+     * An `'own'` channel whose fold is this plain arithmetic, its lerp alone its own: a lane folds
+     * it as the op and lerps it through the channel. A copy that predates it folds it as `'own'`.
+     */
+    folds?: 'sum';
 }
 /**
  * The stock arithmetic of a channel `sum`, `mul`, `max` or `vec` made, or `vouch` was given, keyed
@@ -55,49 +60,71 @@ export interface NumberOptions {
     bounds?: readonly [min: number, max: number];
 }
 /**
- * Position axes, rotation, crawl, yaw, pitch, offset.
+ * A number whose contributions add, resting at 0.
+ *
+ * A weight scales a contribution toward 0, so two voices each moving `x` by 10 at half weight move it
+ * 10 in all. For position axes, rotation, crawl, yaw, pitch, offset.
  *
  * @category channel
  */
 export declare function sum(opts?: NumberOptions): Channel<number>;
 /**
- * Gain, scale, opacity, hold.
+ * A number whose contributions multiply, resting at 1.
+ *
+ * A weight fades a contribution toward 1 rather than 0, so 0.5 at half weight multiplies by 0.75, and
+ * at weight 0 it leaves the value alone. For gain, scale, opacity, hold.
  *
  * @category channel
  */
 export declare function mul(opts?: NumberOptions): Channel<number>;
 /**
- * Dark, aperture.
+ * A number where the largest contribution wins, resting at 0.
+ *
+ * A weight scales a contribution toward 0 before the comparison, so a fading voice gives way once
+ * another's value passes its scaled one. For dark, aperture.
  *
  * @category channel
  */
 export declare function max(opts?: NumberOptions): Channel<number>;
 /**
- * A channel with no rest: the last contribution to pass wins, and a weight can only gate it. The
+ * What `last` takes.
+ *
+ * @category channel
+ */
+export interface LastOptions<V> {
+    /** How to interpolate between two values. Default: step at the midpoint. */
+    lerp?: (a: V, b: V, u: number) => V;
+}
+/**
+ * A channel with no rest, where the last contribution to pass wins. A weight can only gate it. The
  * default `lerp` steps at the midpoint, which is all a value with no arithmetic can promise; a
  * consumer with a real interpolation passes its own, as `hex` does.
  *
  * @category channel
  */
-export declare function last<V>(opts?: {
-    lerp?: (a: V, b: V, u: number) => V;
-}): Channel<V>;
+export declare function last<V>(opts?: LastOptions<V>): Channel<V>;
 /**
  * `n` copies of `v` in an array the engine stores as doubles from the start, so a copy of it, and
  * every fraction written into that copy, keeps one element kind: a pose's arrays then look alike to
  * every fold, whichever path made them.
  */
 export declare function doubles(n: number, v: number): number[];
-type Tuple<N extends number, T extends number[] = []> = T['length'] extends N ? T : Tuple<N, [...T, number]>;
 /**
- * `N` numbers: a tuple where `N` is a literal, as `Vec<3>` is `[number, number, number]`, and
- * `number[]` where it is only known to be a number.
+ * A tuple of `N` numbers, as `NumberTuple<3>` is `[number, number, number]`. `T` is the tuple built
+ * so far; leave it out.
+ *
+ * @category channel
+ */
+export type NumberTuple<N extends number, T extends number[] = []> = T['length'] extends N ? T : NumberTuple<N, [...T, number]>;
+/**
+ * `N` numbers, as a tuple where `N` is a literal. `Vec<3>` is `[number, number, number]`, and a
+ * `Vec` is `number[]` where `N` is only known to be a number.
  *
  * @category channel
  */
-export type Vec<N extends number> = number extends N ? number[] : Tuple<N>;
+export type Vec<N extends number> = number extends N ? number[] : NumberTuple<N>;
 /**
- * Vec3 position, premultiplied light: one channel's arithmetic applied down an axis list.
+ * One channel's arithmetic applied down an axis list. For a Vec3 position, or premultiplied light.
  *
  * @category channel
  */
@@ -108,4 +135,3 @@ export declare function vec<N extends number>(n: N, of: Channel<number>): Channe
  * @category channel
  */
 export declare function kit<O>(channels: Kit<O>): Kit<O>;
-export {};

package/dist/channels.js

@@ -67,7 +67,10 @@ export function scalarOp(channel) {
 /** Bounds change how a value folds at its edges, so they are part of the kind. */
 const kindOf = (name, bounds) => bounds === undefined ? name : `${name}[${bounds[0]}, ${bounds[1]}]`;
 /**
- * Position axes, rotation, crawl, yaw, pitch, offset.
+ * A number whose contributions add, resting at 0.
+ *
+ * A weight scales a contribution toward 0, so two voices each moving `x` by 10 at half weight move it
+ * 10 in all. For position axes, rotation, crawl, yaw, pitch, offset.
  *
  * @category channel
  */
@@ -84,7 +87,10 @@ export function sum(opts) {
     return channel;
 }
 /**
- * Gain, scale, opacity, hold.
+ * A number whose contributions multiply, resting at 1.
+ *
+ * A weight fades a contribution toward 1 rather than 0, so 0.5 at half weight multiplies by 0.75, and
+ * at weight 0 it leaves the value alone. For gain, scale, opacity, hold.
  *
  * @category channel
  */
@@ -101,7 +107,10 @@ export function mul(opts) {
     return channel;
 }
 /**
- * Dark, aperture.
+ * A number where the largest contribution wins, resting at 0.
+ *
+ * A weight scales a contribution toward 0 before the comparison, so a fading voice gives way once
+ * another's value passes its scaled one. For dark, aperture.
  *
  * @category channel
  */
@@ -118,7 +127,7 @@ export function max(opts) {
     return channel;
 }
 /**
- * A channel with no rest: the last contribution to pass wins, and a weight can only gate it. The
+ * A channel with no rest, where the last contribution to pass wins. A weight can only gate it. The
  * default `lerp` steps at the midpoint, which is all a value with no arithmetic can promise; a
  * consumer with a real interpolation passes its own, as `hex` does.
  *
@@ -148,7 +157,7 @@ export function doubles(n, v) {
     return a;
 }
 /**
- * Vec3 position, premultiplied light: one channel's arithmetic applied down an axis list.
+ * One channel's arithmetic applied down an axis list. For a Vec3 position, or premultiplied light.
  *
  * @category channel
  */

package/dist/color.d.ts

@@ -1,13 +1,14 @@
 import type { Channel } from './types.js';
 /**
- * OKLCH, hue the short way round, so a crossfade between hues keeps its lightness and saturation
- * instead of dipping through a muddy middle. A mix that leaves sRGB's gamut is clipped per channel.
+ * Crossfades two hex colors in OKLCH, hue the short way round. A crossfade between hues then keeps
+ * its lightness and saturation instead of dipping through a muddy middle. A mix that leaves sRGB's
+ * gamut is clipped per channel.
  *
  * @category channel
  */
 export declare function mixHex(a: number, b: number, u: number): number;
 /**
- * How a `color` channel interpolates two colors: straight across OKLab, or in OKLCH with hue the
+ * How a `color` channel interpolates two colors. Straight across OKLab, or in OKLCH with hue the
  * short way round, as `mixHex` does.
  *
  * @category channel
@@ -21,29 +22,30 @@ export interface ColorOptions {
  * `toHex` divides it out and lays it over what is under it. `color(last())` replaces, the last
  * voice to pass winning, at the coverage it was authored with. `lerp` picks how two colors
  * interpolate: OKLab, the default, crosses through gray between opposite hues, and `'oklch'`
- * goes round the hue instead, off lanes.
+ * goes round the hue instead.
  *
  * @category channel
  */
 export declare function color(opts?: ColorOptions): Channel<number[]>;
 export declare function color(of: Channel<number> | Channel<unknown>, opts?: ColorOptions): Channel<number[]>;
 /**
- * 0xrrggbb as a `color` value: OKLab `[L, a, b]` at full coverage. Convert keyframe stops once
- * when authoring them, and call it outside the hot path in an `fn` patch.
+ * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * keyframe stops once when authoring them, and call it outside the hot path in an `fn` patch.
  *
  * @category channel
  */
 export declare function oklab(rgb: number): number[];
 /**
- * A `color` pose as 0xrrggbb: its color divided out of its coverage, the coverage capped at 1
- * and laid over `under` in OKLab, then clipped to sRGB per channel. No coverage gives `under`.
+ * A `color` pose as 0xrrggbb, laid over `under`. Its color is divided out of its coverage, the
+ * coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per channel. No
+ * coverage gives `under`.
  *
  * @category channel
  */
 export declare function toHex(pose: ArrayLike<number>, under?: number): number;
 /**
- * A `color` pose as a CSS `oklab()` color with its coverage, capped at 1, as the alpha, for a
- * host that lets the browser lay it over what is under it.
+ * A `color` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is capped at 1.
+ * For a host that lets the browser lay it over what is under it.
  *
  * @category channel
  */

package/dist/color.js

@@ -82,8 +82,9 @@ function fromOklch(L, C, h) {
     return fromLab(L, C * Math.cos(h), C * Math.sin(h));
 }
 /**
- * OKLCH, hue the short way round, so a crossfade between hues keeps its lightness and saturation
- * instead of dipping through a muddy middle. A mix that leaves sRGB's gamut is clipped per channel.
+ * Crossfades two hex colors in OKLCH, hue the short way round. A crossfade between hues then keeps
+ * its lightness and saturation instead of dipping through a muddy middle. A mix that leaves sRGB's
+ * gamut is clipped per channel.
  *
  * @category channel
  */
@@ -98,14 +99,19 @@ export function mixHex(a, b, u) {
     const ah = slotH[sa];
     const sb = oklch(b);
     const bc = slotC[sb];
-    const from = ac < GRAY ? slotH[sb] : ah;
-    const to = bc < GRAY ? ah : slotH[sb];
+    const h = hueAt(ah, ac, slotH[sb], bc, u);
+    return fromOklch(mix(al, slotL[sb], u), mix(ac, bc, u), h);
+}
+/** The hue `u` of the way from `ah` to `bh` the short way round, a gray end taking the other's. */
+function hueAt(ah, ac, bh, bc, u) {
+    const from = ac < GRAY ? bh : ah;
+    const to = bc < GRAY ? ah : bh;
     let turn = to - from;
     if (turn > Math.PI)
         turn -= 2 * Math.PI;
     else if (turn < -Math.PI)
         turn += 2 * Math.PI;
-    return fromOklch(mix(al, slotL[sb], u), mix(ac, bc, u), from + turn * u);
+    return from + turn * u;
 }
 /** Two OKLab colors with coverage, interpolated in OKLCH: color by `u`, coverage by `u` alongside. */
 function lerpLch(x, y, u) {
@@ -126,17 +132,8 @@ function lerpLch(x, y, u) {
     const toB = yw > 0 ? yB : xB;
     const xc = Math.sqrt(xA * xA + xB * xB);
     const yc = Math.sqrt(toA * toA + toB * toB);
-    const xh = Math.atan2(xB, xA);
-    const yh = Math.atan2(toB, toA);
-    const from = xc < GRAY ? yh : xh;
-    const to = yc < GRAY ? xh : yh;
-    let turn = to - from;
-    if (turn > Math.PI)
-        turn -= 2 * Math.PI;
-    else if (turn < -Math.PI)
-        turn += 2 * Math.PI;
     const C = mix(xc, yc, u);
-    const h = from + turn * u;
+    const h = hueAt(Math.atan2(xB, xA), xc, Math.atan2(toB, toA), yc, u);
     return [mix(xL, toL, u) * w, C * Math.cos(h) * w, C * Math.sin(h) * w, w];
 }
 export function color(ofOrOpts, maybe) {
@@ -149,8 +146,11 @@ export function color(ofOrOpts, maybe) {
         (stock?.op === 'sum' && stock.turn === undefined && of.bounds === undefined)) {
         const channel = vec(4, sum());
         channel.kind = `color(sum${space})`;
-        // A lane interpolates a stock channel straight across, so a lerp of its own takes it off them.
-        return round ? { ...channel, lerp: lerpLch } : channel;
+        if (!round)
+            return channel;
+        const turning = { ...channel, lerp: lerpLch };
+        vouch(turning, { op: 'own', axes: 4, folds: 'sum' });
+        return turning;
     }
     if (of.kind === 'last') {
         const channel = {
@@ -159,15 +159,14 @@ export function color(ofOrOpts, maybe) {
             lerp: round ? lerpLch : vec(4, sum()).lerp,
         };
         widen(channel, 4);
-        if (!round)
-            vouch(channel, { op: 'last', axes: 4 });
+        vouch(channel, { op: 'last', axes: 4 });
         return channel;
     }
     throw new Error(`color takes sum() to average or last() to replace, not ${of.kind ?? 'a channel of its own'}`);
 }
 /**
- * 0xrrggbb as a `color` value: OKLab `[L, a, b]` at full coverage. Convert keyframe stops once
- * when authoring them, and call it outside the hot path in an `fn` patch.
+ * Converts 0xrrggbb to a `color` value. The value is OKLab `[L, a, b]` at full coverage. Convert
+ * keyframe stops once when authoring them, and call it outside the hot path in an `fn` patch.
  *
  * @category channel
  */
@@ -176,8 +175,9 @@ export function oklab(rgb) {
     return [LAB[0], LAB[1], LAB[2], 1];
 }
 /**
- * A `color` pose as 0xrrggbb: its color divided out of its coverage, the coverage capped at 1
- * and laid over `under` in OKLab, then clipped to sRGB per channel. No coverage gives `under`.
+ * A `color` pose as 0xrrggbb, laid over `under`. Its color is divided out of its coverage, the
+ * coverage capped at 1 and laid over `under` in OKLab, then clipped to sRGB per channel. No
+ * coverage gives `under`.
  *
  * @category channel
  */
@@ -195,8 +195,8 @@ export function toHex(pose, under = 0x000000) {
     return fromLab(mix(LAB[0], L, w), mix(LAB[1], A, w), mix(LAB[2], B, w));
 }
 /**
- * A `color` pose as a CSS `oklab()` color with its coverage, capped at 1, as the alpha, for a
- * host that lets the browser lay it over what is under it.
+ * A `color` pose as a CSS `oklab()` color, its coverage as the alpha. The coverage is capped at 1.
+ * For a host that lets the browser lay it over what is under it.
  *
  * @category channel
  */

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

@@ -22,16 +22,12 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
     const frame = lanes.frameProbes;
     const subjects = lanes.subjects;
     const unlinked = lanes.unlinked;
+    const holds = lanes.holds;
+    // 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;
@@ -47,33 +43,25 @@ export function pullRun(lanes, slots, list, was, since, from, columns, now, vers
             per[o + 0 /* Per.FILLED */] >= busy ||
             per[o + 2 /* Per.IDLE */] !== 0 ||
             per[o + 1 /* Per.SEEN */] < wide ||
-            lanes.owes(slot))
+            (owing && lanes.owes(slot)))
             break;
         if (!(per[o + 3 /* Per.LANE_PROBE */] > frame ||
             per[o + 4 /* Per.GENERAL_PROBE */] > frame))
             lanes.distinct++;
         per[o + 3 /* Per.LANE_PROBE */] = ++lanes.probes;
         per[o + 5 /* Per.LANE_FILL */] = fills;
-        subjects[slot] = subject;
+        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 (n > from)
+    if (first >= 0)
+        add(lanes, first, start, n - start);
+    if (n > from && holds)
         lanes.holding = true;
     return n;
 }
@@ -81,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);
@@ -169,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);