@msb235/blits 0.14.0 → 0.15.1

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/restored.d.ts

@@ -1,7 +1,7 @@
+import type { Cut } from './cut.js';
 import type { Leavings } from './leavings.js';
 import { Store } from './store.js';
-import type { Cut } from './transport.js';
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /**
  * The seeks back after the one a record was last put back, written or deleted at, which every
  * record stamped then shares. The next seek fills it; a later seek to as early a moment joins it

package/dist/restored.js

@@ -138,7 +138,7 @@ export class Restored extends Store {
     }
     /** `get`, given what `own` holds for `key`. */
     from(key, own) {
-        const mark = own !== undefined && own.reaches;
+        const mark = own?.reaches;
         const at = (mark ? own.restored : this.at.get(key)) ?? this.first;
         const now = this.stamp;
         if (at === now)

package/dist/rests.d.ts

@@ -0,0 +1,9 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+export declare function atRest<I, O>(this: Mixer<I, O>, subject: I): boolean;
+export declare function rests<I, O>(this: Mixer<I, O>, pose: O): boolean;
+export declare function restful<I, O>(this: Mixer<I, O>): boolean;
+/** Whether a voice will change no pose from `now` on, short of a change made to it. */
+export declare function still<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): boolean;
+export declare function restsLaned<I, O>(this: Mixer<I, O>): boolean;
+export declare function restsKey<I, O>(this: Mixer<I, O>): number;

package/dist/rests.js

@@ -0,0 +1,76 @@
+import { near } from './fold.js';
+import { Store } from './store.js';
+export function atRest(subject) {
+    this.restStamps ??= new Store();
+    const head = this.linked(subject);
+    const laned = this.linkedLaned;
+    const lanes = this.lanes;
+    // Every voice on lanes and nothing to clamp: the pose a fold would make is the lanes' values.
+    if (laned && this.restsLaned()) {
+        const slot = head.slot;
+        if (!lanes.owes(slot))
+            return lanes.rests(slot);
+    }
+    // A probe this frame answers for the pose it gave the host.
+    const since = (this.restStamps.get(subject) ?? Number.NaN) - 2 * this.restsKey();
+    if (since >= 0)
+        return since === 1;
+    this.restScratch ??= this.pose();
+    const pose = this.foldWith(subject, this.restScratch, head, laned, true);
+    return this.rests((this.bounded.length === 0 ? pose : this.clamp(pose)));
+}
+export function rests(pose) {
+    for (let i = 0; i < this.names.length; i++) {
+        const channel = this.channels[i];
+        const value = pose[this.names[i]];
+        if (channel.rest === undefined) {
+            if (value !== undefined)
+                return false;
+        }
+        else if (!near(value, channel.rest))
+            return false;
+    }
+    return true;
+}
+export function restful() {
+    // Standing still, a voice changes no pose but by its weight signal, or by an anchor or start
+    // that host time may yet reach.
+    if (this.pace?.stopped(this.u))
+        return this.cued.every((v) => v.state === 'done' ||
+            (v.state !== 'pending' &&
+                typeof v.spec.weight !== 'function' &&
+                v.spec.anchor === undefined));
+    return this.cued.every((v) => this.still(v, this.now));
+}
+/** Whether a voice will change no pose from `now` on, short of a change made to it. */
+export function still(voice, now) {
+    if (voice.state === 'done')
+        return true;
+    if (voice.state !== 'frozen' && voice.state !== 'live')
+        return false;
+    if (typeof voice.spec.weight === 'function' || voice.parts !== null)
+        return false;
+    const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
+    if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
+        return false;
+    if (voice.state === 'frozen' || voice.holding !== null)
+        return true;
+    const motion = voice.motion;
+    return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
+}
+export function restsLaned() {
+    return this.lanes.whole && this.bounded.length === 0;
+}
+export function restsKey() {
+    if (this.frame !== this.restsFrame ||
+        this.version !== this.restsVersion ||
+        this.relinks !== this.restsRelinks ||
+        this.stirs !== this.restsStirs) {
+        this.restsEpoch++;
+        this.restsFrame = this.frame;
+        this.restsVersion = this.version;
+        this.restsRelinks = this.relinks;
+        this.restsStirs = this.stirs;
+    }
+    return this.restsEpoch;
+}

package/dist/revive.d.ts

@@ -1,10 +1,11 @@
 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 { Run } from './stretch.js';
+import type { Parted, Parting } from './subject.js';
 import type { Described } from './types.js';
-import { type Controls, type Parted, type Parting, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
 /** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
 interface PackedVoice {
     as: Described;

package/dist/revive.js

@@ -1,4 +1,4 @@
-import { playable } from './cue.js';
+import { playable, roleOf } from './cue.js';
 import { VoiceHandle } from './handle.js';
 import { handle } from './hosts.js';
 import { Leavings } from './leavings.js';
@@ -120,7 +120,7 @@ export function reviveVoice(mix, id, d) {
     const revive = mix.opts.history?.revive;
     if (revive === undefined)
         throw new Error('blits: a paged voice needs history.revive');
-    const spec = { ...revive(d.as), as: d.as };
+    const spec = roleOf(mix, { ...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.clocks = d.clocks;

package/dist/{locus.d.ts → role.d.ts}

@@ -1,11 +1,12 @@
 import type { Mixer } from './mixer.js';
-import type { Subject, Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
 /**
- * What a fold with a locus in play gathers, kept from one fold to the next: the contributions in
- * voice order, each a voice's own or a locus's first member; every locus member; and per channel
- * slot, a locus's folding value, the weight taken into it and the array it owns.
+ * What a fold with a role in play gathers, kept from one fold to the next: the contributions in
+ * voice order, each a voice's own or a role's first member; every role member; and per channel
+ * slot, a role's folding value, the weight taken into it and the array it owns.
  */
-export interface LocusScratch<I, O> {
+export interface RoleScratch<I, O> {
     n: number;
     voices: (Voice<I, O> | null)[];
     helds: (Subject<unknown> | null)[];
@@ -27,17 +28,17 @@ export interface LocusScratch<I, O> {
     touched: number[];
     owned: (number[] | undefined)[];
 }
-export declare function locusScratch<I, O>(channels: number): LocusScratch<I, O>;
+export declare function roleScratch<I, O>(channels: number): RoleScratch<I, O>;
 /**
  * `value` copied into the array `k` owns for the slot, as long as the channel's rest, where a
  * shorter value leaves the rest's own fill: what the channel's fold and lerp read past its end.
  */
-export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
+export declare function own<I, O>(k: RoleScratch<I, O>, slot: number, value: number[], rest: number[]): number[];
 /**
- * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
+ * Folds one role's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
  * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
-export declare function foldLocus<I, O>(this: Mixer<I, O>, k: LocusScratch<I, O>, group: number): number;
+export declare function foldRole<I, O>(this: Mixer<I, O>, k: RoleScratch<I, O>, group: number): number;

package/dist/{locus.js → role.js}

@@ -1,5 +1,5 @@
 import { first } from './clone.js';
-export function locusScratch(channels) {
+export function roleScratch(channels) {
     return {
         n: 0,
         voices: [],
@@ -36,13 +36,13 @@ export function own(k, slot, value, rest) {
     return out;
 }
 /**
- * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
+ * Folds one role's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
  * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
  * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
-export function foldLocus(k, group) {
+export function foldRole(k, group) {
     k.touched.length = 0;
     let sum = 0;
     for (let m = 0; m < k.m; m++)

package/dist/roles.d.ts

@@ -0,0 +1,10 @@
+import type { Mixer } from './mixer.js';
+import type { Subject } from './subject.js';
+import type { Voice } from './voice.js';
+/**
+ * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
+ * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
+ */
+export declare function chainFirst<I, O>(held: Subject<unknown> | null, sharers: readonly Voice<I, O>[], q: number): boolean;
+/** `foldWith`'s voices with a role in play: each role folds at its first member's place. */
+export declare function foldRoles<I, O>(this: Mixer<I, O>, subject: I, pose: Record<string, unknown>, head: Subject<unknown>, laned: boolean, dry: boolean, except: number | undefined, owed: number): O;

package/dist/roles.js

@@ -0,0 +1,158 @@
+import { first } from './clone.js';
+import { open as openRecord } from './everyone.js';
+import { merged, unband } from './fold.js';
+import { roleScratch } from './role.js';
+// V8 reads a local const as a constant, where it reads an import from its module on every call.
+const open = openRecord;
+/**
+ * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
+ * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
+ */
+export function chainFirst(held, sharers, q) {
+    if (held === null)
+        return false;
+    if (q >= sharers.length || held.voice === null)
+        return true;
+    const next = sharers[q];
+    return next.id > held.voice.id;
+}
+/** `foldWith`'s voices with a role in play: each role folds at its first member's place. */
+export function foldRoles(subject, pose, head, laned, dry, except, owed) {
+    const now = this.now;
+    // A patch reading the pose can fold again from inside this one, so each depth has its own.
+    let k = this.roleScratch[this.roleDepth];
+    if (k === undefined) {
+        k = roleScratch(this.channels.length);
+        this.roleScratch[this.roleDepth] = k;
+    }
+    this.roleDepth++;
+    try {
+        k.n = 0;
+        k.m = 0;
+        k.names.length = 0;
+        const sharers = this.sharers;
+        let q = 0;
+        let at = head;
+        while (at !== null || q < sharers.length) {
+            const mine = chainFirst(at, sharers, q);
+            let voice;
+            let rec;
+            if (mine) {
+                rec = at;
+                voice = rec.voice;
+                at = rec.next;
+            }
+            else {
+                voice = sharers[q++];
+                rec = voice.state === 'pending' ? null : voice.everyone;
+            }
+            if (voice === null || rec === null)
+                continue;
+            if (laned && voice.laned && !this.owedBy(owed, voice))
+                continue;
+            if (voice.id === except || voice.state === 'done')
+                continue;
+            const held = rec;
+            if (!mine)
+                open(voice, held, head.slot);
+            const delta = this.read(voice, subject, now, dry, held);
+            if (owed >= 0 && voice.laned)
+                this.lanes.paid(voice.id, owed, held.weight);
+            if (!mine)
+                q = this.shared(voice, head.slot, held, q);
+            if (delta === null)
+                continue;
+            const role = voice.spec.role;
+            let group = -1;
+            if (role !== undefined) {
+                group = k.names.indexOf(role);
+                const m = k.m++;
+                k.mVoices[m] = voice;
+                k.mDeltas[m] = delta;
+                k.mWeights[m] = this.w;
+                if (group >= 0) {
+                    k.mGroups[m] = group;
+                    continue;
+                }
+                group = k.names.length;
+                k.names.push(role);
+                k.mGroups[m] = group;
+            }
+            const n = k.n++;
+            k.voices[n] = voice;
+            k.helds[n] = held;
+            k.deltas[n] = delta;
+            k.weights[n] = role === undefined ? this.w : 0;
+            k.groups[n] = group;
+        }
+        let bands = head.roles;
+        if (bands === null) {
+            bands = new Map();
+            head.roles = bands;
+        }
+        for (let n = 0; n < k.n; n++) {
+            const group = k.groups[n];
+            if (group < 0) {
+                const weight = k.weights[n];
+                if (weight > 0)
+                    this.apply(pose, k.voices[n], k.helds[n], k.deltas[n], weight);
+                else
+                    unband(k.helds[n]);
+                continue;
+            }
+            const weight = this.foldRole(k, group);
+            const name = k.names[group];
+            if (!(weight > 0)) {
+                bands.get(name)?.fill(2);
+                continue;
+            }
+            let on = bands.get(name);
+            if (on === undefined) {
+                on = new Uint8Array(this.channels.length);
+                bands.set(name, on);
+            }
+            for (let t = 0; t < k.touched.length; t++) {
+                const slot = k.touched[t];
+                const value = k.values[slot];
+                k.values[slot] = undefined;
+                const key = this.names[slot];
+                const channel = this.channels[slot];
+                // A channel folds at the weight of the members that wrote it, not the whole role.
+                const taken = k.taken[slot];
+                const w = taken > 1 ? 1 : taken;
+                if (channel.rest !== undefined && channel.scale) {
+                    // pose[key] is the copy of rest this fold made, so it is ours to write into.
+                    pose[key] = channel.fold
+                        ? channel.fold(pose[key], value, w)
+                        : merged(channel, pose[key], channel.scale(value, w));
+                    continue;
+                }
+                const band = on[slot];
+                const passes = this.passes(band === 0 ? undefined : band === 1, w);
+                on[slot] = passes ? 1 : 2;
+                if (passes)
+                    pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
+            }
+        }
+        return pose;
+    }
+    finally {
+        for (let n = 0; n < k.n; n++) {
+            k.voices[n] = null;
+            k.helds[n] = null;
+            k.deltas[n] = null;
+        }
+        for (let m = 0; m < k.m; m++) {
+            k.mVoices[m] = null;
+            k.mDeltas[m] = null;
+        }
+        // Left set only where a channel's lerp threw partway, which the next fold must not inherit.
+        for (let t = 0; t < k.touched.length; t++) {
+            const slot = k.touched[t];
+            k.met[slot] = 0;
+            k.values[slot] = undefined;
+        }
+        k.touched.length = 0;
+        this.roleDepth--;
+    }
+}

package/dist/roster.js

@@ -2,8 +2,8 @@ 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.role !== undefined)
+        mix.roleVoices += by;
     const e = voice.spec.earliest;
     if (voice.spec.anchor !== undefined || (e !== undefined && typeof e !== 'number'))
         mix.anchored += by;
@@ -36,7 +36,7 @@ export function recount(mix) {
     mix.naming = 0;
     mix.general = [];
     mix.sharers = [];
-    mix.loci = 0;
+    mix.roleVoices = 0;
     mix.anchored = 0;
     for (const voice of mix.cued) {
         index(mix, voice);

package/dist/rotation.d.ts

@@ -10,7 +10,7 @@ export interface AngleOptions {
     turn?: number;
 }
 /**
- * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * A rotation about one axis that interpolates the short way round. It adds as `sum` does, and 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.

package/dist/rotation.js

@@ -1,7 +1,7 @@
 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
+ * A rotation about one axis that interpolates the short way round. It adds as `sum` does, and 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.

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)
@@ -25,7 +26,7 @@ export function unplace(lanes, c, p) {
     c.records[p] = undefined;
     c.deltas[p] = null;
     const f = p * c.stride + 0 /* Hot.FLAGS */;
-    c.hot[f] = c.hot[f] & ~16 /* Flag.PLACED */;
+    c.hot[f] = c.hot[f] & ~(16 /* Flag.PLACED */ | 2048 /* Flag.READY */);
     const o = p * 8 /* Row.STRIDE */;
     c.data[o + 4 /* Row.MSLOT */] = -1;
     c.data[o + 5 /* Row.SAMPLED */] = -1;
@@ -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/sample.d.ts

@@ -1,7 +1,7 @@
 import { type Lane, type Positions } from './lane.js';
 import type { Lanes } from './lanes.js';
-import type { Motions } from './motions.js';
-import type { Subject } from './voice.js';
+import { type Motions } from './motions.js';
+import type { Subject } from './subject.js';
 /**
  * A motion voice's fill: what `one` and `move` do for each subject, in one loop for the common
  * case, a subject not yet probed this frame with nothing pending, and through `move` for the rest.