@msb235/blits 0.14.0 → 0.15.0

package/dist/qualify.js

@@ -5,6 +5,7 @@ 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';
 /**
@@ -57,21 +58,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 +98,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 +118,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);
@@ -161,6 +166,7 @@ export function requalify(lanes, version) {
         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;
@@ -318,8 +326,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 +349,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 +398,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 +408,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 +458,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/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);