@msb235/blits 0.13.0 → 0.15.0

package/dist/roles.js

@@ -0,0 +1,158 @@
+import { first } from './clone.js';
+import { open as openRecord } from './everyone.js';
+import { merged, unband } from './fold.js';
+import { roleScratch } from './role.js';
+// V8 reads a local const as a constant, where it reads an import from its module on every call.
+const open = openRecord;
+/**
+ * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
+ * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
+ */
+export function chainFirst(held, sharers, q) {
+    if (held === null)
+        return false;
+    if (q >= sharers.length || held.voice === null)
+        return true;
+    const next = sharers[q];
+    return next.id > held.voice.id;
+}
+/** `foldWith`'s voices with a role in play: each role folds at its first member's place. */
+export function foldRoles(subject, pose, head, laned, dry, except, owed) {
+    const now = this.now;
+    // A patch reading the pose can fold again from inside this one, so each depth has its own.
+    let k = this.roleScratch[this.roleDepth];
+    if (k === undefined) {
+        k = roleScratch(this.channels.length);
+        this.roleScratch[this.roleDepth] = k;
+    }
+    this.roleDepth++;
+    try {
+        k.n = 0;
+        k.m = 0;
+        k.names.length = 0;
+        const sharers = this.sharers;
+        let q = 0;
+        let at = head;
+        while (at !== null || q < sharers.length) {
+            const mine = chainFirst(at, sharers, q);
+            let voice;
+            let rec;
+            if (mine) {
+                rec = at;
+                voice = rec.voice;
+                at = rec.next;
+            }
+            else {
+                voice = sharers[q++];
+                rec = voice.state === 'pending' ? null : voice.everyone;
+            }
+            if (voice === null || rec === null)
+                continue;
+            if (laned && voice.laned && !this.owedBy(owed, voice))
+                continue;
+            if (voice.id === except || voice.state === 'done')
+                continue;
+            const held = rec;
+            if (!mine)
+                open(voice, held, head.slot);
+            const delta = this.read(voice, subject, now, dry, held);
+            if (owed >= 0 && voice.laned)
+                this.lanes.paid(voice.id, owed, held.weight);
+            if (!mine)
+                q = this.shared(voice, head.slot, held, q);
+            if (delta === null)
+                continue;
+            const role = voice.spec.role;
+            let group = -1;
+            if (role !== undefined) {
+                group = k.names.indexOf(role);
+                const m = k.m++;
+                k.mVoices[m] = voice;
+                k.mDeltas[m] = delta;
+                k.mWeights[m] = this.w;
+                if (group >= 0) {
+                    k.mGroups[m] = group;
+                    continue;
+                }
+                group = k.names.length;
+                k.names.push(role);
+                k.mGroups[m] = group;
+            }
+            const n = k.n++;
+            k.voices[n] = voice;
+            k.helds[n] = held;
+            k.deltas[n] = delta;
+            k.weights[n] = role === undefined ? this.w : 0;
+            k.groups[n] = group;
+        }
+        let bands = head.roles;
+        if (bands === null) {
+            bands = new Map();
+            head.roles = bands;
+        }
+        for (let n = 0; n < k.n; n++) {
+            const group = k.groups[n];
+            if (group < 0) {
+                const weight = k.weights[n];
+                if (weight > 0)
+                    this.apply(pose, k.voices[n], k.helds[n], k.deltas[n], weight);
+                else
+                    unband(k.helds[n]);
+                continue;
+            }
+            const weight = this.foldRole(k, group);
+            const name = k.names[group];
+            if (!(weight > 0)) {
+                bands.get(name)?.fill(2);
+                continue;
+            }
+            let on = bands.get(name);
+            if (on === undefined) {
+                on = new Uint8Array(this.channels.length);
+                bands.set(name, on);
+            }
+            for (let t = 0; t < k.touched.length; t++) {
+                const slot = k.touched[t];
+                const value = k.values[slot];
+                k.values[slot] = undefined;
+                const key = this.names[slot];
+                const channel = this.channels[slot];
+                // A channel folds at the weight of the members that wrote it, not the whole role.
+                const taken = k.taken[slot];
+                const w = taken > 1 ? 1 : taken;
+                if (channel.rest !== undefined && channel.scale) {
+                    // pose[key] is the copy of rest this fold made, so it is ours to write into.
+                    pose[key] = channel.fold
+                        ? channel.fold(pose[key], value, w)
+                        : merged(channel, pose[key], channel.scale(value, w));
+                    continue;
+                }
+                const band = on[slot];
+                const passes = this.passes(band === 0 ? undefined : band === 1, w);
+                on[slot] = passes ? 1 : 2;
+                if (passes)
+                    pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
+            }
+        }
+        return pose;
+    }
+    finally {
+        for (let n = 0; n < k.n; n++) {
+            k.voices[n] = null;
+            k.helds[n] = null;
+            k.deltas[n] = null;
+        }
+        for (let m = 0; m < k.m; m++) {
+            k.mVoices[m] = null;
+            k.mDeltas[m] = null;
+        }
+        // Left set only where a channel's lerp threw partway, which the next fold must not inherit.
+        for (let t = 0; t < k.touched.length; t++) {
+            const slot = k.touched[t];
+            k.met[slot] = 0;
+            k.values[slot] = undefined;
+        }
+        k.touched.length = 0;
+        this.roleDepth--;
+    }
+}

package/dist/roster.js

@@ -2,8 +2,8 @@ import { index, unindex } from './chain.js';
 import { detour } from './everyone.js';
 import { Store } from './store.js';
 function tally(mix, voice, by) {
-    if (voice.spec.locus !== undefined)
-        mix.loci += by;
+    if (voice.spec.role !== undefined)
+        mix.roleVoices += by;
     const e = voice.spec.earliest;
     if (voice.spec.anchor !== undefined || (e !== undefined && typeof e !== 'number'))
         mix.anchored += by;
@@ -36,7 +36,7 @@ export function recount(mix) {
     mix.naming = 0;
     mix.general = [];
     mix.sharers = [];
-    mix.loci = 0;
+    mix.roleVoices = 0;
     mix.anchored = 0;
     for (const voice of mix.cued) {
         index(mix, voice);

package/dist/rotation.d.ts

@@ -10,7 +10,7 @@ export interface AngleOptions {
     turn?: number;
 }
 /**
- * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * A rotation about one axis that interpolates the short way round. It adds as `sum` does, and from
  * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
  * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
  * either.

package/dist/rotation.js

@@ -1,7 +1,7 @@
 import { doubles, vouch } from './channels.js';
 import { shortWay } from './turns.js';
 /**
- * A rotation about one axis, which adds as `sum` does and interpolates the short way round: from
+ * A rotation about one axis that interpolates the short way round. It adds as `sum` does, and from
  * 350 to 10 it passes 0, not 180. A weight below 1 fades it the short way to rest too. Its values
  * are angles, so two a whole number of turns apart are the same value, and a fold may answer with
  * either.

package/dist/rows.js

@@ -25,7 +25,7 @@ export function unplace(lanes, c, p) {
     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 */;
+    c.hot[f] = c.hot[f] & ~(16 /* Flag.PLACED */ | 2048 /* Flag.READY */);
     const o = p * 8 /* Row.STRIDE */;
     c.data[o + 4 /* Row.MSLOT */] = -1;
     c.data[o + 5 /* Row.SAMPLED */] = -1;

package/dist/sample.d.ts

@@ -1,7 +1,7 @@
 import { type Lane, type Positions } from './lane.js';
 import type { Lanes } from './lanes.js';
-import type { Motions } from './motions.js';
-import type { Subject } from './voice.js';
+import { type Motions } from './motions.js';
+import type { Subject } from './subject.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.

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/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';
@@ -33,8 +34,7 @@ function restore(mix, voice, live, at, every, mine) {
         const h = mine && live.reaches ? unread(live) : copyHeld(voice, live);
         if (h.stepped > t)
             h.stepped = t;
-        // Whether it had rested by `t` is not kept; the next probe finds it again.
-        h.rested = false;
+        restedBy(h, live, t);
         h.weight = 0;
         h.inputs = inputs;
         if (!(h.since <= t))
@@ -63,6 +63,7 @@ function restore(mix, voice, live, at, every, mine) {
     else
         h = copyHeld(voice, snap.held, true);
     h.weight = 0;
+    restedBy(h, live, t);
     if (snap.at < t)
         h.copied = true;
     const kept = i + 1;
@@ -108,6 +109,13 @@ function restore(mix, voice, live, at, every, mine) {
     }
     return h;
 }
+/**
+ * Whether a record put back for mix time `t` had rested by then, from when the live one did: a
+ * 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.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) {
     while (snaps.length > kept) {
@@ -188,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 ??= [];
@@ -350,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);
@@ -393,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.13.0";
+export declare const release = "0.15.0";
 /**
  * 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.13.0';
+export const release = '0.15.0';
 /**
  * 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>;