@msb235/blits 0.14.0 → 0.15.1

package/dist/project.js

@@ -1,23 +1,20 @@
+import { copyAhead, mirror, playAhead, recordOf } from './ahead.js';
 import { ownBlends } from './blend.js';
-import { headOf, heldAt } from './chain.js';
+import { heldAt } from './chain.js';
 import { stepOf } from './clock.js';
-import { open, sighted, weightAt } from './everyone.js';
+import { within } from './cut.js';
 import { fadesAt } from './fade.js';
 import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
-import { markOf, voiceMarks } from './marks.js';
 import { Mixer } from './mixer.js';
-import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
-import { pin, place } from './place.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
 import { copyStanding, stands } from './standing.js';
-import { hostAhead, hostAt, replay } from './tape.js';
-import { Transport, within } from './transport.js';
+import { hostAhead, hostAt } from './tape.js';
+import { Transport } from './transport.js';
 import { cover, coverFrame } from './unpage.js';
-import { unreached } from './unreached.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
  * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
@@ -75,6 +72,7 @@ export function projectAll(transport, at) {
         }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
+        copy.places = mix.places;
         copies.set(mix, copy);
         if (ahead)
             copyAhead(mix, copy);
@@ -91,15 +89,18 @@ export function projectAll(transport, at) {
         earlier = new Map();
         stood = playAhead(transport, c, copies, t, earlier);
     }
+    const back = !ahead && kept ? cut : null;
     const read = (f) => {
         reading.live = false;
         reading.ahead = stood.ahead.size > 0 ? stood.ahead : null;
+        reading.back = back;
         try {
             return f();
         }
         finally {
             reading.live = true;
             reading.ahead = null;
+            reading.back = null;
         }
     };
     return {
@@ -136,168 +137,6 @@ export function projectAll(transport, at) {
         },
     };
 }
-/**
- * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
- * there makes them on the mixes. While a voice could carry state across it, it stops at each known
- * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
- * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
- * transport they stand on, and puts the tape back where it stood.
- */
-function playAhead(transport, c, copies, t, earlier) {
-    const tape = transport.tape;
-    const depth = tape?.undoDepth() ?? 0;
-    let played = false;
-    try {
-        for (;;) {
-            const e = nextEvent(tape, c, t);
-            if (!(e < t))
-                break;
-            played = playTo(transport, c, copies, e) || played;
-            if (!carries(c))
-                continue;
-            // Placed now, as the next move would place them, while a target that has just left is here.
-            for (const m of c.members)
-                if (m.anchored > 0)
-                    place(m);
-            const next = restage(c);
-            for (const [mix, copy] of copies) {
-                const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
-                on.slot = copy.slot;
-                on.projecting = true;
-                copyAhead(copy, on);
-                const stages = earlier.get(mix);
-                if (stages === undefined)
-                    earlier.set(mix, { at: [copy], met: new Set() });
-                else
-                    stages.at.push(copy);
-                copies.set(mix, on);
-            }
-            c = next;
-        }
-        played = playTo(transport, c, copies, t) || played;
-    }
-    finally {
-        if (played)
-            tape?.goto(depth);
-    }
-    return c;
-}
-/**
- * Whether a voice on a read ahead's copies could carry state from one known event to the next: a
- * patch that steps, or a weight given by a signal, which may keep state. Where none could, a read
- * crosses the events in one go, as fast as one with none.
- */
-function carries(c) {
-    for (const m of c.members)
-        for (const v of m.cued)
-            if (v.state !== 'done' && (v.patch.step !== undefined || typeof v.spec.weight === 'function'))
-                return true;
-    return false;
-}
-/**
- * The earliest known event a read ahead's copies have yet to reach before `t`, mix time: the next
- * call the tape holds, and while a voice could carry state across one, a mark of a voice or one
- * announced. Infinity where there is none.
- */
-function nextEvent(tape, c, t) {
-    const now = c.now;
-    let e = Number.POSITIVE_INFINITY;
-    const call = tape?.timestampAt(tape.undoDepth());
-    if (call !== undefined)
-        e = c.pace === null ? call : c.pace.reading(call);
-    if (!carries(c))
-        return e < t ? e : Number.POSITIVE_INFINITY;
-    for (const m of c.members)
-        for (const v of m.cued) {
-            if (v.state === 'done')
-                continue;
-            for (const mark of voiceMarks) {
-                const at = markOf(m, v, mark);
-                if (at !== undefined && at > now && at < e)
-                    e = at;
-            }
-            const inner = v.spec.marks;
-            if (inner !== undefined)
-                for (const mark of Object.keys(inner)) {
-                    const at = markOf(m, v, mark);
-                    if (at !== undefined && at > now && at < e)
-                        e = at;
-                }
-        }
-    for (const a of c.announced) {
-        const at = c.pace === null ? a.at : c.pace.at(a.at, c.u);
-        if (at > now && at < e)
-            e = at;
-    }
-    return e < t ? e : Number.POSITIVE_INFINITY;
-}
-/**
- * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
- * there. Answers whether it moved the tape.
- */
-function playTo(transport, c, copies, to) {
-    const tape = transport.tape;
-    const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
-    const next = tape?.timestampAt(tape.undoDepth());
-    c.u = hostAhead(c, to);
-    let played = false;
-    if (next !== undefined && due(next)) {
-        // A call may write what a copy shares with the voice it was copied from.
-        for (const copy of c.members)
-            for (const v of copy.cued) {
-                if (v.parts !== null)
-                    v.parts = new Map(v.parts);
-                if (v.parted !== null)
-                    v.parted = new Map(v.parted);
-            }
-        played = true;
-        const last = replay(transport, due, c, {
-            transport: () => c,
-            mix: (of) => copies.get(of),
-        });
-        c.u = Math.max(last, hostAhead(c, to));
-    }
-    // A call played at `to` itself moved the copies there before it, as a sync does.
-    if (!(c.now >= to))
-        for (const copy of c.members)
-            move(copy, to);
-    return played;
-}
-/** A transport for a read ahead's copies to go on from where those on `c` stand. */
-function restage(c) {
-    const next = new Transport(undefined, true);
-    next.offset = c.offset;
-    next.u = c.u;
-    next.nextId = c.nextId;
-    next.now = c.now;
-    next.pace = c.pace === null ? null : c.pace.until(Number.POSITIVE_INFINITY);
-    next.announced = c.announced.map((a) => ({ ...a }));
-    // The retargets and pushes the tape made carry their times, so every stop shares one list.
-    next.ahead = c.ahead;
-    return next;
-}
-/**
- * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
- * or from the copy at the known event before.
- */
-function copyAhead(mix, c) {
-    mirror(mix, c);
-    c.cued = mix.cued
-        .filter((v) => v.state !== 'done')
-        .map((v) => {
-        const copy = v.copy((subject) => carry(mix, v, subject, c, copy), undefined, true);
-        const at = mix.pins?.get(v);
-        if (at !== undefined)
-            pin(c, copy, at);
-        return copy;
-    });
-    c.waking = mix.waking;
-    ownBlends(c.cued);
-    // A copy keeps no list of owners, so the one before says only by its voices.
-    if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))
-        relink(c.cued);
-    recount(c);
-}
 /** A mix's copy for a read back to `t`, cut at `cut`: its voices then, from the controls and copies kept. */
 function copyBack(mix, c, t, cut) {
     mirror(mix, c);
@@ -352,48 +191,6 @@ export function stateAt(c, t) {
                     ? 'frozen'
                     : 'live';
 }
-/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
-export function mirror(mix, c) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
-}
-/** A voice's record of a subject, the one it shares among those it does not reach included. */
-function recordOf(mix, voice, subject) {
-    // A voice sharing one record has that for every subject a chain has asked it about, pointed at
-    // the subject for the caller to copy from.
-    if (voice.sharing) {
-        const slot = headOf(mix, subject)?.slot ?? -1;
-        if (!sighted(voice, slot))
-            return undefined;
-        const all = voice.everyone;
-        open(voice, all, slot);
-        all.weight = weightAt(voice, slot);
-        return all;
-    }
-    const held = voice.subjects.get(subject);
-    if (held !== undefined || voice.unreachedBits === null)
-        return held;
-    return unreached(voice, headOf(mix, subject)?.slot ?? -1)
-        ? voice.unreached
-        : undefined;
-}
-/**
- * A projection ahead starts each subject from where the live mix holds it, its `since` worked out
- * again where it was still ahead, since the copy's clock may have moved it.
- */
-function carry(mix, voice, subject, c, copy) {
-    const live = recordOf(mix, voice, subject);
-    if (live === undefined)
-        return undefined;
-    const h = copyHeld(voice, live);
-    if (h.reaches && !(h.since <= mix.now)) {
-        h.since = c.sinceOf(copy, h.delay);
-        h.shown = c.shownOf(copy, h.since);
-    }
-    h.from = h.stepped;
-    return h;
-}
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.

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. */
@@ -18,12 +19,10 @@ function writeValue(c, v, n) {
 }
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export function keep(subject, pose, out) {
-    // Keeping last frame's pose is free when the mix allocated it; a host sampling into its own
-    // object only pays for the copy once something in the mix has asked to retarget from it.
+    // A pose handed back without `out` is the host's to edit, so it is copied too. A host sampling
+    // into its own object only pays for the copy once something has asked to retarget from it.
     let kept;
-    if (out === undefined)
-        kept = pose;
-    else if (this.wantsPose) {
+    if (out === undefined || this.wantsPose) {
         kept = {};
         for (const key of this.names) {
             const v = pose[key];
@@ -32,9 +31,14 @@ export function keep(subject, pose, out) {
         }
     }
     if (kept !== undefined) {
-        const rec = this.pose.get(subject);
+        const rec = this.lastPoses.get(subject);
         if (rec === undefined)
-            this.pose.set(subject, { pose: kept, at: this.now, prev: undefined, prevAt: Number.NaN });
+            this.lastPoses.set(subject, {
+                pose: kept,
+                at: this.now,
+                prev: undefined,
+                prevAt: Number.NaN,
+            });
         else if (rec.at === this.now)
             rec.pose = kept;
         else {
@@ -50,7 +54,7 @@ export function pull(mix, subjects, into) {
     const lanes = mix.lanes;
     const now = mix.now;
     if (mix.scratch === undefined)
-        mix.scratch = {};
+        mix.scratch = mix.pose();
     let room = Number.POSITIVE_INFINITY;
     let tightest = '';
     for (const c of columns) {
@@ -149,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

@@ -5,8 +5,10 @@ import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
 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
@@ -57,21 +59,21 @@ export function requalify(lanes, version) {
         keepCallsOff(present, fits, host.channels);
     const candidates = () => present.map((v, i) => ({ id: v.id, fits: fits[i], slots: v.slots }));
     let { channels, voices } = qualify(numeric, candidates());
-    // A locus folds its members together, so they run on lanes all together or not at all.
+    // A role folds its members together, so they run on lanes all together or not at all.
     for (let split = true; split;) {
         split = false;
-        const loci = new Map();
+        const roles = new Map();
         present.forEach((v, i) => {
-            const name = v.spec.locus;
+            const name = v.spec.role;
             if (name === undefined)
                 return;
-            const at = loci.get(name);
+            const at = roles.get(name);
             if (at === undefined)
-                loci.set(name, [i]);
+                roles.set(name, [i]);
             else
                 at.push(i);
         });
-        for (const at of loci.values()) {
+        for (const at of roles.values()) {
             const on = at.filter((i) => voices.has(present[i].id)).length;
             if (on === 0 || on === at.length)
                 continue;
@@ -97,18 +99,18 @@ export function requalify(lanes, version) {
         const lane = lanes.byId.get(v.id) ?? new Lane(v);
         v.laned = true;
         if (lane.epoch === 0 && v.state !== 'pending')
-            lane.epoch = open(lanes, v);
+            opened(lanes, lane);
         kept.push(lane);
     }
     lanes.lanes = kept;
-    lanes.loci = [];
-    const loci = new Map();
+    lanes.roles = [];
+    const roles = new Map();
     for (const lane of kept) {
         lane.group = null;
-        const name = lane.voice.spec.locus;
+        const name = lane.voice.spec.role;
         if (name === undefined)
             continue;
-        let g = loci.get(name);
+        let g = roles.get(name);
         if (g === undefined) {
             g = {
                 members: [],
@@ -117,13 +119,17 @@ export function requalify(lanes, version) {
                 sum: new Float64Array(lanes.cap),
                 values: [],
                 taken: [],
+                contiguous: false,
+                inline: false,
             };
-            loci.set(name, g);
-            lanes.loci.push(g);
+            roles.set(name, g);
+            lanes.roles.push(g);
         }
         g.members.push(lane);
         lane.group = g;
     }
+    for (const [name, g] of roles)
+        g.contiguous = contiguous(present, voices, name, g.members);
     lanes.dense = kept
         .filter((l) => l.voice.named === null && l.epoch > 0)
         .sort((a, b) => a.epoch - b.epoch);
@@ -145,22 +151,22 @@ 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;
     }
     lanes.laned = [];
+    lanes.copier = null;
     lanes.bySlot = host.channels.map(() => undefined);
     channels.forEach((on, slot) => {
         if (!on)
@@ -170,10 +176,12 @@ export function requalify(lanes, version) {
         // A rest-less channel's values are NaN until some voice passes the band: absent from the pose.
         const rest = (channel.rest ?? Number.NaN);
         const scalar = typeof rest === 'number' && n.axes === 1;
+        const op = n.folds ?? n.op;
         const ch = {
             name: host.names[slot],
-            op: n.op,
-            plain: n.op !== 'last' && n.op !== 'own' && n.turn === undefined,
+            op,
+            plain: op !== 'last' && op !== 'own' && n.turn === undefined,
+            straight: n.folds === undefined,
             turn: n.turn ?? 0,
             channel,
             scalar,
@@ -263,7 +271,7 @@ export function open(lanes, v) {
         lanes.wide = epoch;
         return epoch;
     }
-    for (const subject of v.named) {
+    for (const subject of v.named.list) {
         const slot = lanes.host.slotOf(subject);
         if (slot < 0 || slot >= lanes.cap)
             continue;
@@ -298,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)
@@ -318,8 +325,8 @@ export function retouch(lanes) {
         }
         if (v.state === 'done')
             return qualify();
-        // A locus's members are on lanes together or not at all, so one joining may move the others.
-        if (v.spec.locus !== undefined)
+        // A role's members are on lanes together or not at all, so one joining may move the others.
+        if (v.spec.role !== undefined)
             return qualify();
         const laned = v.slots.some((slot) => lanes.bySlot[slot] !== undefined);
         const fits = v.slots.length > 0 && lanes.host.fits(v);
@@ -341,6 +348,46 @@ export function retouch(lanes) {
         lanes.subjects = [];
     return true;
 }
+/** A lane's voice started playing: its epoch, and room up front where it reaches every subject. */
+function opened(lanes, lane) {
+    const v = lane.voice;
+    lane.epoch = open(lanes, v);
+    if (v.named === null && v.spec.target === undefined) {
+        lane.reserve(lanes.live, lanes.cap);
+        if (placesAll(lanes, lane))
+            placeAll(lanes, lane);
+    }
+}
+/**
+ * Whether a lane just opened can take every numbered subject now, its first call or read for each
+ * made by the fill: a stateless fn or keys voice sharing one record, which every subject would meet
+ * at its next probe, in a host that probed every subject last frame. One by one, each probe would
+ * meet it and make its first call or read there (`foldNow` in `meet.ts`).
+ */
+function placesAll(lanes, lane) {
+    const v = lane.voice;
+    return (v.sharing &&
+        v.everyone !== null &&
+        lane.motion === undefined &&
+        !v.keeping &&
+        typeof v.spec.weight !== 'function' &&
+        lane.list.length === 0 &&
+        lanes.lastDistinct >= lanes.live);
+}
+/** Gives every numbered subject a position on a lane `placesAll` passed. */
+function placeAll(lanes, lane) {
+    const rec = lane.voice.everyone;
+    const numbers = lanes.numbers;
+    const size = Math.min(numbers.size, lanes.cap);
+    for (let slot = 0; slot < size; slot++) {
+        if (!numbers.has(slot))
+            continue;
+        lane.add(slot, rec);
+        if (lane.idle)
+            reach(lanes, slot, 1);
+    }
+    lane.every = true;
+}
 /**
  * A new voice that fits and writes only laned channels, and that no crowd takes, gets a lane at
  * the end of the order, its id being past every other: what a qualify would give it, since such a
@@ -350,7 +397,7 @@ function enlane(lanes, v) {
     const lane = new Lane(v);
     v.laned = true;
     if (v.state !== 'pending')
-        lane.epoch = open(lanes, v);
+        opened(lanes, lane);
     lane.chans = v.slots.map((s) => lanes.bySlot[s]);
     lane.values = lane.chans.map(() => undefined);
     lanes.lanes.push(lane);
@@ -360,13 +407,13 @@ function enlane(lanes, v) {
 }
 /**
  * A laned voice that started playing or finished, as a qualify would take it: a lane leaving
- * cannot lane or unlane another channel. False for a locus member, which a qualify must take.
+ * cannot lane or unlane another channel. False for a role member, which a qualify must take.
  */
 function relane(lanes, lane) {
     const v = lane.voice;
     if (v.state !== 'done') {
         if (lane.epoch === 0 && v.state !== 'pending') {
-            lane.epoch = open(lanes, v);
+            opened(lanes, lane);
             if (v.named === null)
                 lanes.dense.push(lane);
         }
@@ -410,3 +457,18 @@ function leave(lanes, lane) {
     }
     lane.voice.laned = false;
 }
+/**
+ * Whether a role's members, in the order lanes run, have no laned or crowded voice of another
+ * role or none between them, so its every subject folds at its first member's turn.
+ */
+function contiguous(present, voices, name, members) {
+    for (let i = 1; i < members.length; i++)
+        if (members[i].voice.id <= members[i - 1].voice.id)
+            return false;
+    const lo = members[0].voice.id;
+    const hi = members[members.length - 1].voice.id;
+    for (const v of present)
+        if (v.id > lo && v.id < hi && voices.has(v.id) && v.spec.role !== name)
+            return false;
+    return true;
+}

package/dist/reading.d.ts

@@ -1,3 +1,4 @@
+import type { Cut } from './cut.js';
 /**
  * Internal: what kind of read the mix is making right now, for patches that keep state of their own
  * outside the mix. Not exported from the package.
@@ -32,4 +33,9 @@ export declare const reading: {
      * commits none. Null for every other read.
      */
     ahead: Map<object, Map<unknown, unknown[]>> | null;
+    /**
+     * While a read back under history reads: the frame it reads, so a motion patch reads the run a
+     * subject had then and only the changes made by then. Null for every other read.
+     */
+    back: Cut | null;
 };

package/dist/reading.js

@@ -32,4 +32,9 @@ export const reading = {
      * commits none. Null for every other read.
      */
     ahead: null,
+    /**
+     * While a read back under history reads: the frame it reads, so a motion patch reads the run a
+     * subject had then and only the changes made by then. Null for every other read.
+     */
+    back: null,
 };

package/dist/record.d.ts

@@ -1,4 +1,8 @@
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
+/** Whether a record was left at rest during a handover. */
+export declare const isRested: (h: {
+    restedAt: number;
+}) => boolean;
 /** A record with every field written out, optional ones too, as every record in a mix is built. */
 export type WholeRecord = {
     [K in Field]: Subject<unknown>[K];

package/dist/record.js

@@ -1,3 +1,5 @@
+/** Whether a record was left at rest during a handover. */
+export const isRested = (h) => !Number.isNaN(h.restedAt);
 /**
  * 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
@@ -12,7 +14,6 @@ export function record(voice, reaches, state) {
         since: 0,
         shown: 0,
         weight: 0,
-        rested: false,
         restedAt: Number.NaN,
         bands: null,
         state,
@@ -37,7 +38,7 @@ export function record(voice, reaches, state) {
         voice,
         next: null,
         version: Number.NaN,
-        loci: null,
+        roles: null,
         slot: -1,
         run: -1,
         freed: -1,

package/dist/relink.d.ts

@@ -1,4 +1,4 @@
-import type { Subject } from './voice.js';
+import type { Subject } from './subject.js';
 /** What `patch` needs of a voice: its place in voice order. */
 interface Ordered {
     readonly id: number;

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;