@msb235/blits 0.7.1 → 0.8.1

package/dist/sample.js

@@ -1,6 +1,6 @@
 import { unbareLane } from './bare.js';
 import { foldNumber } from './channels.js';
-import { clampWeight, passAt, weighed } from './clock.js';
+import { clampWeight, passAt, same, weighed } from './clock.js';
 import { absent } from './numbers.js';
 import { reading } from './reading.js';
 import { between, left, progress } from './tweened.js';
@@ -26,6 +26,7 @@ export function runMotion(lanes, lane, run) {
     // 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 arg = lanes.arg;
     const n = run.n;
     const op = ch.op;
     if (n > 0) {
@@ -48,7 +49,7 @@ export function runMotion(lanes, lane, run) {
         run.watchId = voice.id;
     }
     const own = ease !== undefined && !signal && run.watcher === lanes && run.watchId === voice.id;
-    const folds = n === ch.axes;
+    const folds = n === ch.axes && ch.plain;
     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)
@@ -64,14 +65,14 @@ export function runMotion(lanes, lane, run) {
         }
         const delay = data[o + 0 /* Row.DELAY */];
         const elapsed = elapsedNow - delay;
-        if (elapsed < 0) {
+        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)) {
+            if (!lane.weighed || !same(since, lane.weighedSince)) {
                 lane.fade = lanes.host.envelope(voice, since);
                 lane.weighed = true;
                 lane.weighedSince = since;
@@ -79,11 +80,14 @@ export function runMotion(lanes, lane, run) {
         }
         let w;
         if (signal) {
-            w = lanes.signalled(voice, slot, records[p], elapsed, passAt(elapsed, voice.duration, voice.passes), lane.fade);
-            if (Number.isNaN(w)) {
+            arg[1 /* Arg.ELAPSED */] = elapsed;
+            arg[3 /* Arg.PASS */] = passAt(elapsed, voice.duration, voice.passes);
+            arg[5 /* Arg.FADE */] = lane.fade;
+            if (!lanes.signalled(voice, slot, records[p])) {
                 data[o + 2 /* Row.WEIGHT */] = 0;
                 continue;
             }
+            w = arg[0 /* Arg.WEIGHT */];
         }
         else
             w = flat && !parts ? whole : weighed(voice.weight, lane.fade, lanes.parting(voice, slot));
@@ -102,7 +106,10 @@ export function runMotion(lanes, lane, run) {
             (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);
+            arg[1 /* Arg.ELAPSED */] = elapsed;
+            arg[4 /* Arg.DELAY */] = delay;
+            arg[0 /* Arg.WEIGHT */] = w;
+            move(lanes, lane, run, p, slot, records[p]);
             continue;
         }
         const runs = run.runs;
@@ -123,7 +130,7 @@ export function runMotion(lanes, lane, run) {
             continue;
         }
         if (ease !== undefined) {
-            // A tween's closed form, read straight from its run: release time, seconds, `x0`, `to`.
+            // A tween's closed form, read straight from its run: release time, length, `x0`, `to`.
             const share = left(ease, progress(elapsed, runs[b], runs[b + 2]));
             const x = b + 3;
             const g = x + 2 * n;
@@ -146,8 +153,10 @@ export function runMotion(lanes, lane, run) {
             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);
+        else {
+            arg[0 /* Arg.WEIGHT */] = w;
+            lanes.foldInto(ch, slot, run.value(ms, xs));
+        }
     }
     if (own) {
         lane.bareFill = fills;
@@ -159,14 +168,22 @@ export function runMotion(lanes, lane, run) {
  * 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.
+ * this frame already read keeps the value it read, as the general path's record would. The
+ * subject's voice time, delay and weight are in `Arg`.
  */
-export function move(lanes, lane, run, p, slot, held, elapsed, delay, w) {
+export function move(lanes, lane, run, p, slot, held) {
+    const elapsed = lanes.arg[1 /* Arg.ELAPSED */];
+    const delay = lanes.arg[4 /* Arg.DELAY */];
+    const w = lanes.arg[0 /* Arg.WEIGHT */];
     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);
+    // The general path never samples a voice at weight 0, so the motion neither numbers the subject
+    // nor runs on for it, and `inert` reads the same.
+    if (!(w > 0))
+        return;
     const delta = held.delta;
     if (delta === null ||
         held.probed !== lanes.now ||
@@ -200,16 +217,16 @@ export function move(lanes, lane, run, p, slot, held, elapsed, delay, w) {
             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);
+            lanes.foldRun(ch, slot, run.xs);
         else
-            lanes.foldInto(ch, slot, run.value(ms, run.xs), w);
+            lanes.foldInto(ch, slot, run.value(ms, run.xs));
         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);
+        lanes.foldInto(ch, slot, delta[ch.name]);
 }
 /** The delta a motion voice's last sample for position `p` made, built from `samples`. */
 function sampled(lane, p) {

package/dist/seek.js

@@ -1,10 +1,14 @@
-import { index } from './chain.js';
 import { schedule } from './due.js';
-import { copyHeld, last, leftAt } from './history.js';
+import { copyHeld, last, lastWithin } from './history.js';
 import { laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
-import { move } from './move.js';
+import { Leavings } from './leavings.js';
+import { move, nextFrame } from './move.js';
 import { ownerReading } from './owner.js';
+import { place } from './place.js';
+import { unpull } from './pull.js';
+import { Restored } from './restored.js';
+import { recount } from './roster.js';
 import { refitAll } from './spans.js';
 import { Store } from './store.js';
 import { hostAt, replay } from './tape.js';
@@ -35,44 +39,6 @@ function restore(voice, live, t) {
     h.inputs = inputs;
     return h;
 }
-/**
- * A voice's records after a seek back: each subject's is put back from the records it had, the first
- * time it is asked for, since the subjects a store holds cannot be listed.
- */
-class Restored extends Store {
-    was;
-    make;
-    left;
-    constructor(was, make, left) {
-        super();
-        this.was = was;
-        this.make = make;
-        this.left = left;
-    }
-    /** Subjects whose record has been put back or deleted, which `left` no longer answers for. */
-    settled = new Store();
-    get(key) {
-        const v = super.get(key);
-        if (v !== undefined)
-            return v;
-        // A subject that left after the moment sought had the record it left with, whatever it has now.
-        const kept = this.settled.get(key) === undefined ? this.left(key) : undefined;
-        this.settled.set(key, true);
-        const live = kept ?? this.was.get(key);
-        if (live === undefined)
-            return undefined;
-        this.was.delete(key);
-        const made = this.make(live);
-        if (made !== undefined)
-            super.set(key, made);
-        return made;
-    }
-    delete(key) {
-        super.delete(key);
-        this.was.delete(key);
-        this.settled.set(key, true);
-    }
-}
 /** Takes a voice cued after the moment sought out of the mix, until the tape cues it again. */
 function park(mix, voice) {
     const owner = voice.owner;
@@ -86,34 +52,27 @@ function park(mix, voice) {
         motion.owner = null;
     voice.park();
 }
-/** Puts a voice's controls and records back as they stood at mix time `t`. */
-function restoreVoice(voice, t) {
+/** Puts a voice's controls and records back as they stood at mix time `t`, the end of frame `seq`. */
+function restoreVoice(mix, voice, t, seq) {
+    const cut = { seq, strict: false };
     const log = voice.log;
-    const c = last(log, t, true) ?? log[0];
+    const c = lastWithin(log, cut) ?? log[0];
     log.length = log.indexOf(c) + 1;
-    voice.anchorNow = c.anchorNow;
-    voice.anchorElapsed = c.anchorElapsed;
-    voice.rate = c.rate;
-    voice.ramp = c.ramp;
-    voice.weight = c.weight;
-    voice.out = c.out;
-    voice.start = c.start;
-    voice.outAt = c.outAt;
-    voice.outOver = c.outOver;
-    voice.outSet = c.outSet;
-    if (voice.reopen(t) && voice.owner?.holding)
+    voice.take(c);
+    if (voice.reopen(seq) && voice.owner?.holding)
         voice.owner.holding.played--;
     voice.doneAt = Number.POSITIVE_INFINITY;
+    voice.doneSeq = Number.POSITIVE_INFINITY;
     if (voice.parts !== null) {
         for (const [subject, r] of voice.parts)
-            if (r.at > t)
+            if (r.seq > seq)
                 voice.parts.delete(subject);
         if (voice.parts.size === 0)
             voice.parts = null;
     }
     if (voice.parted !== null) {
-        for (const [subject, at] of voice.parted)
-            if (at > t)
+        for (const [subject, p] of voice.parted)
+            if (p.seq > seq)
                 voice.parted.delete(subject);
         if (voice.parted.size === 0)
             voice.parted = null;
@@ -127,30 +86,43 @@ function restoreVoice(voice, t) {
     voice.unreached = null;
     voice.unreachedBits = null;
     voice.seeks++;
-    const left = voice.left;
-    voice.left = left === null ? null : left.filter((e) => e.at <= t);
-    const future = left === null ? [] : left.filter((e) => e.at > t);
-    voice.subjects = new Restored(voice.subjects, (live) => {
-        const h = restore(voice, live, t);
-        if (h === undefined)
+    const left = voice.left?.all() ?? [];
+    voice.left = Leavings.from(left.filter((e) => e.seq <= seq));
+    const future = Leavings.from(left.filter((e) => e.seq > seq));
+    let records = voice.subjects;
+    if (!(records instanceof Restored)) {
+        records = new Restored(records, (live, least, top) => {
+            const h = restore(voice, live, least);
+            if (h === undefined)
+                return h;
+            if (h.reaches)
+                voice.seen++;
+            if (h.rested)
+                voice.restedCount++;
+            if (!(h.since <= least)) {
+                // Kept while its origin was still ahead: where the controls put back place it now.
+                h.since = mix.sinceOf(voice, h.delay);
+                h.shown = mix.shownOf(voice, h.since);
+                if (h.ticks === 0 && h.stepped > h.since)
+                    h.stepped = h.since;
+            }
+            if (!(h.since <= top)) {
+                voice.early ??= [];
+                voice.early.push(h);
+            }
             return h;
-        if (h.reaches)
-            voice.seen++;
-        if (h.rested)
-            voice.restedCount++;
-        if (voice.state === 'pending') {
-            voice.early ??= [];
-            voice.early.push(h);
-        }
-        return h;
-    }, (key) => leftAt(future, key, t));
+        });
+        voice.subjects = records;
+    }
+    records.back(t, cut, future);
 }
 /** Each voice's state at mix time `t`, once every clock above it is back where it was. */
 function stateAt(voice, t) {
+    // A fade begins at once, even one whose ramp starts later, at the voice's start.
+    if (voice.out !== null)
+        return 'fading';
     if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
         return 'pending';
-    if (voice.out !== null && voice.out.at <= t)
-        return 'fading';
     if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
         return 'frozen';
     return 'live';
@@ -172,34 +144,43 @@ export function seek(transport, t) {
     if (!(t >= transport.born))
         throw new Error(`blits: ${t} is older than this mix's history reaches`);
     const unpaged = cover(transport, t);
-    if (t >= transport.now)
-        replay(transport, () => t);
-    // Under the rate the recorded calls up to `t` set, ahead; behind, under the rate it had then.
-    const u = hostAt(transport, t);
-    if (!Number.isFinite(u))
-        throw new RangeError(`blits: the mix's rate never reaches ${t}`);
     if (t >= transport.now) {
+        // Ahead, under the rate the recorded calls up to `t` set, past any frames rate 0 held at `t`.
+        const last = replay(transport, (at) => (transport.pace === null ? at : transport.pace.reading(at)) <= t);
+        const u = Number.isNaN(last) ? hostAt(transport, t) : Math.max(last, hostAt(transport, t));
+        if (!Number.isFinite(u))
+            throw new RangeError(`blits: the mix's rate never reaches ${t}`);
         transport.u = u;
         for (const m of transport.members)
             move(m, t);
     }
     else {
-        const n = tape.depthAt(t);
-        if (n < tape.undoDepth())
-            tape.goto(n);
-        transport.undrop(t);
-        // What history kept after `t` is let go; the tape holds the calls that made it.
-        transport.announced = transport.announced.filter((a) => a.made <= t);
-        transport.pace?.cut(u);
+        const frame = transport.frames.at(t);
+        if (frame === undefined)
+            throw new Error(`blits: ${t} is older than this mix's history reaches`);
+        // On the frame itself, its own host time: rate 0 may have held the clock there for several.
+        const u = frame.at === t ? frame.u : hostAt(transport, t);
+        const seq = frame.seq;
+        tape.goto(tape.depthAt(u));
+        transport.undrop(seq);
+        // What history kept after the frame is let go; the tape holds the calls that made it.
+        transport.announced = transport.announced.filter((a) => a.seq <= seq);
+        transport.frames.set(transport.frames.all().filter((f) => f.seq <= seq));
+        if (transport.pacedSeq > seq) {
+            transport.pace = null;
+            transport.pacedSeq = Number.POSITIVE_INFINITY;
+        }
+        else
+            transport.pace?.cut(u);
         transport.u = u;
         transport.now = t;
         for (const m of transport.members)
-            back(m, t);
-        cut(transport, t, unpaged);
+            back(m, t, seq, frame.at < t);
+        cut(transport, seq, unpaged);
     }
+    transport.tick(t);
     // The host's clock reads on from here: its next sync reads `t` plus its time since its last.
-    transport.offset = transport.last - u;
-    transport.u = u;
+    transport.offset = transport.last - transport.u;
     transport.kept();
     for (const m of transport.members) {
         m.stir();
@@ -209,8 +190,11 @@ export function seek(transport, t) {
                 b.sought();
     }
 }
-/** Puts one mix back as it stood at the end of frame `t`, its transport already there. */
-function back(mix, t) {
+/**
+ * Puts one mix back as it stood at mix time `t`, the end of frame `seq`, its transport already
+ * there; `on` past that frame's own time, where it moves on to `t`.
+ */
+function back(mix, t, seq, on) {
     const all = [...mix.cued, ...mix.gone].sort((a, b) => a.id - b.id);
     const kept = [];
     const gone = [];
@@ -220,14 +204,14 @@ function back(mix, t) {
         if (voice.motion !== undefined)
             motions.add(voice.motion);
     for (const voice of all)
-        if (voice.cuedAt > t)
+        if (voice.cuedSeq > seq)
             park(mix, voice);
-        else if (voice.doneAt <= t)
+        else if (voice.doneSeq <= seq)
             gone.push(voice);
         else
             kept.push(voice);
     for (const voice of kept)
-        restoreVoice(voice, t);
+        restoreVoice(mix, voice, t, seq);
     for (const voice of kept)
         voice.state = stateAt(voice, t);
     mix.cued = kept;
@@ -242,28 +226,17 @@ function back(mix, t) {
     if (oldLanes !== null)
         mix.lanes = new Lanes(laneHost(mix));
     mix.chains = new Store();
-    mix.named = new Store();
-    mix.naming = 0;
-    mix.general = [];
-    for (const voice of kept)
-        index(mix, voice);
     mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
-    mix.loci = kept.filter((v) => v.spec.locus !== undefined).length;
-    mix.anchored = kept.filter((v) => v.spec.anchor !== undefined).length;
+    recount(mix);
     mix.parters.clear();
     for (const voice of [...kept, ...gone])
         if (voice.parts !== null || voice.parted !== null)
             mix.parters.add(voice);
-    mix.steps.push(null, ++mix.version);
     mix.relinks++;
     mix.pose = new Store();
     if (mix.restStamps !== null)
         mix.restStamps = new Store();
-    mix.pulled = [];
-    mix.pulledHeads = [];
-    mix.pulledSlots = new Int32Array(0);
-    mix.pulledVersion = Number.NaN;
-    mix.pulledRelinks = -1;
+    unpull(mix);
     for (const voice of [...kept, ...gone]) {
         voice.unreached = null;
         voice.unreachedBits = null;
@@ -290,10 +263,10 @@ function back(mix, t) {
     for (const motion of motions) {
         if (oldLanes !== null && motion.watcher === oldLanes)
             motion.watcher = null;
-        motion.rewind(t);
+        motion.rewind(seq);
     }
     // What history kept after `t` is let go; the tape holds the calls that made it.
-    mix.hostLog = mix.hostLog.filter((e) => e.at <= t);
+    mix.hostLog = mix.hostLog.filter((e) => e.seq <= seq);
     mix.sent = mix.sent.filter((e) => e.timestamp <= t);
     mix.sentTo = t;
     mix.pins = null;
@@ -307,5 +280,15 @@ function back(mix, t) {
     for (const voice of kept)
         schedule(mix, voice);
     mix.stir();
-    move(mix, t);
+    // On the frame's own time its move is behind it: a second would land what the next frame does.
+    if (on)
+        move(mix, t);
+    else {
+        mix.frame = nextFrame();
+        mix.reducedNow = mix.reduced;
+        // A voice history let go of may have placed an anchor then: placed again from what it holds.
+        const ms = mix.opts.history.ms;
+        if (mix.anchored > 0 && mix.transport.forgotTo >= t - ms)
+            place(mix);
+    }
 }

package/dist/shared.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export declare function shared<K extends object, V>(name: string): WeakMap<K, V>;

package/dist/shared.js

@@ -0,0 +1,15 @@
+/**
+ * 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
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export function shared(name) {
+    const key = Symbol.for(`@msb235/blits/${name}`);
+    const g = globalThis;
+    let map = g[key];
+    if (map === undefined) {
+        map = new WeakMap();
+        g[key] = map;
+    }
+    return map;
+}

package/dist/signals.d.ts

@@ -1,4 +1,6 @@
-import type { Signal } from './types.js';
+import type { 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;
 /**
  * The loudest of several signals.
  *
@@ -6,7 +8,26 @@ import type { Signal } from './types.js';
  */
 export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]): Signal<I, H>;
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be 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
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @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;
+};
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
@@ -14,7 +35,7 @@ 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
+ * 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.

package/dist/signals.js

@@ -1,5 +1,16 @@
+import { reading } from './reading.js';
+/** Input signals whose every change bumps `reading.inputs`: `input`'s, and those built only on them. */
+const told = new WeakSet();
+/** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
+export const heard = (signal) => told.has(signal);
 const inputOf = (signals) => signals.some((s) => s.input);
-const marked = (read, input) => (input ? Object.assign(read, { input: true }) : read);
+const marked = (read, of) => {
+    if (!inputOf(of))
+        return read;
+    if (of.every((s) => !s.input || told.has(s)))
+        told.add(read);
+    return Object.assign(read, { input: true });
+};
 /**
  * The loudest of several signals.
  *
@@ -14,19 +25,46 @@ export function peak(...signals) {
                 out = v;
         }
         return out;
-    }, inputOf(signals));
+    }, signals);
 }
+const touch = () => {
+    reading.inputs++;
+};
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be 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
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @category signal
+ */
+export function input(read, of) {
+    if (of !== undefined)
+        return Object.assign(marked(read, of), { touch });
+    told.add(read);
+    return Object.assign(read, { input: true, touch });
+}
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
 export function level(initial = 0) {
     let value = initial;
-    return Object.assign(() => value, {
-        input: true,
+    return Object.assign(input(() => value), {
         set(v) {
+            if (Object.is(v, value))
+                return;
             value = v;
+            touch();
         },
     });
 }
@@ -38,7 +76,7 @@ const firstSight = (target, from, setting) => from === undefined || !Number.isFi
     ? { value: target, seen: Number.NaN }
     : { value: from, seen: setting.timestamp };
 /**
- * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
+ * 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.
@@ -56,7 +94,8 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
             const gap = target - held.value;
             const ms = gap > 0 ? riseMs : fallMs;
             if (ms > 0) {
-                const step = (setting.timestamp - held.seen) / ms;
+                // No longer than `dt`, which `maxDt` caps, as every step is.
+                const step = Math.min(setting.timestamp - held.seen, setting.dt) / ms;
                 next = gap > 0 ? Math.min(target, held.value + step) : Math.max(target, held.value - step);
             }
         }
@@ -64,7 +103,7 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The exponential counterpart to `slew`: closes the same fraction of the distance to its input in
@@ -86,7 +125,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         if (!Number.isNaN(held.seen) && Number.isFinite(setting.dt)) {
             const ms = target > held.value ? riseMs : fallMs;
             if (ms > 0) {
-                const gap = setting.timestamp - held.seen;
+                const gap = Math.min(setting.timestamp - held.seen, setting.dt);
                 next = held.value + (target - held.value) * (1 - Math.exp(-gap / ms));
                 if (Math.abs(target - next) <= floor)
                     next = target;
@@ -96,7 +135,7 @@ export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
         held.seen = setting.timestamp;
         return next;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }
 /**
  * The other half of the pair: a band, not an edge. It drops at `off`, passes at `on`, and between
@@ -116,5 +155,5 @@ export function gate(of, band) {
         }
         return held.on ? 1 : 0;
     };
-    return marked(read, inputOf([of]));
+    return marked(read, [of]);
 }