@msb235/blits 0.4.0 → 0.5.0

package/dist/rows.js

@@ -0,0 +1,282 @@
+import { Crowd, none } from './crowd.js';
+import { KeyRows } from './keyrows.js';
+import { reach } from './meet.js';
+import { motionOf } from './motion.js';
+import { open } from './qualify.js';
+import { settle } from './sample.js';
+/** Whether two crowds' channels are the same list. */
+function same(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** Takes a crowd row off its subject, to be placed again if a probe meets it again. */
+export function unplace(lanes, c, p) {
+    const slot = c.list[p];
+    if (c.idle && slot >= 0)
+        reach(lanes, slot, -1);
+    c.list[p] = -1;
+    c.records[p] = undefined;
+    c.deltas[p] = null;
+    const f = p * c.stride + 0 /* Hot.FLAGS */;
+    c.hot[f] = c.hot[f] & ~16 /* Flag.PLACED */;
+    const o = p * 8 /* Row.STRIDE */;
+    c.data[o + 4 /* Row.MSLOT */] = -1;
+    c.data[o + 5 /* Row.SAMPLED */] = -1;
+    c.data[o + 7 /* Row.MET */] = 0;
+}
+/**
+ * Whether every voice qualifying for a crowd has its row, and every row's voice either qualified
+ * or is done, so the crowds stand as a rebuild would leave them, departed rows aside.
+ */
+export function sameCrowds(lanes, members) {
+    let live = 0;
+    for (const v of members) {
+        if (!lanes.crowdOf.has(v.id))
+            return false;
+        live++;
+    }
+    let rows = 0;
+    for (const [id, c] of lanes.crowdOf) {
+        const p = c.rowOf.get(id);
+        if (c.voices[p].state !== 'done')
+            rows++;
+    }
+    return rows === live;
+}
+/**
+ * Rebuilds the crowds from the voices that belong in one, in voice order: a voice already in a
+ * crowd keeps its row's numbers, a new one gets a row a probe will place, and a voice no longer in
+ * one is handed back to the general path, as a lane's voice is when it leaves.
+ */
+export function regroup(lanes, members) {
+    const keep = new Set(members.map((v) => v.id));
+    for (const c of lanes.crowds)
+        for (let p = 0; p < c.size; p++) {
+            const v = c.voices[p];
+            if (!keep.has(v.id) || v.state === 'done')
+                leaveCrowd(lanes, c, p);
+        }
+    const old = lanes.crowds;
+    const was = new Map(lanes.crowdOf);
+    lanes.crowds = [];
+    lanes.crowdOf.clear();
+    lanes.overlap = false;
+    for (const v of members) {
+        const from = was.get(v.id);
+        join(lanes, v, from, from?.rowOf.get(v.id), old);
+    }
+    if (lanes.crowds.length === 0) {
+        lanes.lawsByKey.clear();
+        lanes.lastLaw = null;
+    }
+}
+/**
+ * Gives a voice the next row of its channel's crowd, made if there is none: a copy of the row it
+ * had in `from` at `at`, or a new one. `old` holds the crowds being replaced, whose idle state a
+ * new crowd on the same channel keeps. Rows stay in voice order only because voices join in it.
+ */
+export function join(lanes, v, from, at, old) {
+    const chans = v.slots.map((s) => lanes.bySlot[s]);
+    let c = lanes.crowds.find((o) => same(o.chans, chans));
+    if (c === undefined) {
+        c = new Crowd(chans, chans[0].axes);
+        const names = chans.map((ch) => ch.name).join(' ');
+        const was = old.find((o) => o.chans.map((ch) => ch.name).join(' ') === names);
+        if (was !== undefined)
+            c.idle = was.idle;
+        for (const o of lanes.crowds)
+            if (o.chans.some((ch) => chans.includes(ch)))
+                lanes.overlap = true;
+        lanes.crowds.push(c);
+    }
+    const p = c.size;
+    c.reserve(p + 1);
+    if (from !== undefined && at !== undefined)
+        copyRow(from, at, c, p);
+    else
+        newRow(lanes, c, p, v);
+    if (c.hot[p * c.stride + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
+        c.hot[p * c.stride + 6 /* Hot.EPOCH */] = open(lanes, v);
+    c.rowOf.set(v.id, p);
+    lanes.crowdOf.set(v.id, c);
+    v.laned = true;
+}
+/** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
+export function retouchRow(lanes, c, p, v) {
+    const h = p * c.stride;
+    if (c.hot[h + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
+        c.hot[h + 6 /* Hot.EPOCH */] = open(lanes, v);
+    c.hot[h + 0 /* Hot.FLAGS */] = c.hot[h + 0 /* Hot.FLAGS */] | 64 /* Flag.VOICE */;
+}
+/**
+ * Compacts every crowd a quarter or more empty rows: each fill walks every row, and at half a
+ * crowd replacing a voice a frame carried as many empty rows as live ones.
+ */
+export function compactSparse(lanes) {
+    for (const c of lanes.crowds)
+        if (c.dead > 64 && c.dead * 4 >= c.size)
+            compact(c);
+}
+/**
+ * Slides a crowd's rows down over the empty ones its departed voices left, in order, so its rows
+ * stay in voice order; a qualify did this by rebuilding every crowd, a dropped frame at 10k rows.
+ */
+function compact(c) {
+    // The rows' stops are copied into a fresh pool, leaving the departed rows' behind.
+    const keys = c.keys;
+    c.keys = new KeyRows();
+    let q = 0;
+    for (let p = 0; p < c.size; p++) {
+        const v = c.voices[p];
+        if (c.rowOf.get(v.id) !== p) {
+            c.odd?.delete(p);
+            continue;
+        }
+        if (q !== p) {
+            copyRow(c, p, c, q, keys);
+            c.odd?.delete(p);
+            c.rowOf.set(v.id, q);
+        }
+        else
+            copyKeys(keys, c, q);
+        q++;
+    }
+    c.list.length = q;
+    c.voices.length = q;
+    c.records.length = q;
+    c.deltas.length = q;
+    c.motions.length = q;
+    c.eases.length = q;
+    c.laws.length = q;
+    c.dead = 0;
+}
+/** A crowd voice left: its row stays, empty, until the crowds are next rebuilt. */
+export function bury(lanes, c, p) {
+    const v = c.voices[p];
+    leaveCrowd(lanes, c, p);
+    c.list[p] = -1;
+    c.records[p] = undefined;
+    c.deltas[p] = null;
+    c.motions[p] = undefined;
+    c.hot[p * c.stride + 0 /* Hot.FLAGS */] = 0;
+    c.rowOf.delete(v.id);
+    lanes.crowdOf.delete(v.id);
+    c.dead++;
+}
+function copyRow(from, p, to, q, keys = from.keys) {
+    from.fix(p);
+    to.list[q] = from.list[p];
+    to.data.set(from.data.subarray(p * 8 /* Row.STRIDE */, (p + 1) * 8 /* Row.STRIDE */), q * 8 /* Row.STRIDE */);
+    to.hot.set(from.hot.subarray(p * from.stride, (p + 1) * from.stride), q * to.stride);
+    copyKeys(keys, to, q);
+    if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0)
+        to.stale = true;
+    to.samples.set(from.samples.subarray(p * from.axes, (p + 1) * from.axes), q * to.axes);
+    to.deltas[q] = from.deltas[p] ?? null;
+    to.records[q] = from.records[p];
+    to.voices[q] = from.voices[p];
+    to.motions[q] = from.motions[p];
+    to.eases[q] = from.eases[p];
+    to.laws[q] = from.laws[p];
+    const odd = from.odd?.get(p);
+    if (odd !== undefined) {
+        to.odd ??= new Map();
+        to.odd.set(q, odd);
+    }
+}
+/** Copies row `q`'s stops, as its `hot` holds their place in `keys`, into its crowd's pool. */
+function copyKeys(keys, c, q) {
+    const h = q * c.stride;
+    if ((c.hot[h + 0 /* Hot.FLAGS */] & 512 /* Flag.FLAT */) !== 0)
+        c.hot[h + 8 /* Hot.AT */] = c.keys.copy(keys, c.hot[h + 8 /* Hot.AT */]);
+}
+function newRow(lanes, c, p, v) {
+    const run = motionOf(v.patch);
+    const h = p * c.stride;
+    c.hot.fill(0, h, h + c.stride);
+    const at = v.built === null ? -1 : c.keys.add(v.built, c.chans);
+    if (at >= 0) {
+        c.hot[h + 8 /* Hot.AT */] = at;
+        c.hot[h + 10 /* Hot.X0 */] = v.duration;
+        c.hot[h + 9 /* Hot.MS */] = v.passes;
+    }
+    c.restale(p, 64 /* Flag.VOICE */ |
+        (run === undefined ? 0 : 128 /* Flag.MOTION */) |
+        (run?.ease === undefined ? 0 : 1024 /* Flag.TWEEN */) |
+        (at >= 0 ? 512 /* Flag.FLAT */ : 0));
+    c.hot[h + 7 /* Hot.ID */] = v.id;
+    c.list[p] = -1;
+    const o = p * 8 /* Row.STRIDE */;
+    c.data.fill(0, o, o + 8 /* Row.STRIDE */);
+    c.data[o + 4 /* Row.MSLOT */] = -1;
+    c.data[o + 5 /* Row.SAMPLED */] = -1;
+    c.deltas[p] = null;
+    c.records[p] = undefined;
+    c.voices[p] = v;
+    c.motions[p] = run;
+    if (run === undefined) {
+        c.laws[p] = none;
+        c.eases[p] = undefined;
+        return;
+    }
+    c.laws[p] = lawOf(lanes, run);
+    c.eases[p] = run.ease;
+    // A lane sharing the patch keeps no samples while it watches it: have it keep them first.
+    const watching = run.watcher === lanes ? lanes.byId.get(run.watchId) : undefined;
+    if (watching !== undefined)
+        for (let q = 0; q < watching.list.length; q++)
+            watching.fix(q);
+    run.watcher = lanes;
+    run.watchId = v.id;
+}
+/** A patch's law, as the one array every crowd row with the same law shares. */
+function lawOf(lanes, run) {
+    // Most crowds' voices share one law, so the last one found is checked before any key is made.
+    const last = lanes.lastLaw;
+    if (last !== null && run.hasLaw(last))
+        return last;
+    const law = lawKeyed(lanes, run);
+    lanes.lastLaw = law;
+    return law;
+}
+function lawKeyed(lanes, run) {
+    const law = run.law();
+    const key = law.join(' ');
+    const known = lanes.lawsByKey.get(key);
+    if (known !== undefined)
+        return known;
+    lanes.lawsByKey.set(key, law);
+    return law;
+}
+/** Hands a crowd voice back to the general path, as `leave` does a lane's. */
+function leaveCrowd(lanes, c, p) {
+    const slot = c.list[p];
+    const rec = c.records[p];
+    if (slot >= 0) {
+        if (c.idle)
+            reach(lanes, slot, -1);
+        const w = reportedRow(lanes, c, p, slot);
+        if (rec !== undefined && w !== undefined)
+            rec.weight = w;
+        if (rec !== undefined && c.motions[p] !== undefined)
+            settle(lanes, c, p, slot, rec);
+    }
+    const run = c.motions[p];
+    const v = c.voices[p];
+    if (run !== undefined && run.watcher === lanes && run.watchId === v.id)
+        run.watcher = null;
+    v.laned = false;
+}
+/** A crowd row's weight as `reported` reads a lane position's. */
+export function reportedRow(lanes, c, p, slot) {
+    const o = slot * 6 /* Per.SLOT */;
+    if (!(lanes.per[o + 3 /* Per.LANE_PROBE */] > lanes.per[o + 4 /* Per.GENERAL_PROBE */]))
+        return undefined;
+    if (c.list[p] !== slot)
+        return undefined;
+    return c.data[p * 8 /* Row.STRIDE */ + (lanes.per[o + 5 /* Per.LANE_FILL */] === lanes.fills ? 2 /* Row.WEIGHT */ : 3 /* Row.PROBED */)];
+}

package/dist/sample.d.ts

@@ -0,0 +1,21 @@
+import { type Lane, type Positions } from './lane.js';
+import type { Lanes } from './lanes.js';
+import type { Motions } from './motion.js';
+import type { Subject } from './voice.js';
+/**
+ * A motion voice's fill: what `one` and `move` do for each subject, in one loop for the common
+ * case, a subject not yet probed this frame with nothing pending, and through `move` for the rest.
+ */
+export declare function runMotion<I, O>(lanes: Lanes<I, O>, lane: Lane<I, O>, run: Motions<I>): void;
+/**
+ * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
+ * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
+ * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
+ * this frame already read keeps the value it read, as the general path's record would.
+ */
+export declare function move<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, run: Motions<I>, p: number, slot: number, held: Subject<unknown>, elapsed: number, delay: number, w: number): void;
+/**
+ * A probe this frame read a motion voice's value for the subject from an earlier fill: write onto
+ * its record what the general path's sample would have, so a later read this frame reuses it.
+ */
+export declare function settle<I, O>(lanes: Lanes<I, O>, lane: Positions<I, O>, p: number, slot: number, held: Subject<unknown>): void;

package/dist/sample.js

@@ -0,0 +1,232 @@
+import { unbareLane } from './bare.js';
+import { foldNumber } from './channels.js';
+import { clampWeight, passAt, weighed } from './clock.js';
+import { absent } from './numbers.js';
+import { reading } from './reading.js';
+import { between, left, progress } from './tweened.js';
+/**
+ * A motion voice's fill: what `one` and `move` do for each subject, in one loop for the common
+ * case, a subject not yet probed this frame with nothing pending, and through `move` for the rest.
+ */
+export function runMotion(lanes, lane, run) {
+    const voice = lane.voice;
+    const data = lane.data;
+    const per = lanes.per;
+    const list = lane.list;
+    const records = lane.records;
+    const ch = lane.chans[0];
+    const fills = lanes.fills;
+    const from = lanes.frameProbes;
+    const seeks = voice.seeks;
+    const elapsedNow = voice.elapsedAt(lanes.now);
+    const flat = lane.flat;
+    const parts = voice.parts !== null;
+    const signal = typeof voice.spec.weight === 'function';
+    // On a frame's first fill no probe has read a subject yet, so none needs `move` for that.
+    const probed = lanes.probes !== from;
+    const whole = clampWeight(voice.weight);
+    const n = run.n;
+    const op = ch.op;
+    if (n > 0) {
+        if (lane.axes !== n) {
+            lane.axes = n;
+            lane.samples = new Float64Array(0);
+        }
+        if (list.length * n > lane.samples.length) {
+            const grown = new Float64Array(Math.max(list.length, (lane.samples.length / n) * 2, 4) * n);
+            grown.set(lane.samples);
+            lane.samples = grown;
+        }
+    }
+    const samples = lane.samples;
+    const xs = run.xs;
+    const ease = run.ease;
+    // A tween whose stretches tell the lane before they change keeps no sample: see `unbareLane`.
+    if (run.watcher === null) {
+        run.watcher = lanes;
+        run.watchId = voice.id;
+    }
+    const own = ease !== undefined && !signal && run.watcher === lanes && run.watchId === voice.id;
+    const folds = n === ch.axes;
+    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)
+            return;
+        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 */];
+        const delay = data[o + 0 /* Row.DELAY */];
+        const elapsed = elapsedNow - delay;
+        if (elapsed < 0) {
+            unbareLane(lane, p);
+            data[o + 2 /* Row.WEIGHT */] = 0;
+            continue;
+        }
+        if (!flat) {
+            const since = data[o + 1 /* Row.SINCE */];
+            if (!lane.weighed || !Object.is(since, lane.weighedSince)) {
+                lane.fade = lanes.host.envelope(voice, since);
+                lane.weighed = true;
+                lane.weighedSince = since;
+            }
+        }
+        let w;
+        if (signal) {
+            w = lanes.signalled(voice, slot, records[p], elapsed, passAt(elapsed, voice.duration, voice.passes), lane.fade);
+            if (Number.isNaN(w)) {
+                data[o + 2 /* Row.WEIGHT */] = 0;
+                continue;
+            }
+        }
+        else
+            w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
+        data[o + 2 /* Row.WEIGHT */] = w;
+        if (data[o + 7 /* Row.MET */] === 0) {
+            if (Number.isNaN(records[p].probed)) {
+                unbareLane(lane, p);
+                lanes.late.push(slot);
+                continue;
+            }
+            data[o + 7 /* Row.MET */] = 1;
+        }
+        const ms = data[o + 4 /* Row.MSLOT */];
+        const b = ms < 0 ? -1 : run.bareAt(ms);
+        if (b < 0 ||
+            (probed &&
+                (per[q + 3 /* Per.LANE_PROBE */] > from ||
+                    per[q + 4 /* Per.GENERAL_PROBE */] > from))) {
+            move(lanes, lane, run, p, slot, records[p], elapsed, delay, w);
+            continue;
+        }
+        const runs = run.runs;
+        if (own && folds && run.scalar(ms) === ch.scalar) {
+            if (data[o + 5 /* Row.SAMPLED */] !== -2 /* Sampled.BARE */) {
+                data[o + 5 /* Row.SAMPLED */] = -2 /* Sampled.BARE */;
+                lane.deltas[p] = null;
+            }
+            const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
+            if (w <= 0)
+                continue;
+            const values = ch.values;
+            const base = slot * n;
+            const x = b + 3;
+            const g = x + 2 * n;
+            for (let a = 0; a < n; a++)
+                values[base + a] = foldNumber(op, values[base + a], between(runs[x + a], runs[g + a], share), w);
+            continue;
+        }
+        if (ease !== undefined) {
+            // A tween's closed form, read straight from its run: release time, seconds, `x0`, `to`.
+            const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
+            const x = b + 3;
+            const g = x + 2 * n;
+            for (let a = 0; a < n; a++)
+                xs[a] = between(runs[x + a], runs[g + a], share);
+        }
+        else
+            run.sampleBare(ms, elapsed, xs, run.vs);
+        for (let a = 0; a < n; a++)
+            samples[p * n + a] = xs[a];
+        if (lane.deltas[p] !== null)
+            lane.deltas[p] = null;
+        data[o + 5 /* Row.SAMPLED */] = fills;
+        data[o + 6 /* Row.SEEKS */] = seeks;
+        if (w <= 0)
+            continue;
+        if (folds && run.scalar(ms) === ch.scalar) {
+            const values = ch.values;
+            const base = slot * n;
+            for (let a = 0; a < n; a++)
+                values[base + a] = foldNumber(op, values[base + a], xs[a], w);
+        }
+        else
+            lanes.foldInto(ch, slot, run.value(ms, xs), w);
+    }
+    if (own) {
+        lane.bareFill = fills;
+        lane.bareElapsed = elapsedNow;
+        lane.bareSeeks = seeks;
+    }
+}
+/**
+ * A motion voice's value for a subject, sampled from the patch's state as its `at` would, but only
+ * where that sample changes nothing: one with a change to stamp, commit or let go of goes to the
+ * general path, which samples it if and when a probe asks, as it would with no lanes. A probe
+ * this frame already read keeps the value it read, as the general path's record would.
+ */
+export function move(lanes, lane, run, p, slot, held, elapsed, delay, w) {
+    const voice = lane.voiceAt(p);
+    const data = lane.data;
+    const o = p * 8 /* Row.STRIDE */;
+    const ch = lane.chans[0];
+    settle(lanes, lane, p, slot, held);
+    const delta = held.delta;
+    if (delta === null ||
+        held.probed !== lanes.now ||
+        held.seeks !== voice.seeks ||
+        !lanes.probedThisFrame(slot)) {
+        let ms = data[o + 4 /* Row.MSLOT */];
+        if (ms < 0) {
+            const subject = lanes.subjectAt(slot);
+            if (subject === absent)
+                return;
+            ms = run.slot(subject);
+            data[o + 4 /* Row.MSLOT */] = ms;
+            lane.numbered(p, ms);
+        }
+        if (lanes.keeps)
+            lanes.host.horizon(voice, delay);
+        else
+            reading.horizon = Number.POSITIVE_INFINITY;
+        if (!run.quiet(ms, elapsed)) {
+            lanes.late.push(slot);
+            return;
+        }
+        run.sample(ms, elapsed, run.xs, run.vs);
+        // Kept as numbers, not a delta: one is built only if a probe this frame asks for it.
+        const n = run.n;
+        lane.keep(p, run.xs, n);
+        lane.deltas[p] = null;
+        data[o + 5 /* Row.SAMPLED */] = lanes.fills;
+        data[o + 6 /* Row.SEEKS */] = voice.seeks;
+        if (w <= 0)
+            return;
+        // A sample of other axes than the channel's folds as the general path folds it.
+        if (n === ch.axes && run.scalar(ms) === ch.scalar)
+            lanes.foldRun(ch, slot, run.xs, w);
+        else
+            lanes.foldInto(ch, slot, run.value(ms, run.xs), w);
+        return;
+    }
+    lane.deltas[p] = delta;
+    data[o + 5 /* Row.SAMPLED */] = lanes.fills;
+    data[o + 6 /* Row.SEEKS */] = voice.seeks;
+    if (w > 0)
+        lanes.foldInto(ch, slot, delta[ch.name], w);
+}
+/** The delta a motion voice's last sample for position `p` made, built from `samples`. */
+function sampled(lane, p) {
+    const run = lane.motionAt(p);
+    lane.kept(p, run.xs);
+    const ms = lane.data[p * 8 /* Row.STRIDE */ + 4 /* Row.MSLOT */];
+    const delta = { [lane.chans[0].name]: run.value(ms, run.xs) };
+    lane.deltas[p] = delta;
+    return delta;
+}
+/**
+ * A probe this frame read a motion voice's value for the subject from an earlier fill: write onto
+ * its record what the general path's sample would have, so a later read this frame reuses it.
+ */
+export function settle(lanes, lane, p, slot, held) {
+    lane.fix(p);
+    const o = p * 8 /* Row.STRIDE */;
+    if ((held.probed === lanes.now && held.seeks === lane.data[o + 6 /* Row.SEEKS */]) ||
+        !(lanes.per[slot * 6 /* Per.SLOT */ + 3 /* Per.LANE_PROBE */] > lanes.frameProbes) ||
+        lane.data[o + 5 /* Row.SAMPLED */] !== lanes.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */])
+        return;
+    held.delta = lane.deltas[p] ?? sampled(lane, p);
+    held.probed = lanes.now;
+    held.seeks = lane.data[o + 6 /* Row.SEEKS */];
+}

package/dist/signals.d.ts

@@ -4,47 +4,50 @@ import type { Signal } from './types.js';
  *
  * @category signal
  */
-export declare function peak<I>(...signals: readonly Signal<I>[]): Signal<I>;
+export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]): Signal<I, H>;
 /**
  * A signal the host writes. klieg's `level`.
  *
  * @category signal
  */
-export declare function level<I>(initial?: number): Signal<I> & {
+export declare function level<I, H = unknown>(initial?: number): Signal<I, H> & {
     set(v: number): void;
 };
 /**
  * The package's one 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.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
  *
  * @category signal
  */
-export declare function slew<I>(of: Signal<I>, { riseMs, fallMs }: {
+export declare function slew<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, from }: {
     riseMs?: number;
     fallMs?: number;
-}): Signal<I>;
+    from?: number;
+}): 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`.
  *
  * @category signal
  */
-export declare function lag<I>(of: Signal<I>, { riseMs, fallMs, floor }: {
+export declare function lag<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs, floor, from, }: {
     riseMs?: number;
     fallMs?: number;
     floor?: number;
-}): Signal<I>;
+    from?: number;
+}): 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.
  *
  * @category signal
  */
-export declare function gate<I>(of: Signal<I>, band: {
+export declare function gate<I, H = unknown>(of: Signal<I, H>, band: {
     on: number;
     off: number;
-} | number): Signal<I>;
+} | number): Signal<I, H>;

package/dist/signals.js

@@ -30,17 +30,19 @@ export function level(initial = 0) {
         },
     });
 }
+/** Where a follower starts for a subject: on its input, or at `from`, seen now so the next frame moves. */
+const firstSight = (target, from, now) => from === undefined ? { value: target, seen: Number.NaN } : { value: from, seen: now };
 /**
  * The package's one 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.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
  *
  * @category signal
  */
-export function slew(of, { riseMs = 0, fallMs = 0 }) {
+export function slew(of, { riseMs = 0, fallMs = 0, from }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
-        const held = setting.keep(read, () => ({ value: target, seen: Number.NaN }));
+        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;
@@ -64,13 +66,14 @@ export function slew(of, { riseMs = 0, fallMs = 0 }) {
  * 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`.
  *
  * @category signal
  */
-export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6 }) {
+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, () => ({ value: target, seen: Number.NaN }));
+        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;

package/dist/store.d.ts

@@ -2,11 +2,18 @@
  * Per-subject storage keyed by identity. Objects go in a WeakMap and are forgotten when the host
  * drops them; anything else — a string id, the unit subject of a mix with no subject dimension —
  * goes in a Map that only `drop` and `clear` empty, which is why a host keying by value should
- * call `drop`.
+ * call `drop`. Each map is made when first written, since a mix holds a store per voice and patch;
+ * until then it is a shared empty one, so the field always holds a map.
  */
 export declare class Store<K, V> {
-    private readonly weak;
-    private readonly strong;
+    private weak;
+    private strong;
+    /**
+     * The first key that is not an object, and its value, held here until a second comes: a voice of
+     * one subject keyed by id would otherwise spend a Map's smallest table on it.
+     */
+    private oneKey;
+    private oneValue;
     get(key: K): V | undefined;
     set(key: K, value: V): void;
     has(key: K): boolean;