@msb235/blits 0.14.0 → 0.15.0

package/dist/handle.js

@@ -76,9 +76,10 @@ export class VoiceHandle {
         voice.written = true;
         voice.weight = w;
         this.#host.changed(voice);
-        this.#host.record(this, 'weight', (h) => {
-            h.weight = w;
-        });
+        if (this.#host.taping())
+            this.#host.record(this, 'weight', (h) => {
+                h.weight = w;
+            });
     }
     get rate() {
         const voice = this.#voice;
@@ -105,7 +106,8 @@ export class VoiceHandle {
             retime(voice, now, r, over);
         }
         this.#host.changed(voice);
-        this.#host.record(this, 'rate', (h) => h.ramp(r, over));
+        if (this.#host.taping())
+            this.#host.record(this, 'rate', (h) => h.ramp(r, over));
     }
     seek(elapsed, opts) {
         const voice = this.#cued;
@@ -122,7 +124,8 @@ export class VoiceHandle {
         voice.seeks++;
         const doubt = this.#host.sought(voice, opts?.state !== 'keep');
         this.#host.changed(voice);
-        this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));
+        if (this.#host.taping())
+            this.#host.record(this, 'seek', (h) => h.seek(elapsed, opts));
         return doubt;
     }
     fade(opts) {
@@ -131,7 +134,8 @@ export class VoiceHandle {
             return;
         voice.written = true;
         this.#host.fade(voice, opts);
-        this.#host.record(this, 'fade', (h) => h.fade(opts));
+        if (this.#host.taping())
+            this.#host.record(this, 'fade', (h) => h.fade(opts));
     }
     rise(opts) {
         const voice = this.#cued;
@@ -139,7 +143,8 @@ export class VoiceHandle {
             return;
         voice.written = true;
         this.#host.rise(voice, opts);
-        this.#host.record(this, 'rise', (h) => h.rise(opts));
+        if (this.#host.taping())
+            this.#host.record(this, 'rise', (h) => h.rise(opts));
     }
     release() {
         const voice = this.#cued;
@@ -147,7 +152,8 @@ export class VoiceHandle {
             return;
         voice.written = true;
         this.#host.release(voice);
-        this.#host.record(this, 'release', (h) => h.release());
+        if (this.#host.taping())
+            this.#host.record(this, 'release', (h) => h.release());
     }
     weightOf(subject) {
         const voice = this.#voice;

package/dist/held.d.ts

@@ -1,5 +1,6 @@
 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';
 /** The record a voice gives every subject it does not reach. */
 export declare function unreachedOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): Subject<unknown>;
 /**

package/dist/history.d.ts

@@ -1,6 +1,7 @@
+import { type Cut } from './cut.js';
 import type { Mixer } from './mixer.js';
-import { type Cut } from './transport.js';
-import { type Subject, type Voice } from './voice.js';
+import type { Subject } from './subject.js';
+import { type Voice } from './voice.js';
 /** The last entry taken before `t`, or at it where `inclusive` says so. */
 export declare function last<T extends {
     at: number;
@@ -56,7 +57,7 @@ export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, sub
  */
 export declare function leave<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined): void;
 /**
- * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
- * history.
+ * The mix time a motion patch keeps a released subject from, how far back, the frame, and whether
+ * the release came before anything read it, under history.
  */
-export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number, seq?: number];
+export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number, seq?: number, early?: boolean];

package/dist/history.js

@@ -1,11 +1,11 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
+import { within } from './cut.js';
 import { schedule } from './due.js';
 import { Leavings } from './leavings.js';
 import { packHeld } from './pack.js';
 import { pageOut } from './paging.js';
 import { scoreTouched } from './scored.js';
-import { within } from './transport.js';
 import { none } from './voice.js';
 /** The last entry taken before `t`, or at it where `inclusive` says so. */
 export function last(list, t, inclusive) {
@@ -121,7 +121,6 @@ export function copyHeld(voice, h, shared = false) {
         since: h.since,
         shown: h.shown,
         weight: h.weight,
-        rested: h.rested,
         restedAt: h.restedAt,
         bands: h.bands === null ? null : h.bands.slice(),
         state: h.state === undefined || shared ? h.state : copyState(voice, h.state),
@@ -145,7 +144,7 @@ export function copyHeld(voice, h, shared = false) {
         voice: h.voice,
         next: h.next,
         version: h.version,
-        loci: h.loci,
+        roles: h.roles,
         slot: h.slot,
         run: h.run,
         freed: h.freed,
@@ -172,7 +171,6 @@ export function copyHeldInto(voice, h, into, shared = false) {
     into.since = h.since;
     into.shown = h.shown;
     into.weight = h.weight;
-    into.rested = h.rested;
     into.restedAt = h.restedAt;
     into.bands = h.bands === null ? null : h.bands.slice();
     into.state = h.state === undefined || shared ? h.state : copyState(voice, h.state);
@@ -192,7 +190,7 @@ export function copyHeldInto(voice, h, into, shared = false) {
     into.run = h.run;
     into.freed = h.freed;
     into.restored = null;
-    // `probed`, `delta`, `phase`, `seeks`, `snaps`, `inputs`, `next`, `version` and `loci` as
+    // `probed`, `delta`, `phase`, `seeks`, `snaps`, `inputs`, `next`, `version` and `roles` as
     // `unread` leaves them.
     return unread(into);
 }
@@ -209,7 +207,7 @@ export function unread(h) {
     h.inputs = undefined;
     h.next = null;
     h.version = Number.NaN;
-    h.loci = null;
+    h.roles = null;
     return h;
 }
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
@@ -334,12 +332,12 @@ export function leave(mix, voice, subject, held) {
     });
 }
 /**
- * The mix time a motion patch keeps a released subject from, how far back, and the frame, under
- * history.
+ * The mix time a motion patch keeps a released subject from, how far back, the frame, and whether
+ * the release came before anything read it, under history.
  */
 export function releasing(mix) {
     const history = mix.opts.history;
     if (history === undefined || Number.isNaN(mix.now))
         return [];
-    return [mix.now, mix.now - history.ms, mix.transport.seq];
+    return [mix.now, mix.now - history.ms, mix.transport.seq, mix.syncing || !mix.looked];
 }

package/dist/hosts.js

@@ -18,7 +18,7 @@ import { localNow } from './place.js';
 import { reading } from './reading.js';
 import { heard } from './signals.js';
 import { cuedById } from './strays.js';
-import { record } from './tape.js';
+import { record, taping } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
     if (mix.projecting)
@@ -62,6 +62,7 @@ export function laneHost(mix) {
             return mix.held(voice, subject, slot);
         },
         forgot: (slot) => {
+            mix.places?.forgot(slot);
             // Only a voice over every subject keeps bits, and one gone may still be read back.
             for (const voice of mix.general) {
                 unreach(voice, slot, false);
@@ -80,11 +81,7 @@ export function laneHost(mix) {
         parting: (voice, subject) => mix.parting(voice, subject, mix.now),
         ready: (voice, subject, held) => {
             const arg = mix.lanes.arg;
-            const primed = mix.primed;
-            primed[0 /* Primed.NOW */] = mix.now;
-            primed[1 /* Primed.ELAPSED */] = arg[1 /* Arg.ELAPSED */];
-            primed[2 /* Primed.PASS */] = arg[3 /* Arg.PASS */];
-            mix.prime(voice, held);
+            mix.primeLaned(voice, held, arg);
             voice.setting.weight = arg[0 /* Arg.WEIGHT */];
             mix.sending.voice = voice;
             mix.sending.subject = subject;
@@ -97,11 +94,7 @@ export function laneHost(mix) {
                 arg[0 /* Arg.WEIGHT */] = read;
                 return;
             }
-            const primed = mix.primed;
-            primed[0 /* Primed.NOW */] = mix.now;
-            primed[1 /* Primed.ELAPSED */] = arg[1 /* Arg.ELAPSED */];
-            primed[2 /* Primed.PASS */] = arg[3 /* Arg.PASS */];
-            mix.prime(voice, held);
+            mix.primeLaned(voice, held, arg);
             const kept = reading.kept;
             const base = mix.base(voice, subject, mix.now, held, slot);
             if (reading.kept !== kept && !voice.keeping)
@@ -145,13 +138,13 @@ export function fits(mix, voice) {
         return false;
     if (patch.reads !== undefined && patch.reads.length > 0)
         return false;
-    // A locus on lanes gathers keys and fn members; a motion member keeps it on the general path.
-    if (spec.locus !== undefined && voice.motion !== undefined)
+    // A role on lanes gathers keys and fn members; a motion member keeps it on the general path.
+    if (spec.role !== undefined && voice.motion !== undefined)
         return false;
     if (spec.from === 'current')
         return false;
-    // A rest-less channel's band is read on the record `one` folds; crowds, motions and loci fold elsewhere.
-    if ((voice.motion !== undefined || spec.locus !== undefined || crowdable(voice)) &&
+    // A rest-less channel's band is read on the record `one` folds; crowds, motions and roles fold elsewhere.
+    if ((voice.motion !== undefined || spec.role !== undefined || crowdable(voice)) &&
         voice.slots.some((s) => numericOf(mix.channels[s])?.op === 'last'))
         return false;
     if (voice.out?.rest)
@@ -257,6 +250,7 @@ function handleHost(mix) {
             // A voice that stopped sharing makes a subject's record at its next read, from what it kept.
             return held !== undefined ? held.weight : weightAt(voice, slot);
         },
+        taping: () => taping(mix),
         record: (h, label, again) => record(mix, label, (stage) => {
             const to = stage.mix(mix);
             if (to === mix)

package/dist/index.d.ts

@@ -1,25 +1,26 @@
-export type { NumberOptions, Vec } from './channels.js';
+export type { LastOptions, NumberOptions, NumberTuple, Vec } from './channels.js';
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export type { ColorOptions } from './color.js';
 export { color, css, mixHex, oklab, toHex } from './color.js';
 export type { Curve } from './easing.js';
 export { curve } from './easing.js';
-export type { Claim, Fit, FitPlan, Order, SpanClaim, Strength } from './fit.js';
+export type { Claim, Fit, FitPlan, Layout, Order, OverrunOptions, SpanClaim, Strength, } from './fit.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';
-export type { Motion, Moving, PerSubject, Value } from './motion.js';
+export type { Glide, GlideOptions, Motion, MotionOptions, Moving, PerSubject, Spring, SpringOptions, Tween, TweenOptions, Value, } from './motion.js';
 export { glide, spring, tween } from './motion.js';
 export { HistoryMiss } from './paging.js';
 export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
 export type { AngleOptions } from './rotation.js';
 export { angle, quat } from './rotation.js';
+export type { Input, LagOptions, Level, SlewOptions } from './signals.js';
 export { gate, input, lag, level, peak, share, slew } from './signals.js';
 export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, ArcHandle, ArcPart, ArcSpec, ArcVoice, BlendMember, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, Registry, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, Watched, WatchedFrame, } from './types.js';
+export type { Anchor, AnnounceOptions, ArcHandle, ArcPart, ArcSpec, ArcVoice, Band, BlendMember, BookedHit, Booker, BookOptions, Channel, Circle, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, Finder, FitResult, GlideSpec, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Probed, Projection, Pulled, Query, Registry, RegistryChange, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, SpringSpec, SubjectFade, Taken, Tape, TapeBranch, TapeMaker, TapeOp, TapeOptions, Transport, TransportOptions, TransportProjection, TweenSpec, VoiceFade, VoiceSpec, Watched, WatchedFrame, WatchedHistory, WatchedVoice, } from './types.js';
 export { watched } from './watch.js';
 export type { WaveOptions, WaveShape } from './wave.js';
 export { wave, waveAt } from './wave.js';

package/dist/keyfill.d.ts

@@ -1,7 +1,7 @@
 import { type Lane } from './lane.js';
 import type { Lanes } from './lanes.js';
 /**
- * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * A keys voice's fill outside a role, its weight a number: what `one` does for each subject, in
  * one loop, so no weight or time crosses a call as a boxed double per subject.
  */
 export declare function runKeys<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>): void;

package/dist/keyfill.js

@@ -1,9 +1,10 @@
 import { foldNumber } from './channels.js';
 import { clampWeight, frozenTime, phaseAt, same, weighed } from './clock.js';
 import { unband } from './fold.js';
+import { keepProbed } from './lane.js';
 import { shortWay } from './turns.js';
 /**
- * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
+ * A keys voice's fill outside a role, its weight a number: what `one` does for each subject, in
  * one loop, so no weight or time crosses a call as a boxed double per subject.
  */
 export function runKeys(lanes, lane) {
@@ -18,6 +19,8 @@ export function runKeys(lanes, lane) {
     const fills = lanes.fills;
     const lately = lanes.lately;
     const elapsedNow = voice.elapsedAt(lanes.now);
+    // For `one`, where a probe meeting the voice later this fill reads it (`foldNow` in `meet.ts`).
+    lane.elapsedNow = elapsedNow;
     const duration = voice.duration;
     const passes = voice.passes;
     const before = voice.freezesBefore;
@@ -39,8 +42,7 @@ export function runKeys(lanes, lane) {
     for (let p = 0; p < list.length; p++) {
         const slot = list[p];
         const o = p * 8 /* Row.STRIDE */;
-        if (per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === fills - 1)
-            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        keepProbed(data, o, per, slot * 6 /* Per.SLOT */, fills);
         if (lately >= 0 && lanes.unread(slot))
             continue;
         const raw = elapsedNow - data[o + 0 /* Row.DELAY */];

package/dist/keyrows.d.ts

@@ -6,6 +6,7 @@ export interface KeyChannel {
     scalar: boolean;
     op: Numeric['op'];
     plain: boolean;
+    straight: boolean;
     rest: number;
     axes: number;
     values: Float64Array;
@@ -21,6 +22,11 @@ export declare class KeyRows {
     data: Float64Array<ArrayBuffer>;
     used: number;
     eases: (Curve | undefined)[];
+    /** The timing and phase `search` last ran for, and what it found per track. */
+    private lastTiming;
+    private lastPhase;
+    private found;
+    private easedAt;
     /**
      * Copies a voice's stops for channels `chans` and returns the row's offset; -1 where a stop's
      * value is not one a lane folds as a number per axis, so the row reads its voice's stops instead.
@@ -33,5 +39,11 @@ export declare class KeyRows {
      * and the stock lerp and fold give for each track, read from this pool.
      */
     fold(off: number, phase: number, chans: readonly KeyChannel[], slot: number, w: number): void;
+    /**
+     * What `segment` finds for each track of the row at `off` at `phase`, kept for every row after it
+     * with the same timing at the same phase: the stop, and the eased fraction of its segment.
+     */
+    private search;
+    private grow;
     private reserve;
 }

package/dist/keyrows.js

@@ -1,7 +1,49 @@
 import { foldNumber, lerpNumber } from './channels.js';
 import { fraction, locate, shift } from './patch.js';
-/** A row's header: its length in `data`, its offset in `eases`, its duration, its stop count. */
-const HEAD = 4;
+/**
+ * A row's header: its length in `data`, its offset in `eases`, its duration, its stop count, and
+ * its timing's number.
+ */
+const HEAD = 5;
+/**
+ * Timings by what makes two rows find the same stop and easing at the same phase: the duration,
+ * and each track's delay, stop phases and easings. Numbers are never reused, so clearing the map
+ * once it is large only stops rows added later sharing with rows added earlier.
+ */
+const timings = new Map();
+const easeIds = new WeakMap();
+let timed = 0;
+let eased = 0;
+function easeId(ease) {
+    if (ease === undefined)
+        return 0;
+    let id = easeIds.get(ease);
+    if (id === undefined) {
+        id = ++eased;
+        easeIds.set(ease, id);
+    }
+    return id;
+}
+/** A phase written so -0 and 0 differ, as a stop search can tell them apart. */
+const exact = (x) => (Object.is(x, -0) ? '-0' : String(x));
+function timingOf(built) {
+    let key = exact(built.duration);
+    for (const track of built.tracks) {
+        if (track === undefined)
+            return ++timed;
+        key += `|${exact(track.delay)}`;
+        for (const pt of track.all)
+            key += `,${exact(pt.at)}:${easeId(pt.ease)}`;
+    }
+    let id = timings.get(key);
+    if (id === undefined) {
+        if (timings.size >= 4096)
+            timings.clear();
+        id = ++timed;
+        timings.set(key, id);
+    }
+    return id;
+}
 /**
  * The stops of a crowd's `keys` rows, copied into one array as a row joins, so a fill reads each
  * row's stops in place rather than through its voice, its built tracks and every stop's own array.
@@ -13,6 +55,11 @@ export class KeyRows {
     data = new Float64Array(64);
     used = 0;
     eases = [];
+    /** The timing and phase `search` last ran for, and what it found per track. */
+    lastTiming = -1;
+    lastPhase = Number.NaN;
+    found = new Int32Array(4);
+    easedAt = new Float64Array(4);
     /**
      * Copies a voice's stops for channels `chans` and returns the row's offset; -1 where a stop's
      * value is not one a lane folds as a number per axis, so the row reads its voice's stops instead.
@@ -23,7 +70,7 @@ export class KeyRows {
         for (let i = 0; i < built.tracks.length; i++) {
             const track = built.tracks[i];
             const ch = chans[i];
-            if (track === undefined || ch === undefined || !ch.plain)
+            if (track === undefined || ch === undefined || !ch.plain || !ch.straight)
                 return -1;
             for (const pt of track.all)
                 if (!flat(pt.value, ch))
@@ -37,6 +84,7 @@ export class KeyRows {
         d[off + 1] = this.eases.length;
         d[off + 2] = built.duration;
         d[off + 3] = stops;
+        d[off + 4] = timingOf(built);
         let o = off + HEAD;
         for (let i = 0; i < built.tracks.length; i++) {
             const track = built.tracks[i];
@@ -75,8 +123,12 @@ export class KeyRows {
      */
     fold(off, phase, chans, slot, w) {
         const d = this.data;
-        const duration = d[off + 2];
-        let e = d[off + 1];
+        const timing = d[off + 4];
+        // A phase of 0 is searched afresh: -0 and 0 compare equal and need not find the same.
+        if (timing !== this.lastTiming || phase !== this.lastPhase || phase === 0)
+            this.search(off, phase, chans);
+        const found = this.found;
+        const easedAt = this.easedAt;
         let o = off + HEAD;
         const end = off + d[off];
         for (let i = 0; o < end; i++) {
@@ -84,12 +136,9 @@ export class KeyRows {
             const axes = ch.axes;
             const stride = 1 + axes;
             const n = d[o];
-            const ph = shift(d[o + 1], phase, duration);
             const first = o + 2;
             o = first + n * stride;
-            const k = locate(d, first, stride, n, ph);
-            const stops = e;
-            e += n;
+            const k = found[i];
             if (k === -2)
                 continue;
             const values = ch.values;
@@ -102,15 +151,53 @@ export class KeyRows {
             }
             const b = first + k * stride;
             const before = b - stride;
-            const u = fraction(ph, d[before], d[b]);
-            const ease = this.eases[stops + k];
-            const eased = ease ? ease(u) : u;
+            const eased = easedAt[i];
             for (let a = 0; a < axes; a++) {
                 const v = lerpNumber(d[before + 1 + a], d[b + 1 + a], eased);
                 values[base + a] = foldNumber(ch.op, values[base + a], v, w);
             }
         }
     }
+    /**
+     * What `segment` finds for each track of the row at `off` at `phase`, kept for every row after it
+     * with the same timing at the same phase: the stop, and the eased fraction of its segment.
+     */
+    search(off, phase, chans) {
+        const d = this.data;
+        this.lastTiming = -1;
+        const duration = d[off + 2];
+        let e = d[off + 1];
+        let o = off + HEAD;
+        const end = off + d[off];
+        for (let i = 0; o < end; i++) {
+            if (i >= this.found.length)
+                this.grow(i + 1);
+            const stride = 1 + chans[i].axes;
+            const n = d[o];
+            const ph = shift(d[o + 1], phase, duration);
+            const first = o + 2;
+            o = first + n * stride;
+            const k = locate(d, first, stride, n, ph);
+            this.found[i] = k;
+            if (k >= 0 && k < n) {
+                const b = first + k * stride;
+                const u = fraction(ph, d[b - stride], d[b]);
+                const ease = this.eases[e + k];
+                this.easedAt[i] = ease ? ease(u) : u;
+            }
+            e += n;
+        }
+        this.lastTiming = d[off + 4];
+        this.lastPhase = phase;
+    }
+    grow(tracks) {
+        const found = new Int32Array(tracks * 2);
+        found.set(this.found);
+        this.found = found;
+        const easedAt = new Float64Array(tracks * 2);
+        easedAt.set(this.easedAt);
+        this.easedAt = easedAt;
+    }
     reserve(len) {
         const at = this.used;
         if (at + len > this.data.length) {

package/dist/lane.d.ts

@@ -1,8 +1,9 @@
 import type { Numeric } from './channels.js';
 import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
+import type { Subject } from './subject.js';
 import type { Channel } from './types.js';
-import type { Subject, Voice } from './voice.js';
+import type { Voice } from './voice.js';
 /** One laned channel: its arithmetic, and every numbered subject's folded value, `axes` per subject. */
 export interface Laned {
     name: string;
@@ -11,6 +12,8 @@ export interface Laned {
     op: Numeric['op'];
     /** Its values fold as its `op` alone: not through a band as `'last'` does, and not a rotation. */
     plain: boolean;
+    /** A plain channel's values lerp straight across each axis, not through the channel's `lerp`. */
+    straight: boolean;
     /** An angle's full turn, and 0 for any other channel. */
     turn: number;
     /** The channel, whose own `fold` and `lerp` an `'own'` lane calls. */
@@ -24,11 +27,11 @@ export interface Laned {
     index: number;
 }
 /**
- * The laned voices sharing one locus, in voice order, and what a fill gathers from them for each
+ * The laned voices sharing one role, in voice order, and what a fill gathers from them for each
  * subject before folding it in at the subject's first member: their summed weight, and per laned
  * channel the members' values lerped by share of weight and the weight taken into each.
  */
-export interface Locus<I, O> {
+export interface Role<I, O> {
     readonly members: Lane<I, O>[];
     /** By subject number: the fill that last met it, the member it met first then, the summed weight. */
     met: Float64Array;
@@ -37,6 +40,10 @@ export interface Locus<I, O> {
     /** By laned channel, then subject number (times axes for `values`). */
     values: (Float64Array | undefined)[];
     taken: (Float64Array | undefined)[];
+    /** No other laned or crowded voice falls between its members in voice order, as qualify found. */
+    contiguous: boolean;
+    /** This fill runs it a subject at a time at its first member's turn, folding each as it goes. */
+    inline: boolean;
 }
 /**
  * Where each of a lane position's or crowd row's `STRIDE` numbers sits. The layouts are const
@@ -58,6 +65,11 @@ export declare const enum Row {
     /** 1 once the general path has made the voice's first call for the subject, which never undoes. */
     MET = 7
 }
+/**
+ * Keeps the weight a probe read from the last fill as `Row.PROBED`, for `weightOf`, before a fill
+ * writes the position's new weight; reads `per` only where the copy could change a bit.
+ */
+export declare function keepProbed(data: Float64Array, o: number, per: Float64Array, q: number, fills: number): void;
 /** What `begin` found: the general path, or lanes filled. */
 export declare const enum Begin {
     GENERAL = 0,
@@ -79,7 +91,14 @@ export declare const enum Arg {
     DELAY = 4,
     /** The voice's own fade, for `signalled`. */
     FADE = 5,
-    SIZE = 6
+    /**
+     * The fill and voice time a lane's subjects share since it last placed one, numbered once per
+     * placing; NaN where the caller shares none. A setting already filled under it skips its per-lane fields.
+     */
+    MARK = 6,
+    /** A number a delta gave, for `gatherScalar`. */
+    VALUE = 7,
+    SIZE = 8
 }
 /** Where each of a subject's `SLOT` numbers in `Lanes.per` sits. */
 export declare const enum Per {
@@ -207,6 +226,8 @@ export declare class Lane<I, O> implements Positions<I, O> {
     fade: number;
     /** Whether the voice has no fade in or out this fill, so its envelope is 1 for every subject. */
     flat: boolean;
+    /** The fill that last ran it, so what it remembers within one fill is that fill's. */
+    ran: number;
     /** The voice's clock at this fill, set before `one` runs its subjects. */
     elapsedNow: number;
     /** A motion patch's state, which the lane samples in place of calling the patch. */
@@ -217,8 +238,12 @@ export declare class Lane<I, O> implements Positions<I, O> {
     bareFill: number;
     bareElapsed: number;
     bareSeeks: number;
-    /** The locus its voice shares, gathered before the voices are folded in order. */
-    group: Locus<I, O> | null;
+    /** The role its voice shares, gathered before the voices are folded in order. */
+    group: Role<I, O> | null;
+    /** The `Arg.MARK` it was last placed under, for a role run a subject at a time to put back. */
+    mark: number;
+    /** Whether it took every subject when it opened, so a fill makes each one's first call. */
+    every: boolean;
     voiceAt(): Voice<I, O>;
     fix(p: number): void;
     numbered(p: number, ms: number): void;
@@ -228,6 +253,11 @@ export declare class Lane<I, O> implements Positions<I, O> {
     motionAt(): Motions<I> | undefined;
     constructor(voice: Voice<I, O>);
     positionOf(slot: number): number;
+    /**
+     * Room for `n` positions and subject numbers below `cap`, for a voice that reaches every subject:
+     * grown as it met them, a voice replaced every frame regrew both from nothing each frame.
+     */
+    reserve(n: number, cap: number): void;
     /** Gives a subject the voice reaches a position, from what its record fixed on first sight. */
     add(slot: number, held: Subject<unknown>): void;
     /** A subject lost its number: the last position moves into its place. */