@msb235/blits 0.15.0 → 0.15.1

package/dist/lanes.js

@@ -10,6 +10,7 @@ import { Placed } from './placed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
 import { reportedRow, unplace } from './rows.js';
+import { seatOf } from './seat.js';
 /**
  * The lanes of one mix: subject numbers, which channels and voices run on lanes, and the values a
  * frame's fill leaves for probes to copy.
@@ -24,7 +25,7 @@ export class Lanes {
     byId = new Map();
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
-    crowdOf = new Map();
+    seats = new Map();
     /** Which crowd voices' rows are placed on each subject. */
     placed = new Placed();
     /**
@@ -115,14 +116,16 @@ export class Lanes {
      */
     late = [];
     /**
-     * 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 = new Int32Array(0);
     queueRows = new Int32Array(0);
     queueCounts = new Int32Array(0);
     queued = 0;
     queuedFor = null;
+    queueFrom = null;
     keeps = false;
     now = Number.NaN;
     filledAt = Number.NaN;
@@ -233,10 +236,9 @@ export class Lanes {
             lane.remove(slot);
             return;
         }
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined && c.list[p] === slot)
-            unplace(this, c, p);
+        const s = this.seats.get(id);
+        if (s !== undefined && s.crowd.list[s.row] === slot)
+            unplace(this, s.crowd, s.row);
     }
     /** A voice brought a subject back: its next probe meets every lane again, as it met them first. */
     rejoin(slot) {
@@ -254,9 +256,8 @@ export class Lanes {
         const lane = this.byId.get(id);
         if (lane !== undefined)
             return this.reported(lane, slot);
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        return c === undefined || p === undefined ? undefined : reportedRow(this, c, p, slot);
+        const s = this.seats.get(id);
+        return s === undefined ? undefined : reportedRow(this, s.crowd, s.row, slot);
     }
     reported(lane, slot) {
         const o = slot * 6 /* Per.SLOT */;
@@ -439,10 +440,9 @@ export class Lanes {
             lane.remove(slot);
         const placed = this.placed;
         for (let id = placed.any(slot); id !== 0; id = placed.any(slot)) {
-            const c = this.crowdOf.get(id);
-            const p = c?.rowOf.get(id);
-            if (c !== undefined && p !== undefined && c.list[p] === slot)
-                unplace(this, c, p);
+            const s = this.seats.get(id);
+            if (s !== undefined && s.crowd.list[s.row] === slot)
+                unplace(this, s.crowd, s.row);
             else
                 placed.remove(slot, id);
         }
@@ -474,10 +474,10 @@ export class Lanes {
      * next fill, and a lane keeps the sample the old one gave.
      */
     stretchChanged(id, s) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined) {
-            c.restale(p, c.hot[p * c.stride + 0 /* Hot.FLAGS */]);
+        const seat = this.seats.get(id);
+        if (seat !== undefined) {
+            const c = seat.crowd;
+            c.restale(seat.row, c.hot[seat.row * c.stride + 0 /* Hot.FLAGS */]);
             return;
         }
         const lane = this.byId.get(id);
@@ -502,12 +502,11 @@ export class Lanes {
     }
     /** A voice's clock moved the `shown` of records it had already placed: copies them again. */
     reshown(id) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c !== undefined && p !== undefined) {
-            const held = c.records[p];
+        const s = this.seats.get(id);
+        if (s !== undefined) {
+            const held = s.crowd.records[s.row];
             if (held !== undefined)
-                c.data[p * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
+                s.crowd.data[s.row * 8 /* Row.STRIDE */ + 1 /* Row.SINCE */] = held.shown;
         }
         const lane = this.byId.get(id);
         if (lane === undefined)
@@ -519,12 +518,12 @@ export class Lanes {
         }
     }
     /** Something on a voice changed: a crowd copies it again at the next fill. */
-    voiceChanged(id) {
-        const c = this.crowdOf.get(id);
-        const p = c?.rowOf.get(id);
-        if (c === undefined || p === undefined)
+    voiceChanged(voice) {
+        const s = seatOf(this, voice);
+        if (s === null)
             return;
-        const f = p * c.stride + 0 /* Hot.FLAGS */;
+        const c = s.crowd;
+        const f = s.row * c.stride + 0 /* Hot.FLAGS */;
         c.hot[f] = c.hot[f] | 64 /* Flag.VOICE */;
     }
 }

package/dist/meet.js

@@ -1,4 +1,5 @@
 import { open, shut } from './everyone.js';
+import { seatOf } from './seat.js';
 /**
  * Whether the lanes a probe of the subject at `slot` just met (`met`) can be folded on the general
  * path after the lanes' values: none is in a role or a crowd, the subject owes none already this
@@ -183,10 +184,11 @@ function foldNow(lanes, slot, subject, again) {
 }
 /** Places a crowd voice's row on the subject a probe met, as `Lane.add` adds a position. */
 function place(lanes, voice, slot, subject, from, head) {
-    const c = lanes.crowdOf.get(voice.id);
-    const p = c?.rowOf.get(voice.id);
-    if (c === undefined || p === undefined)
+    const s = seatOf(lanes, voice);
+    if (s === null)
         return false;
+    const c = s.crowd;
+    const p = s.row;
     const h = p * c.stride;
     const flags = c.hot[h + 0 /* Hot.FLAGS */];
     if (c.hot[h + 6 /* Hot.EPOCH */] <= from || (flags & 16 /* Flag.PLACED */) !== 0)

package/dist/mixer.d.ts

@@ -32,7 +32,7 @@ import { Store } from './store.js';
 import type { MotionOwner } from './stretch.js';
 import type { Subject } from './subject.js';
 import { type Announced, Transport } from './transport.js';
-import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, VoiceSpec } from './types.js';
+import type { ArcHandle, ArcSpec, BlendMember, Booker, BookOptions, Channel, Columns, Engine, Handle, Kit, Marked, Mix, MixOptions, OwnerSpec, Patch, Projection, Sent, Signal, SpanHandle, SpanSpec, Tape, Trace, TraceOptions, VoiceSpec } from './types.js';
 import { type Voice } from './voice.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, primeLaned, weigh, weighOwned } from './weigh.js';
 /**
@@ -266,6 +266,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     project(at: number | {
         readonly frame: number;
     }): Projection<I, O>;
+    trace(from: number, to: number, opts?: TraceOptions): Trace<I, O>;
     announce(name: string, opts?: {
         at?: number;
         score?: string;

package/dist/mixer.js

@@ -33,6 +33,7 @@ import { Fitting, refit } from './spans.js';
 import { Store } from './store.js';
 import { record } from './tape.js';
 import { touch } from './touch.js';
+import { traceMix } from './trace.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
 import { gave, historyFor, register, unregister } from './watch.js';
@@ -435,6 +436,9 @@ export class Mixer {
     project(at) {
         return projectAll(this.transport, at).of(this);
     }
+    trace(from, to, opts) {
+        return traceMix(this, from, to, opts);
+    }
     announce(name, opts = {}) {
         this.attached();
         announce(this.transport, name, opts, this.slot, this.name);

package/dist/named.d.ts

@@ -5,7 +5,12 @@
 export declare class Named<I> {
     readonly list: readonly I[];
     private readonly set;
-    constructor(subjects: Iterable<I>);
+    /** Each subject's `stagger` answer, asked at cue; null for a voice with no stagger. */
+    readonly delays: Map<I, number> | null;
+    /** The longest of `delays`, 0 at least, and the least, 0 at most: a voice's bounds at cue. */
+    readonly latest: number;
+    readonly soonest: number;
+    constructor(subjects: Iterable<I>, stagger?: (subject: I) => number);
     get size(): number;
     has(subject: I): boolean;
 }

package/dist/named.js

@@ -7,11 +7,19 @@ const FEW = 8;
 export class Named {
     list;
     set;
-    constructor(subjects) {
+    /** Each subject's `stagger` answer, asked at cue; null for a voice with no stagger. */
+    delays = null;
+    /** The longest of `delays`, 0 at least, and the least, 0 at most: a voice's bounds at cue. */
+    latest = 0;
+    soonest = 0;
+    constructor(subjects, stagger) {
         // An array of distinct subjects, as nearly every voice names, is copied without iterating it.
         if (Array.isArray(subjects) && distinct(subjects)) {
             this.list = subjects.slice();
             this.set = null;
+            if (stagger)
+                this.delays = delaysOf(this.list, stagger);
+            [this.latest, this.soonest] = boundsOf(this.delays);
             return;
         }
         const list = [];
@@ -32,6 +40,9 @@ export class Named {
         // Exactly as long as it is: a list grown by push keeps room for 17.
         this.list = list.slice();
         this.set = set;
+        if (stagger)
+            this.delays = delaysOf(this.list, stagger);
+        [this.latest, this.soonest] = boundsOf(this.delays);
     }
     get size() {
         return this.list.length;
@@ -40,6 +51,23 @@ export class Named {
         return this.set === null ? this.list.includes(subject) : this.set.has(subject);
     }
 }
+function delaysOf(list, stagger) {
+    const delays = new Map();
+    for (const s of list)
+        delays.set(s, stagger(s));
+    return delays;
+}
+function boundsOf(delays) {
+    let latest = 0;
+    let soonest = 0;
+    for (const delay of delays?.values() ?? []) {
+        if (delay > latest)
+            latest = delay;
+        if (delay < soonest)
+            soonest = delay;
+    }
+    return [latest, soonest];
+}
 /** Whether a short array names no subject twice, as `includes` compares; a long one says no. */
 function distinct(subjects) {
     const n = subjects.length;

package/dist/numbers.d.ts

@@ -36,5 +36,10 @@ export declare class Numbers<I> {
     /** Whether `slot` is a number in use, its subject perhaps collected and not yet released. */
     has(slot: number): boolean;
     subject(slot: number): I | typeof absent;
+    /**
+     * Hands the subject numbered `from` the free number `to`, and frees `from` without telling the
+     * owner, whose stores the caller moves; false, changing nothing, where either does not hold.
+     */
+    move(from: number, to: number): boolean;
     release(slot: number): void;
 }

package/dist/numbers.js

@@ -82,6 +82,35 @@ export class Numbers {
         }
         return ref;
     }
+    /**
+     * Hands the subject numbered `from` the free number `to`, and frees `from` without telling the
+     * owner, whose stores the caller moves; false, changing nothing, where either does not hold.
+     */
+    move(from, to) {
+        const ref = this.refs[from];
+        const free = this.free;
+        if (ref === undefined || to >= this.next || this.refs[to] !== undefined || free === null)
+            return false;
+        const at = free.lastIndexOf(to);
+        if (at < 0)
+            return false;
+        if (ref instanceof WeakRef) {
+            const subject = ref.deref();
+            if (subject === undefined)
+                return false;
+            if (ref === this.lone)
+                this.loneSlot = to;
+            else if (this.registry !== null) {
+                this.registry.unregister(ref);
+                this.registry.register(subject, to, ref);
+            }
+        }
+        free.splice(at, 1);
+        free.push(from);
+        this.refs[to] = ref;
+        this.refs[from] = undefined;
+        return true;
+    }
     release(slot) {
         const ref = this.refs[slot];
         if (ref === undefined)

package/dist/pull.js

@@ -1,6 +1,7 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
 import { clampRun, flush, pullRun, writeLater } from './columns.js';
+import { renumber } from './renumber.js';
 /** What `pull` remembers at a position it has read no subject at. */
 const UNREAD = Symbol('unread');
 /** Writes a folded pose's value into subject `n`'s places in a column. */
@@ -152,12 +153,21 @@ function readAll(mix, list, columns, live, current, since, whole) {
                 was[n] = subject;
                 heads[n] = head;
                 slot = head.slot;
+                // Numbered out of the list's order, as swap-remove leaves a subject: renumbered into it.
+                const to = n === 0 ? 0 : slots[n - 1] + 1;
+                if (runs && slot >= 0 && slot !== to && to >= 0) {
+                    if (renumber(mix, subject, head, to)) {
+                        for (let j = was.indexOf(subject); j >= 0; j = was.indexOf(subject, j + 1))
+                            slots[j] = to;
+                        slot = to;
+                    }
+                }
                 slots[n] = slot;
             }
         }
         const laned = live && lanes?.prepare(slot, subject, mix.version, heads[n] ?? null) === true;
         if (laned && whole && lanes.whole && !lanes.owes(slot)) {
-            writeLater(lanes, slot, columns, n);
+            writeLater(lanes, slot, columns, n, slots);
             continue;
         }
         const head = live ? heads[n] : null;

package/dist/qualify.js

@@ -8,6 +8,7 @@ import { Lane } from './lane.js';
 import { reach } from './meet.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';
 import { settle } from './sample.js';
+import { seated, seatOf } from './seat.js';
 /**
  * Which channels run as lanes and which voices run on them: the fixed point where every voice
  * writing a laned channel fits and writes only laned channels. Only channels some laned voice
@@ -150,17 +151,16 @@ export function requalify(lanes, version) {
         for (const c of lanes.crowds)
             for (let p = 0; p < c.size; p++) {
                 const v = c.voices[p];
-                if (c.rowOf.get(v.id) === p && v.state === 'done')
+                if (seated(lanes, v, c, p) && v.state === 'done')
                     bury(lanes, c, p);
             }
         // A crowd voice that started or began fading takes it up on its row, as `retouch` does.
         for (const v of touched) {
             if (v.state === 'done')
                 continue;
-            const c = lanes.crowdOf.get(v.id);
-            const p = c?.rowOf.get(v.id);
-            if (c !== undefined && p !== undefined)
-                retouchRow(lanes, c, p, v);
+            const s = seatOf(lanes, v);
+            if (s !== null)
+                retouchRow(lanes, s.crowd, s.row, v);
         }
         compactSparse(lanes);
         return;
@@ -306,14 +306,13 @@ export function retouch(lanes) {
         const known = v.id <= lanes.known;
         if (v.id > lanes.known)
             lanes.known = v.id;
-        const c = lanes.crowdOf.get(v.id);
-        const p = c?.rowOf.get(v.id);
-        if (c !== undefined && p !== undefined) {
+        const s = seatOf(lanes, v);
+        if (s !== null) {
             if (v.state === 'done') {
-                bury(lanes, c, p);
+                bury(lanes, s.crowd, s.row);
                 continue;
             }
-            retouchRow(lanes, c, p, v);
+            retouchRow(lanes, s.crowd, s.row, v);
             continue;
         }
         if (v.state === 'done' && !known)

package/dist/renumber.d.ts

@@ -0,0 +1,10 @@
+import type { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+/**
+ * Gives a subject the free number `to` in place of its own, carrying everything kept under the old
+ * one, so `pull` can keep a list's numbers in its order: a list kept dense by swap-remove moves its
+ * last subject into the place a dropped one left, whose number the drop just freed. Says whether it
+ * did; it does not where some store it would have to carry is in use: while a fill runs, under
+ * history, in a read ahead, or with roles, a bound or anything owed on the lanes.
+ */
+export declare function renumber<I, O>(mix: Mixer<I, O>, subject: I, head: Subject<unknown>, to: number): boolean;

package/dist/renumber.js

@@ -0,0 +1,75 @@
+import { resight } from './everyone.js';
+import { goneIndex } from './gone.js';
+import { reunreach } from './unreached.js';
+/**
+ * Gives a subject the free number `to` in place of its own, carrying everything kept under the old
+ * one, so `pull` can keep a list's numbers in its order: a list kept dense by swap-remove moves its
+ * last subject into the place a dropped one left, whose number the drop just freed. Says whether it
+ * did; it does not where some store it would have to carry is in use: while a fill runs, under
+ * history, in a read ahead, or with roles, a bound or anything owed on the lanes.
+ */
+export function renumber(mix, subject, head, to) {
+    const lanes = mix.lanes;
+    const from = head.slot;
+    if (from < 0 ||
+        lanes.filling ||
+        lanes.host.keeps ||
+        mix.projecting ||
+        lanes.roles.length > 0 ||
+        lanes.owed.any() ||
+        lanes.lanes.some((lane) => lane.voice.bound !== null) ||
+        !lanes.numbers.move(from, to))
+        return false;
+    for (const lane of lanes.lanes)
+        lane.renumber(from, to);
+    const placed = lanes.placed;
+    for (const id of placed.all(from)) {
+        placed.remove(from, id);
+        const s = lanes.seats.get(id);
+        if (s === undefined || s.crowd.list[s.row] !== from)
+            continue;
+        s.crowd.list[s.row] = to;
+        placed.add(to, id);
+    }
+    const per = lanes.per;
+    per.copyWithin(to * 6 /* Per.SLOT */, from * 6 /* Per.SLOT */, (from + 1) * 6 /* Per.SLOT */);
+    per[from * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = lanes.fills;
+    lanes.unlinked[to] = lanes.unlinked[from];
+    lanes.subjects[to] = lanes.subjects[from];
+    lanes.subjects[from] = undefined;
+    for (const ch of lanes.laned)
+        ch.values.copyWithin(to * ch.axes, from * ch.axes, (from + 1) * ch.axes);
+    mix.places?.forgot(from);
+    mix.places?.number(subject, to);
+    const cap = lanes.cap;
+    for (const voice of mix.general) {
+        reunreach(voice, from, to);
+        resight(voice, from, to, cap);
+        reblend(mix, voice, from, to);
+    }
+    for (const voice of goneIndex(mix).general)
+        reunreach(voice, from, to);
+    for (let held = head; held !== null; held = held.next)
+        if (held.voice !== null)
+            reblend(mix, held.voice, from, to);
+    head.slot = to;
+    return true;
+}
+/** Moves a blend's read for the subject this frame, if it has made one, to its new number. */
+function reblend(mix, voice, from, to) {
+    const of = voice.blend?.of;
+    if (of === undefined || from >= of.frames.length || of.frames[from] !== mix.frame)
+        return;
+    if (to >= of.frames.length) {
+        const size = Math.max(to + 1, of.frames.length * 2, 64);
+        const frames = new Float64Array(size);
+        const values = new Float64Array(size);
+        frames.set(of.frames);
+        values.set(of.values);
+        of.frames = frames;
+        of.values = values;
+    }
+    of.frames[to] = mix.frame;
+    of.values[to] = of.values[from];
+    of.frames[from] = Number.NaN;
+}

package/dist/rows.js

@@ -4,6 +4,7 @@ import { reach } from './meet.js';
 import { motionOf } from './motion.js';
 import { open } from './qualify.js';
 import { settle } from './sample.js';
+import { Seat, seatOf } from './seat.js';
 /** Whether two crowds' channels are the same list. */
 function same(a, b) {
     if (a.length !== b.length)
@@ -38,14 +39,13 @@ export function unplace(lanes, c, p) {
 export function sameCrowds(lanes, members) {
     let live = 0;
     for (const v of members) {
-        if (!lanes.crowdOf.has(v.id))
+        if (!lanes.seats.has(v.id))
             return false;
         live++;
     }
     let rows = 0;
-    for (const [id, c] of lanes.crowdOf) {
-        const p = c.rowOf.get(id);
-        if (c.voices[p].state !== 'done')
+    for (const s of lanes.seats.values()) {
+        if (s.crowd.voices[s.row].state !== 'done')
             rows++;
     }
     return rows === live;
@@ -64,13 +64,15 @@ export function regroup(lanes, members) {
                 leaveCrowd(lanes, c, p);
         }
     const old = lanes.crowds;
-    const was = new Map(lanes.crowdOf);
+    const was = new Map(lanes.seats);
+    for (const s of was.values())
+        s.lanes = null;
     lanes.crowds = [];
-    lanes.crowdOf.clear();
+    lanes.seats.clear();
     lanes.overlap = false;
     for (const v of members) {
         const from = was.get(v.id);
-        join(lanes, v, from, from?.rowOf.get(v.id), old);
+        join(lanes, v, from?.crowd, from?.row, old);
     }
     if (lanes.crowds.length === 0) {
         lanes.lawsByKey.clear();
@@ -104,8 +106,9 @@ export function join(lanes, v, from, at, old) {
         newRow(lanes, c, p, v);
     if (c.hot[p * c.stride + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
         c.hot[p * c.stride + 6 /* Hot.EPOCH */] = open(lanes, v);
-    c.rowOf.set(v.id, p);
-    lanes.crowdOf.set(v.id, c);
+    const seat = new Seat(lanes, c, p);
+    lanes.seats.set(v.id, seat);
+    v.seat = seat;
     v.laned = true;
 }
 /** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
@@ -122,27 +125,28 @@ export function retouchRow(lanes, c, p, v) {
 export function compactSparse(lanes) {
     for (const c of lanes.crowds)
         if (c.dead > 64 && c.dead * 4 >= c.size)
-            compact(c);
+            compact(lanes, c);
 }
 /**
  * Slides a crowd's rows down over the empty ones its departed voices left, in order, so its rows
  * stay in voice order; a qualify did this by rebuilding every crowd, a dropped frame at 10k rows.
  */
-function compact(c) {
+function compact(lanes, c) {
     // The rows' stops are copied into a fresh pool, leaving the departed rows' behind.
     const keys = c.keys;
     c.keys = new KeyRows();
     let q = 0;
     for (let p = 0; p < c.size; p++) {
         const v = c.voices[p];
-        if (c.rowOf.get(v.id) !== p) {
+        const s = seatOf(lanes, v);
+        if (s === null || s.crowd !== c || s.row !== p) {
             c.odd?.delete(p);
             continue;
         }
         if (q !== p) {
             copyRow(c, p, c, q, keys);
             c.odd?.delete(p);
-            c.rowOf.set(v.id, q);
+            s.row = q;
         }
         else
             copyKeys(keys, c, q);
@@ -166,8 +170,12 @@ export function bury(lanes, c, p) {
     c.deltas[p] = null;
     c.motions[p] = undefined;
     c.hot[p * c.stride + 0 /* Hot.FLAGS */] = 0;
-    c.rowOf.delete(v.id);
-    lanes.crowdOf.delete(v.id);
+    lanes.seats.delete(v.id);
+    const s = v.seat;
+    if (s !== null && s.lanes === lanes) {
+        s.lanes = null;
+        v.seat = null;
+    }
     c.dead++;
 }
 /** Copies `n` numbers of a row; a view of them to hand `set` was three objects a row moved. */
@@ -202,7 +210,7 @@ function copyRow(from, p, to, q, keys = from.keys) {
 function copyKeys(keys, c, q) {
     const h = q * c.stride;
     if ((c.hot[h + 0 /* Hot.FLAGS */] & 512 /* Flag.FLAT */) !== 0)
-        c.hot[h + 8 /* Hot.AT */] = c.keys.copy(keys, c.hot[h + 8 /* Hot.AT */]);
+        c.hot[h + 9 /* Hot.AT */] = c.keys.copy(keys, c.hot[h + 9 /* Hot.AT */]);
 }
 function newRow(lanes, c, p, v) {
     const run = motionOf(v.patch);
@@ -210,9 +218,9 @@ function newRow(lanes, c, p, v) {
     c.hot.fill(0, h, h + c.stride);
     const at = v.built === null ? -1 : c.keys.add(v.built, c.chans);
     if (at >= 0) {
-        c.hot[h + 8 /* Hot.AT */] = at;
-        c.hot[h + 10 /* Hot.X0 */] = v.duration;
-        c.hot[h + 9 /* Hot.MS */] = v.passes;
+        c.hot[h + 9 /* Hot.AT */] = at;
+        c.hot[h + 11 /* Hot.X0 */] = v.duration;
+        c.hot[h + 10 /* Hot.MS */] = v.passes;
     }
     c.restale(p, 64 /* Flag.VOICE */ |
         (run === undefined ? 0 : 128 /* Flag.MOTION */) |

package/dist/seat.d.ts

@@ -0,0 +1,17 @@
+import type { Crowd } from './crowd.js';
+import type { Voice } from './voice.js';
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export declare class Seat<I, O> {
+    lanes: object | null;
+    readonly crowd: Crowd<I, O>;
+    row: number;
+    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number);
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export declare function seatOf<I, O>(lanes: object, voice: Voice<I, O>): Seat<I, O> | null;
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export declare function seated<I, O>(lanes: object, voice: Voice<I, O>, c: Crowd<I, O>, p: number): boolean;

package/dist/seat.js

@@ -0,0 +1,25 @@
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export class Seat {
+    lanes;
+    crowd;
+    row;
+    constructor(lanes, crowd, row) {
+        this.lanes = lanes;
+        this.crowd = crowd;
+        this.row = row;
+    }
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export function seatOf(lanes, voice) {
+    const s = voice.seat;
+    return s !== null && s.lanes === lanes ? s : null;
+}
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export function seated(lanes, voice, c, p) {
+    const s = seatOf(lanes, voice);
+    return s !== null && s.crowd === c && s.row === p;
+}

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.15.0";
+export declare const release = "0.15.1";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.15.0';
+export const release = '0.15.1';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when