@msb235/blits 0.14.0 → 0.15.1

package/dist/sample.js

@@ -1,6 +1,7 @@
 import { unbareLane } from './bare.js';
 import { foldNumber } from './channels.js';
 import { clampWeight, passAt, same, weighed } from './clock.js';
+import { keepProbed } from './lane.js';
 import { absent } from './numbers.js';
 import { reading } from './reading.js';
 import { between, left, progress } from './tweened.js';
@@ -50,6 +51,11 @@ export function runMotion(lanes, lane, run) {
     }
     const own = ease !== undefined && !signal && run.watcher === lanes && run.watchId === voice.id;
     const folds = n === ch.axes && ch.plain;
+    // The weight a voice with a fade and no subject ramps gives every subject at one fade: worked
+    // out again for a zero, whose sign a hit by `===` would not keep.
+    let fadeOf = Number.NaN;
+    let baseOf = Number.NaN;
+    let faded = 0;
     for (let p = 0; p < list.length; p++) {
         // Its signal just made kept state: no further call this fill, the general path makes them.
         if (signal && voice.keeping)
@@ -57,8 +63,7 @@ export function runMotion(lanes, lane, run) {
         const slot = list[p];
         const o = p * 8 /* Row.STRIDE */;
         const q = slot * 6 /* Per.SLOT */;
-        if (per[q + 5 /* Per.LANE_FILL */] === fills - 1)
-            data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
+        keepProbed(data, o, per, q, fills);
         if (lately >= 0 && lanes.unread(slot)) {
             unbareLane(lane, p);
             continue;
@@ -89,8 +94,20 @@ export function runMotion(lanes, lane, run) {
             }
             w = arg[0 /* Arg.WEIGHT */];
         }
-        else
-            w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
+        else if (parts)
+            w = weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
+        else if (flat)
+            w = whole;
+        else {
+            const fade = lane.fade;
+            const base = voice.weight;
+            if (fade !== fadeOf || base !== baseOf || fade === 0 || base === 0) {
+                fadeOf = fade;
+                baseOf = base;
+                faded = weighed(base, fade, 1);
+            }
+            w = faded;
+        }
         data[o + 2 /* Row.WEIGHT */] = w;
         if (data[o + 7 /* Row.MET */] === 0) {
             if (Number.isNaN(records[p].probed)) {
@@ -101,7 +118,16 @@ export function runMotion(lanes, lane, run) {
             data[o + 7 /* Row.MET */] = 1;
         }
         const ms = data[o + 4 /* Row.MSLOT */];
-        const b = ms < 0 ? -1 : run.bareAt(ms);
+        // `bareAt` and `scalar` written out: V8 leaves them and `base` out of line here.
+        let b = -1;
+        let scalar = false;
+        if (ms >= 0) {
+            b = 5 /* Law.HEAD */ + ms * run.stride;
+            const f = run.runs[b + 1];
+            if ((f & (2 /* RunFlag.PENDING */ | 4 /* RunFlag.OLDER */)) !== 0)
+                b = -1;
+            scalar = (f & 1 /* RunFlag.SCALAR */) !== 0;
+        }
         if (b < 0 ||
             (probed &&
                 (per[q + 3 /* Per.LANE_PROBE */] > from ||
@@ -113,7 +139,7 @@ export function runMotion(lanes, lane, run) {
             continue;
         }
         const runs = run.runs;
-        if (own && folds && run.scalar(ms) === ch.scalar) {
+        if (own && folds && scalar === ch.scalar) {
             if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */) {
                 data[o + 5 /* Row.SAMPLED */] = -2 /* Sampled.BARE */;
                 lane.deltas[p] = null;
@@ -147,7 +173,7 @@ export function runMotion(lanes, lane, run) {
         data[o + 6 /* Row.SEEKS */] = seeks;
         if (w <= 0)
             continue;
-        if (folds && run.scalar(ms) === ch.scalar) {
+        if (folds && scalar === ch.scalar) {
             const values = ch.values;
             const base = slot * n;
             for (let a = 0; a < n; a++)

package/dist/seat.d.ts

@@ -0,0 +1,17 @@
+import type { Crowd } from './crowd.js';
+import type { Voice } from './voice.js';
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export declare class Seat<I, O> {
+    lanes: object | null;
+    readonly crowd: Crowd<I, O>;
+    row: number;
+    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number);
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export declare function seatOf<I, O>(lanes: object, voice: Voice<I, O>): Seat<I, O> | null;
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export declare function seated<I, O>(lanes: object, voice: Voice<I, O>, c: Crowd<I, O>, p: number): boolean;

package/dist/seat.js

@@ -0,0 +1,25 @@
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export class Seat {
+    lanes;
+    crowd;
+    row;
+    constructor(lanes, crowd, row) {
+        this.lanes = lanes;
+        this.crowd = crowd;
+        this.row = row;
+    }
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export function seatOf(lanes, voice) {
+    const s = voice.seat;
+    return s !== null && s.lanes === lanes ? s : null;
+}
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export function seated(lanes, voice, c, p) {
+    const s = seatOf(lanes, voice);
+    return s !== null && s.crowd === c && s.row === p;
+}

package/dist/seek.js

@@ -9,6 +9,7 @@ import { move, nextFrame } from './move.js';
 import { ownerReading } from './owner.js';
 import { place } from './place.js';
 import { unpull } from './pull.js';
+import { isRested } from './record.js';
 import { Restored } from './restored.js';
 import { recount } from './roster.js';
 import { refitAll } from './spans.js';
@@ -113,8 +114,7 @@ function restore(mix, voice, live, at, every, mine) {
  * subject may have rested and moved on since, so a probe at `t` would not find it at rest again.
  */
 function restedBy(h, live, t) {
-    h.rested = live.restedAt <= t;
-    h.restedAt = h.rested ? live.restedAt : Number.NaN;
+    h.restedAt = live.restedAt <= t ? live.restedAt : Number.NaN;
 }
 /** Cuts a record's list of copies to its first `kept`, keeping those no other list holds as spares. */
 function trim(voice, snaps, kept) {
@@ -196,7 +196,7 @@ function restoreVoice(mix, voice, t, seq) {
                 return h;
             if (h.reaches)
                 voice.seen++;
-            if (h.rested)
+            if (isRested(h))
                 voice.restedCount++;
             if (!(h.since <= restored.top)) {
                 voice.early ??= [];
@@ -358,7 +358,7 @@ function back(mix, t, seq, on) {
         if (voice.parts !== null || voice.parted !== null)
             mix.parters.add(voice);
     mix.relinks++;
-    mix.pose = new Store();
+    mix.lastPoses = new Store();
     if (mix.restStamps !== null)
         mix.restStamps = new Store();
     unpull(mix);
@@ -401,7 +401,7 @@ function back(mix, t, seq, on) {
             mix.pins.set(voice, voice.pinned);
         }
     refitAll(mix);
-    mix.due = [];
+    mix.due.clear();
     for (const voice of kept)
         schedule(mix, voice);
     mix.stir();

package/dist/setting.d.ts

@@ -0,0 +1,27 @@
+import type { Setting } from './types.js';
+import type { Voice } from './voice.js';
+/**
+ * A voice's `setting.keep`, one per voice: a setting is valid only during its call, so the state
+ * goes on the record of the subject being called for, `keepOn`, or on the voice before any is.
+ */
+export declare function keeping<I, O>(voice: Voice<I, O>): Setting['keep'];
+/**
+ * A voice's setting. `keep` is made on first read: most patches keep no state, and a closure and
+ * its context per voice cost a one-subject tween voice about 100 bytes.
+ */
+export declare class VoiceSetting<I, O> implements Setting<unknown> {
+    host: unknown;
+    readonly send: (event: unknown) => void;
+    private readonly voice;
+    timestamp: number;
+    dt: number;
+    elapsed: number;
+    pass: number;
+    weight: number;
+    state: unknown;
+    /** The `Arg.MARK` a lane last filled `timestamp`, `elapsed` and `pass` under; 0 once anything else writes them. */
+    mark: number;
+    private kept;
+    constructor(host: unknown, send: (event: unknown) => void, voice: Voice<I, O>);
+    get keep(): Setting['keep'];
+}

package/dist/setting.js

@@ -0,0 +1,55 @@
+import { reading } from './reading.js';
+/**
+ * A voice's `setting.keep`, one per voice: a setting is valid only during its call, so the state
+ * goes on the record of the subject being called for, `keepOn`, or on the voice before any is.
+ */
+export function keeping(voice) {
+    return function keep(owner, init) {
+        const held = voice.keepOn;
+        let kept = held === null ? voice.ownKept : held.kept;
+        if (kept === null) {
+            kept = new Map();
+            if (held === null)
+                voice.ownKept = kept;
+            else
+                held.kept = kept;
+        }
+        if (kept.has(owner))
+            return kept.get(owner);
+        const unkept = held?.unkept;
+        const made = unkept === undefined ? init() : unkept.shift();
+        if (unkept?.length === 0 && held !== null)
+            held.unkept = undefined;
+        kept.set(owner, made);
+        reading.kept++;
+        return made;
+    };
+}
+/**
+ * A voice's setting. `keep` is made on first read: most patches keep no state, and a closure and
+ * its context per voice cost a one-subject tween voice about 100 bytes.
+ */
+export class VoiceSetting {
+    host;
+    send;
+    voice;
+    timestamp = 0;
+    dt = 0;
+    elapsed = 0;
+    pass = 0;
+    weight = 0;
+    state = undefined;
+    /** The `Arg.MARK` a lane last filled `timestamp`, `elapsed` and `pass` under; 0 once anything else writes them. */
+    mark = 0;
+    kept = null;
+    constructor(host, send, voice) {
+        this.host = host;
+        this.send = send;
+        this.voice = voice;
+    }
+    get keep() {
+        if (this.kept === null)
+            this.kept = keeping(this.voice);
+        return this.kept;
+    }
+}

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.14.0";
+export declare const release = "0.15.1";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.14.0';
+export const release = '0.15.1';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/signals.d.ts

@@ -1,4 +1,4 @@
-import type { Setting, Signal } from './types.js';
+import type { Band, Setting, Signal } from './types.js';
 /** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
 export declare const heard: (signal: object) => boolean;
 /**
@@ -10,15 +10,24 @@ export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]
 /** A blend member's share of its signal's read `k`: the members' stops sit evenly along 0..1. */
 export declare function shareOf(k: number, i: number, stops: number): number;
 /**
- * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it: the hat of `by`'s read at the
- * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of
- * its members, such as one member played alone.
+ * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it. It is the hat of `by`'s read at the
+ * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of its
+ * members, such as one member played alone.
  *
  * @category signal
  */
 export declare function share<I, H = unknown>(by: Signal<I, H>, i: number, n: number): Signal<I, H>;
 /**
- * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * The signal `input` returns, with `touch` to report a change.
+ *
+ * @category signal
+ */
+export interface Input<I, H = unknown> extends Signal<I, H> {
+    /** Reports a change to what the signal reads. */
+    touch(): void;
+}
+/**
+ * Marks `read` as a signal driven from outside the clock. A host's own signal has to be one for
  * `assess` and a history's `inputs` to treat it as one. Two uses:
  *
  * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
@@ -32,54 +41,77 @@ export declare function share<I, H = unknown>(by: Signal<I, H>, i: number, n: nu
  *
  * @category signal
  */
-export declare function input<I, H = unknown>(read: (subject: I, setting: Setting<void, H>) => number, of?: readonly Signal<I, H>[]): Signal<I, H> & {
-    touch(): void;
-};
+export declare function input<I, H = unknown>(read: (subject: I, setting: Setting<void, H>) => number, of?: readonly Signal<I, H>[]): Input<I, H>;
 /**
- * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
- * `level`.
+ * The signal `level` returns, with `set` to write it.
  *
  * @category signal
  */
-export declare function level<I, H = unknown>(initial?: number): Signal<I, H> & {
+export interface Level<I, H = unknown> extends Signal<I, H> {
+    /** Writes the level, reporting the change; writing the value it holds already does nothing. */
     set(v: number): void;
-};
+}
 /**
- * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
- * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`
- * unless `dt` is infinite.
+ * A signal the host writes. It is `input` over one number, with `set` reporting each change.
+ * klieg's `level`.
+ *
+ * @category signal
+ */
+export declare function level<I, H = unknown>(initial?: number): Level<I, H>;
+/**
+ * What `slew` takes.
  *
  * @category signal
  */
-export declare function slew<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, from }: {
+export interface SlewOptions {
+    /** Ms per unit climbing; 0 follows at once. Default 0. */
     riseMs?: number;
+    /** Ms per unit draining; 0 follows at once. Default 0. */
     fallMs?: number;
+    /** Where a subject starts, unless `dt` is infinite. Default: on its input. */
     from?: number;
-}): Signal<I, H>;
+}
+/**
+ * Follows its input at a rate limit, the package's linear decay primitive. No faster than `riseMs`
+ * per unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two
+ * voices handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * unless `dt` is infinite.
+ *
+ * @category signal
+ */
+export declare function slew<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, from }: SlewOptions): Signal<I, H>;
 /**
- * The exponential counterpart to `slew`: closes the same fraction of the distance to its input in
- * every equal stretch of time, `1 − exp(−gap / ms)`, so it reads the same however the frames that
- * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
- * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
- * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from` unless `dt` is infinite.
+ * What `lag` takes.
  *
  * @category signal
  */
-export declare function lag<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, floor, from, }: {
+export interface LagOptions {
+    /** The time constant climbing, ms; 0 follows at once. Default 0. */
     riseMs?: number;
+    /** The time constant draining, ms; 0 follows at once. Default 0. */
     fallMs?: number;
+    /** Within this of its input it lands on it; 0 keeps the curve exact. Default 1e-6. */
     floor?: number;
+    /** Where a subject starts, unless `dt` is infinite. Default: on its input. */
     from?: number;
-}): Signal<I, H>;
+}
+/**
+ * Closes the same fraction of the distance to its input in every equal stretch of time. The
+ * exponential counterpart to `slew`: the fraction is `1 − exp(−gap / ms)`, so it reads the same
+ * however the frames that sample it are spaced while the input holds still. `riseMs` and `fallMs`
+ * are time constants: after one, 63% of the way is covered. 0 follows at once. Within `floor` of
+ * its input it lands on it, so a subject can reach rest; pass 0 to keep the curve exact. The mix
+ * keeps its state per voice and subject. A subject starts on its input, or at `from` unless `dt` is
+ * infinite.
+ *
+ * @category signal
+ */
+export declare function lag<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, floor, from }: LagOptions): Signal<I, H>;
 /**
- * The other half of the pair: a band, not an edge. It drops at `off`, passes at `on`, and between
- * the two it holds whatever it last did, so an input resting on a threshold cannot chatter.
+ * Passes or drops its input across a band, not an edge. The other half of the pair. It drops at
+ * `off`, passes at `on`, and between the two it holds whatever it last did, so an input resting on
+ * a threshold cannot chatter.
  *
  * @category signal
  */
-export declare function gate<I, H = unknown>(of: Signal<I, H>, band: {
-    on: number;
-    off: number;
-} | number): Signal<I, H>;
+export declare function gate<I, H = unknown>(of: Signal<I, H>, band: Band | number): Signal<I, H>;

package/dist/signals.js

@@ -33,9 +33,9 @@ export function shareOf(k, i, stops) {
     return d >= 1 ? 0 : 1 - d;
 }
 /**
- * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it: the hat of `by`'s read at the
- * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of
- * its members, such as one member played alone.
+ * Member `i` of `n`'s share of `by`, as `mix.blend` weighs it. It is the hat of `by`'s read at the
+ * member's stop, the stops spaced evenly from 0 to 1. Weights a voice outside a blend as one of its
+ * members, such as one member played alone.
  *
  * @category signal
  */
@@ -48,7 +48,7 @@ const touch = () => {
     reading.inputs++;
 };
 /**
- * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * Marks `read` as a signal driven from outside the clock. A host's own signal has to be one for
  * `assess` and a history's `inputs` to treat it as one. Two uses:
  *
  * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
@@ -69,8 +69,8 @@ export function input(read, of) {
     return Object.assign(read, { input: true, touch });
 }
 /**
- * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
- * `level`.
+ * A signal the host writes. It is `input` over one number, with `set` reporting each change.
+ * klieg's `level`.
  *
  * @category signal
  */
@@ -93,9 +93,9 @@ const firstSight = (target, from, setting) => from === undefined || !Number.isFi
     ? { value: target, seen: Number.NaN }
     : { value: from, seen: setting.timestamp };
 /**
- * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
- * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * Follows its input at a rate limit, the package's linear decay primitive. No faster than `riseMs`
+ * per unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two
+ * voices handed the same slew each follow on their own. A subject starts on its input, or at `from`
  * unless `dt` is infinite.
  *
  * @category signal
@@ -123,16 +123,17 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
     return marked(read, [of]);
 }
 /**
- * The exponential counterpart to `slew`: closes the same fraction of the distance to its input in
- * every equal stretch of time, `1 − exp(−gap / ms)`, so it reads the same however the frames that
- * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
- * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
- * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from` unless `dt` is infinite.
+ * Closes the same fraction of the distance to its input in every equal stretch of time. The
+ * exponential counterpart to `slew`: the fraction is `1 − exp(−gap / ms)`, so it reads the same
+ * however the frames that sample it are spaced while the input holds still. `riseMs` and `fallMs`
+ * are time constants: after one, 63% of the way is covered. 0 follows at once. Within `floor` of
+ * its input it lands on it, so a subject can reach rest; pass 0 to keep the curve exact. The mix
+ * keeps its state per voice and subject. A subject starts on its input, or at `from` unless `dt` is
+ * infinite.
  *
  * @category signal
  */
-export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
+export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
         const held = setting.keep(read, () => firstSight(target, from, setting));
@@ -155,8 +156,9 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
     return marked(read, [of]);
 }
 /**
- * The other half of the pair: a band, not an edge. It drops at `off`, passes at `on`, and between
- * the two it holds whatever it last did, so an input resting on a threshold cannot chatter.
+ * Passes or drops its input across a band, not an edge. The other half of the pair. It drops at
+ * `off`, passes at `on`, and between the two it holds whatever it last did, so an input resting on
+ * a threshold cannot chatter.
  *
  * @category signal
  */

package/dist/stack.d.ts

@@ -1,10 +1,10 @@
 import type { Kit } from './types.js';
 /**
- * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
- * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
- * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
- * weight above 0, and stays undefined where none is.
+ * Folds deltas into one pose by a kit's arithmetic, with no mix and no clock. It folds them in
+ * order, and gives what a mix gives for voices contributing these deltas at these weights. Each
+ * channel starts at its rest, a weight (default 1, held to 0..1) fades a delta toward rest, and the
+ * pose is clamped to each channel's bounds. A channel with no rest takes the last delta a mix's
+ * default band switches on, any weight above 0, and stays undefined where none is.
  *
  * @category channel
  */

package/dist/stack.js

@@ -2,11 +2,11 @@ import { STOCK_BAND } from './channels.js';
 import { copy, first } from './clone.js';
 import { bound, merged } from './fold.js';
 /**
- * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
- * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
- * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
- * weight above 0, and stays undefined where none is.
+ * Folds deltas into one pose by a kit's arithmetic, with no mix and no clock. It folds them in
+ * order, and gives what a mix gives for voices contributing these deltas at these weights. Each
+ * channel starts at its rest, a weight (default 1, held to 0..1) fades a delta toward rest, and the
+ * pose is clamped to each channel's bounds. A channel with no rest takes the last delta a mix's
+ * default band switches on, any weight above 0, and stays undefined where none is.
  *
  * @category channel
  */

package/dist/standing.d.ts

@@ -1,5 +1,6 @@
+import type { Cut } from './cut.js';
 import type { Mixer } from './mixer.js';
-import type { Cut, Transport } from './transport.js';
+import type { Transport } from './transport.js';
 /**
  * Throws unless a read back to mix time `t` is exact with no history: every voice plays as it was
  * cued and reads the same whenever it is asked, and no mix on the transport has changed since `t`.

package/dist/standing.js

@@ -1,7 +1,8 @@
+import { mirror } from './ahead.js';
 import { ownBlends } from './blend.js';
 import { relink } from './owner.js';
 import { pin } from './place.js';
-import { mirror, recall, stateAt } from './project.js';
+import { recall, stateAt } from './project.js';
 import { recount } from './roster.js';
 /**
  * Why a voice cannot be read at an earlier time from how it stands now, or undefined where it can:
@@ -28,7 +29,7 @@ function unfit(mix, voice) {
         return 'it plays under an owner';
     // A rest-less channel switches on across a band, by the weights its voice has passed through.
     const steady = typeof spec.weight !== 'function' &&
-        spec.locus === undefined &&
+        spec.role === undefined &&
         !((voice.fade.in ?? 0) > 0) &&
         !((voice.fade.out ?? 0) > 0);
     if (!steady && voice.slots.some((s) => mix.channels[s]?.rest === undefined))

package/dist/store.d.ts

@@ -33,3 +33,12 @@ export declare class Masked<K, V> extends Store<K, V> {
     get(key: K): V | undefined;
     delete(key: K): void;
 }
+/** A store that fills a missing entry from `make` on first ask. */
+export declare class Filled<K, V> extends Store<K, V> {
+    private readonly make;
+    /** Keys deleted here, which are made afresh by whoever asks and never again by `make`. */
+    private gone;
+    constructor(make: (key: K) => V | undefined);
+    get(key: K): V | undefined;
+    delete(key: K): void;
+}

package/dist/store.js

@@ -89,3 +89,27 @@ export class Masked extends Store {
 const none = Symbol('none');
 /** A Map's key equality, SameValueZero: NaN finds NaN. */
 const same = (a, b) => a === b || Object.is(a, b);
+/** A store that fills a missing entry from `make` on first ask. */
+export class Filled extends Store {
+    make;
+    /** Keys deleted here, which are made afresh by whoever asks and never again by `make`. */
+    gone = null;
+    constructor(make) {
+        super();
+        this.make = make;
+    }
+    get(key) {
+        let v = super.get(key);
+        if (v === undefined && this.gone?.get(key) !== true) {
+            v = this.make(key);
+            if (v !== undefined)
+                super.set(key, v);
+        }
+        return v;
+    }
+    delete(key) {
+        super.delete(key);
+        this.gone ??= new Store();
+        this.gone.set(key, true);
+    }
+}

package/dist/strays.d.ts

@@ -1,5 +1,6 @@
 import type { Mixer } from './mixer.js';
-import type { MotionOwner, Motions } from './motions.js';
+import type { Motions } from './motions.js';
+import type { MotionOwner } from './stretch.js';
 import type { Voice } from './voice.js';
 /** Notes a motion patch that may hold state for a subject no voice playing it reaches. */
 export declare function stray<I, O>(mix: Mixer<I, O>, motion: Motions<I>, subject: I): void;