@msb235/blits 0.15.0 → 0.16.0

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';
@@ -234,6 +235,8 @@ export class Mixer {
     roleDepth = 0;
     slotOf = new Map();
     lanes;
+    /** The sharing hooks of the lanes this entry was built with, which a projection's copy keeps. */
+    share;
     handles = null;
     /** What `book` made, still booking; null while there is none. */
     bookers = null;
@@ -265,6 +268,7 @@ export class Mixer {
         });
         if (lanesOf === null && opts.lanes === true)
             throw new Error("blits: '@msb235/blits/lean' has no lanes; take mix from '@msb235/blits'");
+        this.share = lanesOf?.share ?? null;
         this.lanes =
             lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
@@ -435,6 +439,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/motions.d.ts

@@ -64,11 +64,14 @@ export declare class Motions<I> {
     /** Whether the channel it was cued on holds a number; undefined until it is cued. */
     private holdsNumber;
     private channel;
+    /** Whether the channel it was cued on travels round the hue, as `ink` does, and its stretches too. */
+    round: boolean;
     /**
      * Records what the channel the patch is cued on holds, refusing a value of the other kind: at once
      * where every subject's value is one kind, else on the first sample of a subject whose value is not.
+     * `round` for a channel that travels round the hue, as `ink` does.
      */
-    cuedOn(channel: string, holdsNumber: boolean): void;
+    cuedOn(channel: string, holdsNumber: boolean, round?: boolean): void;
     frame(subject: I): number;
     constructor(shape: Shape<I>);
     /** The patch's number for `subject`, made with its first stretch on first ask. */

package/dist/motions.js

@@ -1,5 +1,6 @@
 import { applied, change, commit, cut, dueTo, insert, peek, queue, rewind } from './changes.js';
-import { closed } from './closed.js';
+import { BOUND, closed } from './closed.js';
+import { closedLch } from './lch.js';
 import { made, pack, prune, reclaim, release, restretch, runAt, runThen, unpack, unrelease, } from './lives.js';
 import { absent, Numbers } from './numbers.js';
 import { reading } from './reading.js';
@@ -16,6 +17,7 @@ const PENDING = 2 /* RunFlag.PENDING */;
 const OLDER = 4 /* RunFlag.OLDER */;
 const LANDED = 8 /* RunFlag.LANDED */;
 const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel} holds ${holdsNumber ? 'a number' : 'an array'}, and this motion patch gives a subject ${holdsNumber ? 'an array' : 'a number'}`);
+const notOklab = (channel) => new Error(`blits: channel ${channel} goes round the hue, and a motion on it moves oklab() values, four numbers each`);
 /**
  * A motion patch's subjects: the stretch each is playing, in one flat array by a number the patch
  * gives it, with earlier stretches a read back may reach and changes not yet applied beside them.
@@ -68,11 +70,18 @@ export class Motions {
     /** Whether the channel it was cued on holds a number; undefined until it is cued. */
     holdsNumber = undefined;
     channel = '';
+    /** Whether the channel it was cued on travels round the hue, as `ink` does, and its stretches too. */
+    round = false;
     /**
      * Records what the channel the patch is cued on holds, refusing a value of the other kind: at once
      * where every subject's value is one kind, else on the first sample of a subject whose value is not.
+     * `round` for a channel that travels round the hue, as `ink` does.
      */
-    cuedOn(channel, holdsNumber) {
+    cuedOn(channel, holdsNumber, round = false) {
+        if (round && this.shape.law[0] === BOUND)
+            throw new Error(`blits: channel ${channel} goes round the hue, and a glide's bounds are a box on its OKLab axes; glide it without bounds`);
+        if (round && this.n >= 0 && this.n !== 4)
+            throw notOklab(channel);
         const every = this.shape.scalarEvery();
         if (every !== undefined && every !== holdsNumber)
             throw wrongKind(channel, holdsNumber);
@@ -82,6 +91,7 @@ export class Motions {
                 throw wrongKind(channel, holdsNumber);
         this.holdsNumber = holdsNumber;
         this.channel = channel;
+        this.round = round;
     }
     frame(subject) {
         return this.owner === null ? Number.NaN : this.owner.frame(this.ownerId, subject);
@@ -127,6 +137,8 @@ export class Motions {
     }
     /** Sets the axes every subject moves on, at the first. */
     size(n) {
+        if (this.round && n !== 4)
+            throw notOklab(this.channel);
         this.n = n;
         this.stride = 3 + 3 * n;
         if (shared.xs.length < n)
@@ -426,6 +438,8 @@ export class Motions {
         this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
     }
     evaluate(at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+        if (this.round)
+            return closedLch(this.runs, this.shape.ease, at, ms, x0, x, v0, v, to, g, t, xo, vo);
         return closed(this.runs, this.shape.ease, this.n, at, ms, x0, x, v0, v, to, g, t, xo, vo);
     }
 }

package/dist/move.js

@@ -2,16 +2,15 @@ import { settleArcs } from './arcs.js';
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
 import { byId, popDue, schedule } from './due.js';
-import { detour, outgrow } from './everyone.js';
-import { beginFade, part, retire } from './fade.js';
+import { beginFade, part, retire, rouse, stay } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
 import { begin } from './held.js';
 import { noted } from './history.js';
 import { leave as leaveClock } from './origin.js';
-import { ownerReading } from './owner.js';
+import { ownerReading, plays } from './owner.js';
 import { mixAt, place, repin, startAt, startOf } from './place.js';
 import { pageVoice } from './revive.js';
-import { delist } from './roster.js';
+import { delist, detour } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
 import { lapse } from './spans.js';
 import { unplay } from './strays.js';
@@ -80,6 +79,8 @@ function moveTo(mix, now) {
         if (voice.state !== 'pending') {
             if (voice.turns)
                 turn(mix, voice, now);
+            if (voice.state === 'live' && voice.out !== null && !voice.quietAt(now))
+                rouse(mix, voice, now);
             // Its passes run out at its end running forward, and at its start running back. A clock
             // standing still at or before its start is where it was: waiting, or frozen there.
             const way = heading(voice, now);
@@ -87,7 +88,7 @@ function moveTo(mix, now) {
             const back = way < 0;
             const atStart = !voice.beginless && at <= voice.soonest;
             // An owner run back to its start stays for what it holds, and leaves with its last child.
-            const holds = voice.holding !== null && voice.holding.children.length > 0;
+            const holds = voice.holding !== null && plays(voice, now);
             const over = back
                 ? atStart && !holds
                 : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
@@ -95,11 +96,11 @@ function moveTo(mix, now) {
                 voice.play(true, now, mix.transport.seq);
                 // The fade starts when its passes ran out, not at the frame that noticed, so it plays
                 // the same at any frame rate and a read at another time can find it.
-                if (voice.state === 'live') {
+                if (voice.state === 'live' && voice.out === null) {
                     if (back ? voice.freezesBefore : voice.freezesAfter)
                         voice.state = 'frozen';
                     else
-                        beginFade(mix, voice, { back }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
+                        beginFade(mix, voice, { back, stays: voice.owner !== null && mix.opts.history !== undefined }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
                 }
             }
             else if (voice.state === 'frozen' && !(atStart && way === 0))
@@ -126,8 +127,12 @@ function moveTo(mix, now) {
                 else if (settled)
                     retire(mix, voice);
             }
-            else if (spent >= over)
-                retire(mix, voice, at + over);
+            else if (spent >= over) {
+                if (voice.out.stays)
+                    stay(mix, voice, at + over);
+                else
+                    retire(mix, voice, at + over);
+            }
         }
         if (!mix.projecting)
             schedule(mix, voice);
@@ -137,7 +142,7 @@ function moveTo(mix, now) {
         settleArcs(mix, now);
     }
     if (mix.sharers.length > 0 && !mix.projecting)
-        outgrow(mix);
+        mix.share?.outgrow(mix);
     mix.stirred = false;
     mix.asleep = false;
     if (mix.retired.length > 0)

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

@@ -36,8 +36,13 @@ export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
 export declare function turnedBack<I, O>(voice: Voice<I, O>): boolean;
 /** Takes a child into its owner. */
 export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): void;
-/** A child left: its owner, where that was its last child and it should leave too. */
-export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export declare function orphan<I, O>(child: Voice<I, O>, now: number): Voice<I, O> | null;
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export declare function plays<I, O>(owner: Voice<I, O>, now: number): boolean;
 /** A child finished its passes: its owner has played once every child it held has. */
 export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number, seq: number): void;
 /** Every voice an owner holds, its children's children included. */

package/dist/owner.js

@@ -76,14 +76,24 @@ export function adopt(owner, child) {
     h.children.push(child);
     h.kids++;
 }
-/** A child left: its owner, where that was its last child and it should leave too. */
-export function orphan(child) {
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export function orphan(child, now) {
     const owner = child.owner;
     const h = owner.holding;
     const i = h.children.indexOf(child);
     if (i >= 0)
         h.children.splice(i, 1);
-    return h.children.length === 0 && owner.state !== 'done' ? owner : null;
+    return !plays(owner, now) && owner.state !== 'done' ? owner : null;
+}
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export function plays(owner, now) {
+    for (const child of owner.holding.children)
+        if (!child.quietAt(now))
+            return true;
+    return false;
 }
 /** A child finished its passes: its owner has played once every child it held has. */
 export function childPlayed(owner, at, seq) {

package/dist/project.js

@@ -7,7 +7,7 @@ import { fadesAt } from './fade.js';
 import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
 import { Mixer } from './mixer.js';
-import { heldByInput, ownerReading, relink } from './owner.js';
+import { heldByInput, relink } from './owner.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
@@ -72,6 +72,7 @@ export function projectAll(transport, at) {
         }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
+        copy.share = mix.share;
         copy.places = mix.places;
         copies.set(mix, copy);
         if (ahead)
@@ -183,13 +184,7 @@ function copyBack(mix, c, t, cut) {
 /** Sets each copied voice's state to what its clock and fade make it at `t`. */
 export function stateAt(c, t) {
     for (const copy of c.cued)
-        copy.state = copy.out
-            ? 'fading'
-            : (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
-                ? 'pending'
-                : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                    ? 'frozen'
-                    : 'live';
+        copy.state = copy.stateAt(t);
 }
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its

package/dist/pull.d.ts

@@ -1,5 +1,16 @@
 import type { Mixer } from './mixer.js';
 import type { Columns } from './types.js';
+/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
+export interface Column {
+    key: string;
+    slot: number;
+    axes: number;
+    out: Float64Array;
+    /** The rest, clamped, or NaN for a channel with none. */
+    rest: Float64Array;
+    bounds: readonly [number, number] | undefined;
+}
+export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
 export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;

package/dist/pull.js

@@ -1,8 +1,13 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
-import { clampRun, flush, pullRun, writeLater } from './columns.js';
 /** What `pull` remembers at a position it has read no subject at. */
 const UNREAD = Symbol('unread');
+export function clampRun(out, at, n, [lo, hi]) {
+    for (let i = at; i < at + n; i++) {
+        const x = out[i];
+        out[i] = x < lo ? lo : x > hi ? hi : x;
+    }
+}
 /** Writes a folded pose's value into subject `n`'s places in a column. */
 function writeValue(c, v, n) {
     const at = n * c.axes;
@@ -111,7 +116,7 @@ export function pull(mix, subjects, into) {
     }
     finally {
         if (lanes !== null)
-            flush(lanes);
+            lanes.pulls.flush(lanes);
     }
     // Every head is current only if nothing relinked or changed version while they were read.
     const unchanged = live && mix.version === version && mix.relinks === relinks;
@@ -135,7 +140,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
     const runs = live && whole;
     for (let n = 0; n < list.length; n++) {
         if (runs) {
-            n = pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
+            n = lanes.pulls.pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
             if (n === list.length)
                 break;
         }
@@ -152,12 +157,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 (lanes.pulls.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);
+            lanes.pulls.writeLater(lanes, slot, columns, n, slots);
             continue;
         }
         const head = live ? heads[n] : null;

package/dist/qualify.js

@@ -1,13 +1,14 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
-import { crowdable } from './crowd.js';
 import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
+import { crowdable } from './hosts.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
@@ -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/roles.js

@@ -1,9 +1,7 @@
 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.
@@ -54,7 +52,7 @@ export function foldRoles(subject, pose, head, laned, dry, except, owed) {
                 continue;
             const held = rec;
             if (!mine)
-                open(voice, held, head.slot);
+                this.share.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);

package/dist/roster.d.ts

@@ -1,5 +1,11 @@
 import type { Mixer } from './mixer.js';
 import type { Voice } from './voice.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** 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;
 /**

package/dist/roster.js

@@ -1,6 +1,13 @@
 import { index, unindex } from './chain.js';
-import { detour } from './everyone.js';
 import { Store } from './store.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export function detour(mix) {
+    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
+}
 function tally(mix, voice, by) {
     if (voice.spec.role !== undefined)
         mix.roleVoices += by;