@msb235/blits 0.7.1 → 0.8.1

package/dist/record.js

@@ -0,0 +1,42 @@
+/**
+ * A subject's record for `voice` holding every field one can come to hold, in one order, so every
+ * record in a mix shares one hidden class: a record built elsewhere, or given `base`, `snaps` or
+ * `from` later, took a class of its own, and a fold walking a chain of several kinds reads each
+ * field the slow way. The caller sets what it knows; nothing here takes a number, which a call V8
+ * does not inline would box.
+ */
+export function record(voice, reaches, state) {
+    return {
+        reaches,
+        delay: 0,
+        since: 0,
+        shown: 0,
+        weight: 0,
+        rested: false,
+        bands: null,
+        state,
+        stepped: 0,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        rebuilt: 0,
+        base: undefined,
+        slope: undefined,
+        kept: null,
+        unkept: undefined,
+        snaps: undefined,
+        from: undefined,
+        unknown: undefined,
+        inputs: undefined,
+        replay: undefined,
+        voice,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+        run: -1,
+        freed: -1,
+    };
+}

package/dist/relink.d.ts

@@ -3,12 +3,16 @@ import type { Subject } from './voice.js';
 interface Ordered {
     readonly id: number;
 }
+/** What `patch` asks a mix: a voice's record for a subject where a full relink would link it. */
+interface Linker<V, I> {
+    linkable(voice: V, subject: I, slot: number): Subject<unknown> | null;
+}
 /**
  * The voices over every subject behind each step of a mix's `version`, so a chain linked a few
  * steps back can be brought up to date by those voices alone; null for a step that changed
  * anything else, after which every chain links afresh.
  */
-export declare class Steps<V extends Ordered> {
+export declare class Steps<V extends Ordered, I> {
     private list;
     /** The version before `list[0]`. */
     private from;
@@ -16,10 +20,12 @@ export declare class Steps<V extends Ordered> {
     push(voice: V | null, version: number): void;
     /**
      * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
-     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
-     * voice's record where a full relink would link it and null where it would not. undefined where
-     * the steps since do not say, so the chain must link afresh.
+     * stepped since taken off it or put on at its place in voice order by `mix.linkable`, which gives
+     * the voice's record where a full relink would link it and null where it would not. undefined
+     * where the steps since do not say, so the chain must link afresh. It takes the mix and the
+     * subject, not a function closed over them: a closure and its context a subject cost the `swap`
+     * row about 138 B each (bench/allocs.mjs, 2026-10-09).
      */
-    patch(head: Subject<unknown> | null, version: number, reach: (voice: V) => Subject<unknown> | null): Subject<unknown> | null | undefined;
+    patch(head: Subject<unknown> | null, version: number, mix: Linker<V, I>, subject: I, slot: number): Subject<unknown> | null | undefined;
 }
 export {};

package/dist/relink.js

@@ -21,11 +21,13 @@ export class Steps {
     }
     /**
      * A chain linked at `version`, its first record `head` (null where it holds none), with each voice
-     * stepped since taken off it or put on at its place in voice order by `reach`, which gives the
-     * voice's record where a full relink would link it and null where it would not. undefined where
-     * the steps since do not say, so the chain must link afresh.
+     * stepped since taken off it or put on at its place in voice order by `mix.linkable`, which gives
+     * the voice's record where a full relink would link it and null where it would not. undefined
+     * where the steps since do not say, so the chain must link afresh. It takes the mix and the
+     * subject, not a function closed over them: a closure and its context a subject cost the `swap`
+     * row about 138 B each (bench/allocs.mjs, 2026-10-09).
      */
-    patch(head, version, reach) {
+    patch(head, version, mix, subject, slot) {
         if (!(version >= this.from))
             return undefined;
         const list = this.list;
@@ -40,7 +42,7 @@ export class Steps {
                 at = at.next;
             }
             const here = at !== null && at.voice === voice ? at : null;
-            const want = reach(voice);
+            const want = mix.linkable(voice, subject, slot);
             if (want === here)
                 continue;
             const after = here === null ? at : here.next;

package/dist/restored.d.ts

@@ -0,0 +1,41 @@
+import type { Leavings } from './leavings.js';
+import { Store } from './store.js';
+import type { Cut } from './transport.js';
+import type { Subject } from './voice.js';
+/**
+ * A voice's records once a seek has gone back: each subject's is put back from the record it had,
+ * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
+ * It is one store however many seeks there are: by subject it keeps how many seeks its record has
+ * been put back for, and a record behind is put back to the earliest moment sought since, as a
+ * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ */
+export declare class Restored<I> extends Store<I, Subject<unknown>> {
+    private readonly own;
+    private readonly make;
+    /** Seeks back so far. */
+    private n;
+    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    private readonly at;
+    /**
+     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
+     * moment sought since seek `n` is that of the first here at or after it.
+     */
+    private readonly least;
+    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
+    private futures;
+    /** The latest seek's moment. */
+    private t;
+    /**
+     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
+     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     */
+    constructor(own: Store<I, Subject<unknown>>, make: (live: Subject<unknown>, t: number, top: number) => Subject<unknown> | undefined);
+    /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
+    back(t: number, cut: Cut, left: Leavings<I> | null): void;
+    /** The earliest moment sought by seek `from` or any after it. */
+    private since;
+    get(key: I): Subject<unknown> | undefined;
+    set(key: I, value: Subject<unknown>): void;
+    delete(key: I): void;
+    clear(): void;
+}

package/dist/restored.js

@@ -0,0 +1,91 @@
+import { Store } from './store.js';
+/**
+ * A voice's records once a seek has gone back: each subject's is put back from the record it had,
+ * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
+ * It is one store however many seeks there are: by subject it keeps how many seeks its record has
+ * been put back for, and a record behind is put back to the earliest moment sought since, as a
+ * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ */
+export class Restored extends Store {
+    own;
+    make;
+    /** Seeks back so far. */
+    n = 0;
+    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    at = new Store();
+    /**
+     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
+     * moment sought since seek `n` is that of the first here at or after it.
+     */
+    least = [];
+    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
+    futures = null;
+    /** The latest seek's moment. */
+    t = Number.NaN;
+    /**
+     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
+     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     */
+    constructor(own, make) {
+        super();
+        this.own = own;
+        this.make = make;
+    }
+    /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
+    back(t, cut, left) {
+        const n = ++this.n;
+        const least = this.least;
+        while (least.length > 0 && least[least.length - 1].t >= t)
+            least.pop();
+        least.push({ n, t });
+        this.t = t;
+        if (left !== null) {
+            this.futures ??= new Map();
+            this.futures.set(n, { left, cut });
+        }
+    }
+    /** The earliest moment sought by seek `from` or any after it. */
+    since(from) {
+        const least = this.least;
+        let lo = 0;
+        let hi = least.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (least[mid].n >= from)
+                hi = mid;
+            else
+                lo = mid + 1;
+        }
+        return least[lo].t;
+    }
+    get(key) {
+        const at = this.at.get(key) ?? 0;
+        if (at === this.n)
+            return this.own.get(key);
+        this.at.set(key, this.n);
+        // A subject that left after the moment the next seek sought had the record it left with,
+        // whatever it has now. Leaving is a write, so no later seek's leavings can hold it.
+        const future = this.futures?.get(at + 1);
+        const live = future?.left.at(key, future.cut) ?? this.own.get(key);
+        if (live === undefined)
+            return undefined;
+        const made = this.make(live, this.since(at + 1), this.t);
+        if (made === undefined)
+            this.own.delete(key);
+        else
+            this.own.set(key, made);
+        return made;
+    }
+    set(key, value) {
+        this.own.set(key, value);
+        this.at.set(key, this.n);
+    }
+    delete(key) {
+        this.own.delete(key);
+        this.at.set(key, this.n);
+    }
+    clear() {
+        this.own.clear();
+        this.at.clear();
+    }
+}

package/dist/revive.d.ts

@@ -1,5 +1,6 @@
 import type { Mixer } from './mixer.js';
 import type { Run } from './motions.js';
+import type { Past } from './origin.js';
 import { type PackedRecord } from './pack.js';
 import { type Key } from './paging.js';
 import type { Described } from './types.js';
@@ -22,8 +23,13 @@ interface PackedVoice {
     outAt: number;
     outOver: number;
     outSet: boolean;
+    rebuilds: number;
+    past: number;
+    clocks: Past[] | null;
     cuedAt: number;
+    cuedSeq: number;
     doneAt: number;
+    doneSeq: number;
     opened: number;
     pinned: number;
     latest: number;
@@ -32,11 +38,12 @@ interface PackedVoice {
     log: Controls[] | null;
     played: boolean | undefined;
     playedAt: number;
+    playedSeq: number;
     records: [Key, PackedRecord][];
     runs: [Key, Run][];
-    left: [Key, number, PackedRecord][];
-    parts: [Key, number, number][];
-    parted: [Key, number][];
+    left: [Key, number, number, PackedRecord, boolean][];
+    parts: [Key, number, number, number][];
+    parted: [Key, number, number][];
 }
 /**
  * Voices a history store holds whose handles something still holds, by id: a seek that revives

package/dist/revive.js

@@ -1,6 +1,7 @@
 import { playable } from './cue.js';
 import { VoiceHandle } from './handle.js';
 import { handle } from './hosts.js';
+import { Leavings } from './leavings.js';
 import { packHeld, unpackHeld } from './pack.js';
 import { pageOut } from './paging.js';
 import { Voice } from './voice.js';
@@ -47,7 +48,7 @@ export function pageVoice(mix, voice, reach) {
         return false;
     const keys = mix.keys;
     const data = packVoice(voice, keys);
-    pageOut(mix, 'voice', voice.id, undefined, [{ at: voice.doneAt }], () => data, reach);
+    pageOut(mix, 'voice', voice.id, undefined, [{ at: voice.doneAt, seq: voice.doneSeq }], () => data, reach);
     const h = voice.handle;
     VoiceHandle.page(h, { weight: voice.weight, played: voice.settled.played === true });
     mix.outs.add(voice.id, voice.doneAt, h);
@@ -81,8 +82,13 @@ function packVoice(voice, keys) {
         outAt: voice.outAt,
         outOver: voice.outOver,
         outSet: voice.outSet,
+        rebuilds: voice.rebuilds,
+        past: voice.clocks?.length ?? 0,
+        clocks: voice.clocks,
         cuedAt: voice.cuedAt,
+        cuedSeq: voice.cuedSeq,
         doneAt: voice.doneAt,
+        doneSeq: voice.doneSeq,
         opened: voice.opened,
         pinned: voice.pinned,
         latest: voice.latest,
@@ -91,11 +97,18 @@ function packVoice(voice, keys) {
         log: voice.log,
         played: settled.played,
         playedAt: settled.at,
+        playedSeq: settled.seq,
         records,
         runs,
-        left: (voice.left ?? []).map((e) => [keys.key(e.subject), e.at, packHeld(voice, e.held)]),
-        parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over]),
-        parted: [...(voice.parted ?? [])].map(([s, at]) => [keys.key(s), at]),
+        left: (voice.left?.all() ?? []).map((e) => [
+            keys.key(e.subject),
+            e.at,
+            e.seq,
+            packHeld(voice, e.held),
+            e.sync,
+        ]),
+        parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over, r.seq]),
+        parted: [...(voice.parted ?? [])].map(([s, p]) => [keys.key(s), p.at, p.seq]),
     };
 }
 /** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
@@ -106,18 +119,12 @@ export function reviveVoice(mix, id, d) {
     const spec = { ...revive(d.as), as: d.as };
     playable(mix, spec);
     const voice = new Voice(id, spec, spec.patch, spec.fade ?? {}, Number.NEGATIVE_INFINITY, d.start, mix.slotOf, mix.channels, mix.opts.host, mix.send, null);
-    voice.anchorNow = d.anchorNow;
-    voice.anchorElapsed = d.anchorElapsed;
-    voice.rate = d.rate;
-    voice.ramp = d.ramp;
-    voice.weight = d.weight;
-    voice.out = d.out;
-    voice.back = d.back;
-    voice.outAt = d.outAt;
-    voice.outOver = d.outOver;
-    voice.outSet = d.outSet;
+    voice.clocks = d.clocks;
+    voice.take(d);
     voice.cuedAt = d.cuedAt;
+    voice.cuedSeq = d.cuedSeq;
     voice.doneAt = d.doneAt;
+    voice.doneSeq = d.doneSeq;
     voice.opened = d.opened;
     voice.pinned = d.pinned;
     voice.latest = d.latest;
@@ -126,7 +133,7 @@ export function reviveVoice(mix, id, d) {
     voice.log = d.log;
     voice.state = 'done';
     if (d.played !== undefined)
-        voice.play(d.played, d.playedAt);
+        voice.play(d.played, d.playedAt, d.playedSeq);
     voice.resolve();
     const keys = mix.keys;
     const subjectOf = (key) => keys.subject(key);
@@ -137,16 +144,17 @@ export function reviveVoice(mix, id, d) {
     }
     for (const [key, run] of d.runs)
         voice.motion?.unpack(subjectOf(key), run);
-    if (d.left.length > 0)
-        voice.left = d.left.map(([key, at, p]) => ({
-            subject: subjectOf(key),
-            at,
-            held: unpackHeld(voice, p),
-        }));
+    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync]) => ({
+        subject: subjectOf(key),
+        at,
+        seq,
+        sync,
+        held: unpackHeld(voice, p),
+    })));
     if (d.parts.length > 0)
-        voice.parts = new Map(d.parts.map(([key, at, over]) => [subjectOf(key), { at, over }]));
+        voice.parts = new Map(d.parts.map(([key, at, over, seq]) => [subjectOf(key), { at, over, seq }]));
     if (d.parted.length > 0)
-        voice.parted = new Map(d.parted.map(([key, at]) => [subjectOf(key), at]));
+        voice.parted = new Map(d.parted.map(([key, at, seq]) => [subjectOf(key), { at, seq }]));
     const h = mix.outs?.take(id);
     if (h === undefined)
         voice.handle = handle(mix, voice);

package/dist/roster.d.ts

@@ -0,0 +1,11 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/** Counts a voice just put in the list into everything a sync and a fold skip work by. */
+export declare function enlist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Counts a voice leaving the list back out. A voice naming no subject stays in `general` and
+ * `sharers`, which the caller filters once for every voice leaving together.
+ */
+export declare function delist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Counts the list over from nothing, for a seek or a projection's copy. `owners` is the caller's. */
+export declare function recount<I, O>(mix: Mixer<I, O>): void;

package/dist/roster.js

@@ -0,0 +1,46 @@
+import { index, unindex } from './chain.js';
+import { detour } from './everyone.js';
+import { Store } from './store.js';
+function tally(mix, voice, by) {
+    if (voice.spec.locus !== undefined)
+        mix.loci += by;
+    if (voice.spec.anchor !== undefined)
+        mix.anchored += by;
+}
+/** Counts a voice just put in the list into everything a sync and a fold skip work by. */
+export function enlist(mix, voice) {
+    if (voice.holding !== null) {
+        mix.owners ??= [];
+        mix.owners.push(voice);
+    }
+    index(mix, voice);
+    tally(mix, voice, 1);
+    detour(mix);
+}
+/**
+ * Counts a voice leaving the list back out. A voice naming no subject stays in `general` and
+ * `sharers`, which the caller filters once for every voice leaving together.
+ */
+export function delist(mix, voice) {
+    if (voice.named !== null)
+        unindex(mix, voice);
+    if (voice.holding !== null && mix.owners !== null)
+        mix.owners = mix.owners.filter((v) => v !== voice);
+    tally(mix, voice, -1);
+    detour(mix);
+}
+/** Counts the list over from nothing, for a seek or a projection's copy. `owners` is the caller's. */
+export function recount(mix) {
+    mix.named = new Store();
+    mix.naming = 0;
+    mix.general = [];
+    mix.sharers = [];
+    mix.loci = 0;
+    mix.anchored = 0;
+    for (const voice of mix.cued) {
+        index(mix, voice);
+        tally(mix, voice, 1);
+    }
+    detour(mix);
+    mix.steps.push(null, ++mix.version);
+}

package/dist/rotation.d.ts

@@ -0,0 +1,29 @@
+import { type Vec } from './channels.js';
+import type { Channel } from './types.js';
+/**
+ * What `angle` takes.
+ *
+ * @category channel
+ */
+export interface AngleOptions {
+    /** One full turn in the channel's unit. Default 360, for degrees; `2 * Math.PI` for radians. */
+    turn?: number;
+}
+/**
+ * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
+ * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
+ * either.
+ *
+ * @category channel
+ */
+export declare function angle(opts?: AngleOptions): Channel<number>;
+/**
+ * A rotation in space, as a unit quaternion `[x, y, z, w]`. Contributions compose by the Hamilton
+ * product in the order their voices were cued, which matters: rotations do not commute. A weight
+ * turns a contribution part of the way from no rotation, along the short arc, and `lerp` takes the
+ * short arc between two.
+ *
+ * @category channel
+ */
+export declare function quat(): Channel<Vec<4>>;

package/dist/rotation.js

@@ -0,0 +1,91 @@
+import { doubles, vouch } from './channels.js';
+import { shortWay } from './turns.js';
+/**
+ * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
+ * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
+ * either.
+ *
+ * @category channel
+ */
+export function angle(opts) {
+    const turn = opts?.turn ?? 360;
+    if (!(turn > 0))
+        throw new RangeError('blits: an angle takes a positive turn');
+    const channel = {
+        kind: `angle(${turn})`,
+        rest: 0,
+        merge: (a, b) => a + b,
+        scale: (v, w) => shortWay(v, turn) * w,
+        lerp: (a, b, u) => a + shortWay(b - a, turn) * u,
+    };
+    vouch(channel, { op: 'sum', axes: 1, turn });
+    return channel;
+}
+/** `a` then `b`, written into `out`, which may be either. */
+function multiply(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const bw = b[3];
+    out[0] = aw * bx + ax * bw + ay * bz - az * by;
+    out[1] = aw * by - ax * bz + ay * bw + az * bx;
+    out[2] = aw * bz + ax * by - ay * bx + az * bw;
+    out[3] = aw * bw - ax * bx - ay * by - az * bz;
+    return out;
+}
+/** The short arc from `a` to `b` at `u`, a unit quaternion, written into `out`. */
+function slerp(out, a, b, u) {
+    let dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+    // `q` and `-q` are one rotation; the nearer of the two is the short way.
+    const sign = dot < 0 ? -1 : 1;
+    dot *= sign;
+    let p = 1 - u;
+    let q = u;
+    // Nearly parallel, the arc's sine is too small to divide by, and a straight line is as good.
+    if (dot < 1 - 1e-9) {
+        const theta = Math.acos(dot);
+        const s = Math.sin(theta);
+        p = Math.sin((1 - u) * theta) / s;
+        q = Math.sin(u * theta) / s;
+    }
+    q *= sign;
+    const x = p * a[0] + q * b[0];
+    const y = p * a[1] + q * b[1];
+    const z = p * a[2] + q * b[2];
+    const w = p * a[3] + q * b[3];
+    const n = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+    out[0] = x / n;
+    out[1] = y / n;
+    out[2] = z / n;
+    out[3] = w / n;
+    return out;
+}
+const IDENTITY = [0, 0, 0, 1];
+const scratch = doubles(4, 0);
+/**
+ * A rotation in space, as a unit quaternion `[x, y, z, w]`. Contributions compose by the Hamilton
+ * product in the order their voices were cued, which matters: rotations do not commute. A weight
+ * turns a contribution part of the way from no rotation, along the short arc, and `lerp` takes the
+ * short arc between two.
+ *
+ * @category channel
+ */
+export function quat() {
+    const rest = doubles(4, 0);
+    rest[3] = 1;
+    const channel = {
+        kind: 'quat',
+        rest: rest,
+        merge: (a, b) => multiply(doubles(4, 0), a, b),
+        scale: (v, w) => slerp(doubles(4, 0), IDENTITY, v, w),
+        fold: (into, v, w) => multiply(into, into, slerp(scratch, IDENTITY, v, w)),
+        lerp: (a, b, u) => slerp(doubles(4, 0), a, b, u),
+    };
+    vouch(channel, { op: 'own', axes: 4 });
+    return channel;
+}

package/dist/rows.d.ts

@@ -15,19 +15,19 @@ export declare function sameCrowds<I, O>(lanes: Lanes<I, O>, members: readonly V
  */
 export declare function regroup<I, O>(lanes: Lanes<I, O>, members: Voice<I, O>[]): void;
 /**
- * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * Gives a voice the next row of its channels' crowd, made if there is none: a copy of the row it
  * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
- * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ * new crowd on the same channels keeps. Rows stay in voice order only because voices join in it.
  */
 export declare function join<I, O>(lanes: Lanes<I, O>, v: Voice<I, O>, from: Crowd<I, O> | undefined, at: number | undefined, old: readonly Crowd<I, O>[]): void;
 /** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
 export declare function retouchRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, v: Voice<I, O>): void;
 /**
- * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
- * crowd replacing a voice a frame carried as many empty rows as live ones.
+ * Compacts every crowd a quarter or more empty rows, past 64 of them: each fill walks every row,
+ * and at half a crowd replacing a voice a frame carried as many empty rows as live ones.
  */
 export declare function compactSparse<I, O>(lanes: Lanes<I, O>): void;
-/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+/** A crowd voice left: its row stays, empty, until the crowd is compacted or rebuilt. */
 export declare function bury<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number): void;
 /** A crowd row's weight as `reported` reads a lane position's. */
 export declare function reportedRow<I, O>(lanes: Lanes<I, O>, c: Crowd<I, O>, p: number, slot: number): number | undefined;

package/dist/rows.js

@@ -75,9 +75,9 @@ export function regroup(lanes, members) {
     }
 }
 /**
- * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * Gives a voice the next row of its channels' crowd, made if there is none: a copy of the row it
  * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
- * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ * new crowd on the same channels keeps. Rows stay in voice order only because voices join in it.
  */
 export function join(lanes, v, from, at, old) {
     const chans = v.slots.map((s) => lanes.bySlot[s]);
@@ -113,8 +113,8 @@ export function retouchRow(lanes, c, p, v) {
     c.hot[h + 0 /* Hot.FLAGS */] = c.hot[h + 0 /* Hot.FLAGS */] | 64 /* Flag.VOICE */;
 }
 /**
- * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
- * crowd replacing a voice a frame carried as many empty rows as live ones.
+ * Compacts every crowd a quarter or more empty rows, past 64 of them: each fill walks every row,
+ * and at half a crowd replacing a voice a frame carried as many empty rows as live ones.
  */
 export function compactSparse(lanes) {
     for (const c of lanes.crowds)
@@ -154,7 +154,7 @@ function compact(c) {
     c.laws.length = q;
     c.dead = 0;
 }
-/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+/** A crowd voice left: its row stays, empty, until the crowd is compacted or rebuilt. */
 export function bury(lanes, c, p) {
     const v = c.voices[p];
     leaveCrowd(lanes, c, p);

package/dist/sample.d.ts

@@ -11,9 +11,10 @@ export declare function runMotion<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, ru
  * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
  * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
  * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
- * this frame already read keeps the value it read, as the general path's record would.
+ * this frame already read keeps the value it read, as the general path's record would. The
+ * subject's voice time, delay and weight are in `Arg`.
  */
-export declare function move<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, run: Motions<I>, p: number, slot: number, held: Subject<unknown>, elapsed: number, delay: number, w: number): void;
+export declare function move<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, run: Motions<I>, p: number, slot: number, held: Subject<unknown>): void;
 /**
  * A probe this frame read a motion voice's value for the subject from an earlier fill: write onto
  * its record what the general path's sample would have, so a later read this frame reuses it.