@msb235/blits 0.2.0 → 0.3.0

package/dist/numbers.d.ts

@@ -0,0 +1,22 @@
+/** What a number's subject is once it has none: released, or let go by the host. */
+export declare const absent: unique symbol;
+/**
+ * Hands each subject a small number to index flat arrays by, and takes it back when the subject is
+ * released or, for an object, when the host lets it go. Objects are held weakly, as `Store` holds
+ * them, so numbering one never keeps it alive.
+ */
+export declare class Numbers<I> {
+    private readonly gone;
+    private next;
+    private readonly free;
+    private readonly refs;
+    private live;
+    private readonly tokens;
+    private readonly registry;
+    constructor(gone: (slot: number) => void);
+    /** One past the highest number handed out, so a loop over 0..size meets every live one. */
+    get size(): number;
+    take(subject: I): number;
+    subject(slot: number): I | typeof absent;
+    release(slot: number): void;
+}

package/dist/numbers.js

@@ -0,0 +1,64 @@
+/** What a number's subject is once it has none: released, or let go by the host. */
+export const absent = Symbol('absent');
+/**
+ * Hands each subject a small number to index flat arrays by, and takes it back when the subject is
+ * released or, for an object, when the host lets it go. Objects are held weakly, as `Store` holds
+ * them, so numbering one never keeps it alive.
+ */
+export class Numbers {
+    gone;
+    next = 0;
+    free = [];
+    refs = [];
+    live = new Uint8Array(0);
+    tokens = [];
+    registry = new FinalizationRegistry((slot) => this.release(slot));
+    constructor(gone) {
+        this.gone = gone;
+    }
+    /** One past the highest number handed out, so a loop over 0..size meets every live one. */
+    get size() {
+        return this.next;
+    }
+    take(subject) {
+        const slot = this.free.pop() ?? this.next++;
+        if (slot >= this.live.length) {
+            const grown = new Uint8Array(Math.max(64, this.live.length * 2, slot + 1));
+            grown.set(this.live);
+            this.live = grown;
+        }
+        this.live[slot] = 1;
+        if (typeof subject === 'object' && subject !== null) {
+            this.refs[slot] = new WeakRef(subject);
+            const token = {};
+            this.tokens[slot] = token;
+            this.registry.register(subject, slot, token);
+        }
+        else
+            this.refs[slot] = subject;
+        return slot;
+    }
+    subject(slot) {
+        if (this.live[slot] !== 1)
+            return absent;
+        const ref = this.refs[slot];
+        if (ref instanceof WeakRef) {
+            const s = ref.deref();
+            return s === undefined ? absent : s;
+        }
+        return ref;
+    }
+    release(slot) {
+        if (this.live[slot] !== 1)
+            return;
+        this.live[slot] = 0;
+        const token = this.tokens[slot];
+        if (token !== undefined) {
+            this.registry.unregister(token);
+            this.tokens[slot] = undefined;
+        }
+        this.refs[slot] = undefined;
+        this.gone(slot);
+        this.free.push(slot);
+    }
+}

package/dist/patch.d.ts

@@ -1,5 +1,6 @@
+import { type LerpInto } from './channels.js';
 import { type Curve } from './easing.js';
-import type { Easing, Keyframe, Kit, Patch, Setting } from './types.js';
+import type { Channel, Easing, Keyframe, Kit, Patch, Setting } from './types.js';
 /**
  * What `patch` takes besides its period and its function.
  *
@@ -64,6 +65,16 @@ export interface Built {
     tracks: Track[];
     period: number;
 }
+/**
+ * Arrays a reader lets keyed reads interpolate into, by track. Each only ever holds what a read made,
+ * never a stop's or a base's, and a delta read through it is good until the next read through it.
+ */
+export type Scratch = (unknown[] | undefined)[];
+/**
+ * Per track, the in-place form of the `lerp` a read takes, where it is the mix channel's own and the
+ * channel has one. `channels` holds the mix's channel per track, in `writes` order.
+ */
+export declare function intosOf(built: Built, channels: readonly Channel<unknown>[]): (LerpInto | undefined)[];
 /**
  * Evaluates built stops into `out`; a channel with nothing to read at this phase is left undefined.
  * `lerps` holds the mix's channel `lerp` per track, in `writes` order, for a track the patch did not
@@ -71,7 +82,7 @@ export interface Built {
  */
 export declare function readKeys(built: Built, phase: number, out: Record<string, unknown>, base?: Record<string, unknown>, lerps?: readonly (Lerp | undefined)[], 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
-slopes?: Record<string, unknown>): Record<string, unknown>;
+slopes?: Record<string, unknown>, intos?: readonly (LerpInto | undefined)[], scratch?: Scratch): Record<string, unknown>;
 /** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
 export declare function builtOf<I, O, S>(p: Patch<I, O, S>): Built;
 /** Evaluates a stop list into a fresh delta. */

package/dist/patch.js

@@ -1,3 +1,4 @@
+import { lerpInto } from './channels.js';
 import { curve } from './easing.js';
 /**
  * The procedural form. Flicker, roving, a hash walk, a starter strike.
@@ -68,7 +69,9 @@ function build(stops, writes, period, opts) {
  * Reads one track at a phase. `base` stands in for the value at phase 0, which is how
  * `from: 'current'` starts a voice wherever the subject already is.
  */
-function read(track, phase, base, lerp, slope) {
+function read(track, phase, base, lerp, 
+/** Units per ms, for a retarget's first segment. */
+slope, period, into, reuse) {
     const pts = base === undefined ? track.all : track.tail;
     const o = base === undefined ? 0 : 1;
     const n = pts.length + o;
@@ -95,26 +98,50 @@ function read(track, phase, base, lerp, slope) {
     const aValue = lo - 1 < o ? base : pts[lo - 1 - o].value;
     const u = (phase - aAt) / (b.at - aAt);
     const eased = b.ease ? b.ease(u) : u;
-    const by = track.lerp ?? lerp;
-    const value = by
-        ? by(aValue, b.value, eased)
-        : interpolate(aValue, b.value, eased);
+    let value;
+    if (into !== undefined) {
+        value = into(reuse, aValue, b.value, eased);
+        lastRead.wrote = value;
+    }
+    else {
+        const by = track.lerp ?? lerp;
+        value = by ? by(aValue, b.value, eased) : interpolate(aValue, b.value, eased);
+    }
     // Leaving a retarget's base, bend the first segment so it starts at the slope the subject had:
     // add c·u(1−u)², which is 0 at both ends, flat at the end, and fixes the slope at the start.
     if (slope === undefined || lo - 1 >= o)
         return value;
     const len = b.at - aAt;
     const e0 = b.ease ? b.ease(1e-6) / 1e-6 : 1;
-    const bend = (s, a, z) => (s * len - (z - a) * e0) * u * (1 - u) * (1 - u);
+    const bend = (s, a, z) => (s * period * len - (z - a) * e0) * u * (1 - u) * (1 - u);
     if (typeof value === 'number' && typeof slope === 'number')
         return value + bend(slope, aValue, b.value);
-    if (Array.isArray(value) && Array.isArray(slope))
-        return value.map((v, i) => typeof v === 'number' && typeof slope[i] === 'number'
-            ? v +
-                bend(slope[i], aValue[i], b.value[i])
-            : v);
+    if (Array.isArray(value) && Array.isArray(slope)) {
+        const out = value === lastRead.wrote ? value : new Array(value.length);
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            const s = slope[i];
+            out[i] =
+                typeof v === 'number' && typeof s === 'number'
+                    ? v + bend(s, aValue[i], b.value[i])
+                    : v;
+        }
+        return out;
+    }
     return value;
 }
+/** The array the last `read` interpolated into, which only its caller's record holds. */
+const lastRead = { wrote: undefined };
+/**
+ * Per track, the in-place form of the `lerp` a read takes, where it is the mix channel's own and the
+ * channel has one. `channels` holds the mix's channel per track, in `writes` order.
+ */
+export function intosOf(built, channels) {
+    return built.tracks.map((track, i) => {
+        const channel = channels[i];
+        return track.lerp === undefined || track.lerp === channel.lerp ? lerpInto(channel) : undefined;
+    });
+}
 /**
  * Evaluates built stops into `out`; a channel with nothing to read at this phase is left undefined.
  * `lerps` holds the mix's channel `lerp` per track, in `writes` order, for a track the patch did not
@@ -122,19 +149,18 @@ function read(track, phase, base, lerp, slope) {
  */
 export function readKeys(built, phase, out, base, lerps, 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
-slopes) {
+slopes, intos, scratch) {
     const period = built.period;
     for (let i = 0; i < built.tracks.length; i++) {
         const track = built.tracks[i];
         const delay = track.delay;
         const shifted = delay === 0 || period === 0 ? phase : Math.max(0, (phase * period - delay) / period);
         const perMs = slopes?.[track.channel];
-        const slope = perMs === undefined || period === 0
-            ? undefined
-            : typeof perMs === 'number'
-                ? perMs * period
-                : perMs.map((s) => s * period);
-        const value = read(track, shifted, base?.[track.channel], lerps?.[i], slope);
+        const into = scratch === undefined ? undefined : intos?.[i];
+        lastRead.wrote = undefined;
+        const value = read(track, shifted, base?.[track.channel], lerps?.[i], period === 0 ? undefined : perMs, period, into, into === undefined ? undefined : scratch[i]);
+        if (into !== undefined && value === lastRead.wrote)
+            scratch[i] = value;
         if (value !== undefined)
             out[track.channel] = value;
         else if (out[track.channel] !== undefined)

package/dist/reading.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Internal: what kind of read the mix is making right now, for patches that keep state of their own
+ * outside the mix. Not exported from the package.
+ */
+export declare const reading: {
+    /** False while a projection reads: a patch must not commit anything then. */
+    live: boolean;
+    /**
+     * The earliest voice time a read may still ask for; a patch keeping a history may drop what is
+     * older. Infinity where the mix keeps none, so only what plays now is kept.
+     */
+    horizon: number;
+    /**
+     * How many entries `setting.keep` has made in any mix, so a patch call that made one shows
+     * without looking into the record it was made on.
+     */
+    kept: number;
+    /**
+     * How many retargets and pushes any motion patch has taken, so a mix can tell one came mid-frame.
+     * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
+     */
+    moved: number;
+};

package/dist/reading.js

@@ -0,0 +1,23 @@
+/**
+ * Internal: what kind of read the mix is making right now, for patches that keep state of their own
+ * outside the mix. Not exported from the package.
+ */
+export const reading = {
+    /** False while a projection reads: a patch must not commit anything then. */
+    live: true,
+    /**
+     * The earliest voice time a read may still ask for; a patch keeping a history may drop what is
+     * older. Infinity where the mix keeps none, so only what plays now is kept.
+     */
+    horizon: Number.POSITIVE_INFINITY,
+    /**
+     * How many entries `setting.keep` has made in any mix, so a patch call that made one shows
+     * without looking into the record it was made on.
+     */
+    kept: 0,
+    /**
+     * How many retargets and pushes any motion patch has taken, so a mix can tell one came mid-frame.
+     * One count for every mix: a change to a spring in one mix refills the lanes of all of them.
+     */
+    moved: 0,
+};

package/dist/types.d.ts

@@ -10,6 +10,12 @@ export interface Channel<V> {
      * as `'sum'` or `'vec(3, sum)'`. Absent, a channel matches only itself.
      */
     kind?: string;
+    /**
+     * The range a numeric value means anything in, such as 0..1 for an opacity. The mix clamps the
+     * folded value to it, axis by axis for an array, so neither stacked voices nor a retarget that
+     * carries speed can push it out; overshoot stops flat at the bound.
+     */
+    bounds?: readonly [min: number, max: number];
     /** Identity. Absent means the channel has none: it replaces rather than contributes. */
     rest?: V;
     /** Fold two influences into one. */
@@ -87,13 +93,17 @@ export interface Setting<S = void> {
     /**
      * The state `owner` keeps for this voice and this subject, made by `init` on first ask. The mix
      * holds it, so a read at another time can copy it instead of moving it. A stateful signal keeps
-     * its state here and nowhere else.
+     * its state here and nowhere else. With lanes on, a patch that first calls it partway through
+     * playing can have that state advanced once for one subject not probed on the frame it starts; a
+     * patch that keeps state from its first call, or declares `state`, never does.
      */
     keep<K>(owner: object, init: () => K): K;
     /**
      * Reports an event at `timestamp`, for this voice and this subject. The mix queues it until the
      * host drains it, and never calls back. Meant for `step`, where under `stepMs` the timestamp is
-     * the interval the event happened in rather than the frame that sampled it.
+     * the interval the event happened in rather than the frame that sampled it. Sent from a stateless
+     * patch's `at` while it runs on a lane, it goes out for every subject the mix has met, probed that
+     * frame or not.
      */
     send(event: unknown): void;
 }
@@ -112,14 +122,43 @@ export interface Sent<I, E = unknown> {
     tags: readonly string[];
     event: E;
 }
+/**
+ * What a `'motion'` patch is made of, as data an engine can read: the kind of motion and its
+ * constants. Each subject's start, target and starting velocity stay on the patch, since they may
+ * be functions of the subject.
+ *
+ * @category patch
+ */
+export type MotionSpec = {
+    readonly kind: 'spring';
+    /** Per second squared. */
+    readonly stiffness: number;
+    /** Per second. */
+    readonly damping: number;
+    readonly mass: number;
+    readonly settle: number;
+} | {
+    readonly kind: 'glide';
+    /** The friction's time constant, ms. */
+    readonly ms: number;
+    readonly settle: number;
+} | {
+    readonly kind: 'tween';
+    /** How long a stretch takes. */
+    readonly ms: number;
+    readonly ease: Easing;
+};
 /**
  * A pure function of phase and a subject that returns a delta. Optionally stateful.
  *
  * @category patch
  */
 export interface Patch<I, O, S = void> {
-    /** Which authoring form built it. An engine declares which forms it runs. */
-    readonly form: 'fn' | 'keys';
+    /**
+     * Which authoring form built it: `'fn'` from `patch`, `'keys'` from `keys`, `'motion'` from
+     * `spring`, `glide` or `tween`. An engine declares which forms it runs.
+     */
+    readonly form: 'fn' | 'keys' | 'motion';
     /** Milliseconds one pass lasts. 0 is aperiodic: phase and pass stay 0. */
     readonly period: number;
     /** The channels this patch contributes to. Every key `at` sets, and no others. */
@@ -142,6 +181,14 @@ export interface Patch<I, O, S = void> {
     step?(state: S, dt: number, subject: I, setting: Setting<S>): void;
     /** Present when the patch was authored as keyframes, so an engine that reads data can. */
     readonly keys?: readonly Keyframe<O>[];
+    /** Present on a `'motion'` patch: its kind and constants, for an engine that reads data. */
+    readonly motion?: MotionSpec;
+    /**
+     * A copy of `state` that shares nothing with it, for a read at another time. Default
+     * `structuredClone`, which is enough for plain data; a state holding a class instance or a
+     * function needs its own.
+     */
+    clone?(state: S): S;
 }
 /**
  * A 0..1 scalar resolved per subject per frame from something outside the clock. `input` is set
@@ -163,6 +210,82 @@ export interface FadeSpec {
     out?: number;
     ease?: Easing;
 }
+/**
+ * The four times a voice is known by on the mix clock: when its fade in begins (`start`), when it is
+ * fully in (`in`), when its fade out begins (`out`), and when it is gone (`end`).
+ *
+ * @category score
+ */
+export type Mark = 'start' | 'in' | 'out' | 'end';
+/**
+ * Selects voices by what the plan knows of them, never by a channel's value, within the asking
+ * voice's own score unless it names another. Where several match,
+ * the resolver picks one: `last` cued (the default), `first` cued, `next` (the earliest whose mark
+ * is still to come), `earliest` or `latest` by the mark's time.
+ *
+ * @category score
+ */
+export interface Query {
+    /** The score to look in. Default: the asking voice's own. */
+    score?: string;
+    name?: string;
+    tag?: string;
+    /** A channel the voice's patch writes. */
+    writes?: string;
+    resolver?: 'last' | 'first' | 'next' | 'earliest' | 'latest';
+}
+/**
+ * A time given by another voice: `mark` of the voice `of` selects, moved by `by` ms. `after` is
+ * sugar for that voice's `end`, `with` for its `start`, and `before` for its start less `by`. A
+ * string selects by name.
+ *
+ * @category score
+ */
+export type Anchor = {
+    of: string | Query;
+    mark: Mark;
+    by?: number;
+} | {
+    after: string | Query;
+    by?: number;
+} | {
+    with: string | Query;
+    by?: number;
+} | {
+    before: string | Query;
+    by?: number;
+};
+/**
+ * Where a voice sits on the mix clock: at most one of `start` and `in`, and at most one of `out`
+ * and `end`, each a timestamp on the host's clock or an anchor to another voice. A voice whose
+ * anchor has no answer yet waits pending; one whose anchored mark is already past starts partway
+ * through, as playback does from the middle of a region.
+ *
+ * @category score
+ */
+export interface Placement {
+    start?: number | Anchor;
+    in?: number | Anchor;
+    out?: number | Anchor;
+    end?: number | Anchor;
+}
+/**
+ * One mark as `marks` lists it: one of a voice's four, or one the host announced on a score, which
+ * has a name and no voice.
+ *
+ * @category score
+ */
+export interface Marked {
+    /** On the host's clock. */
+    timestamp: number;
+    /** Which of a voice's four this is; undefined for an announced mark. */
+    mark: Mark | undefined;
+    /** The voice it belongs to; undefined for an announced mark. */
+    voice: number | undefined;
+    score: string | undefined;
+    name: string | undefined;
+    tags: readonly string[];
+}
 /**
  * What `cue` takes: a patch, and the clock, weight and reach it plays with.
  *
@@ -172,9 +295,18 @@ export interface VoiceSpec<I, O> {
     patch: Patch<I, O, unknown>;
     /**
      * Which subjects this voice reaches. Default: all of them. The predicate is fixed at `cue`; it
-     * runs per subject the first time the mix sees that subject, and the answer is kept.
+     * runs per subject the first time the mix sees that subject, and the answer is kept. Every
+     * voice's predicate meets every subject, so voices that each reach a known few cost the square
+     * of their number, in time and in memory (a record per voice per subject asked: about 800 MB for
+     * 1,000 such voices); name those with `subjects` instead.
      */
     target?: (subject: I) => boolean;
+    /**
+     * The subjects this voice reaches, fixed at `cue` and matched by identity; a probe of any other
+     * never asks this voice. Takes the place of `target`, and a cue giving both is refused: a
+     * predicate over a fixed list is that list filtered, which the host can do before cueing.
+     */
+    subjects?: readonly I[];
     /**
      * When the voice starts, in ms on the host's clock, the one it passes `sync`: a rAF timestamp and
      * `performance.now()` share an origin, `Date.now()` does not. Default: the next sync.
@@ -203,6 +335,16 @@ export interface VoiceSpec<I, O> {
     from?: 'current';
     /** Words a source attaches to this voice, so its events can be drained as a set. */
     tags?: readonly string[];
+    /** What other voices call this one by. A label blits never reads. */
+    name?: string;
+    /**
+     * The plan this voice belongs to. Each source keeps its own, so two sources can use one name
+     * without meeting: a bare name in an anchor means a voice in the same score, and a query names
+     * `score` to reach into another. Default: the mix's one unnamed score.
+     */
+    score?: string;
+    /** Where it sits relative to the clock or to other voices, in place of `start`. */
+    anchor?: Placement;
 }
 /**
  * How a voice leaves when it is faded.
@@ -282,7 +424,64 @@ export interface MixOptions {
      * Signals and `at` still see the frame. Off by default.
      */
     stepMs?: number;
+    /**
+     * How far back `project` may read, in ms of mix time, and how often a stateful voice's state is
+     * kept per subject on the way, `every` ms (default 200). Within it the mix remembers what it cued,
+     * every change a handle made and when, the voices that have left, and those copies of state, so a
+     * read back restores the nearest copy and steps forward from it. Off by default, and a mix without
+     * it keeps nothing. With `inputs`, it also keeps what each input signal on a voice's weight read
+     * per subject, and the host fields patches `reads`, each time they changed, so a read back over a
+     * `level` or a pointer is known rather than held.
+     */
+    history?: {
+        ms: number;
+        every?: number;
+        inputs?: boolean;
+    };
+    /**
+     * Whether a channel may run as a lane: computed for every subject at once in flat arrays, when
+     * every voice writing it can run that way. On by default; the pose is the same either way, so
+     * turning it off is for ruling a lane out, or for comparing against. Two things differ: a
+     * stateless patch's `setting.send` from `at` sends for every subject a lane fills, probed or not,
+     * and a patch that first calls `setting.keep` partway through playing can advance that state once
+     * more for one unprobed subject (see `Setting.keep`).
+     */
+    lanes?: boolean;
 }
+/**
+ * How sure a projection is of one channel: `exact` where only the clock and known changes drove
+ * it; `stepped` where state was advanced across a gap in one go, which is as good as the patch's
+ * step makes it; `held` where it depends on input from outside the clock, whose value at that time
+ * is not known, so the value it had is held.
+ *
+ * @category mix
+ */
+export type Doubt = 'exact' | 'stepped' | 'held';
+/**
+ * The mix read at another time: what `probe` would give at that timestamp, with nothing in the
+ * live mix moved. Valid until the mix is next synced or cued.
+ *
+ * @category mix
+ */
+export interface Projection<I, O> {
+    /** The timestamp it reads at, on the host's clock. */
+    readonly timestamp: number;
+    /** The merged pose for one subject at this projection's timestamp. */
+    probe(subject: I, out?: O): O;
+    /** Per channel, how sure that pose is; the least sure voice that fed a channel decides. */
+    assess(subject: I): {
+        [K in keyof O]-?: Doubt;
+    };
+}
+/**
+ * Arrays for `pull` to write, one per channel it reads: any channel whose value is a number or an
+ * array of numbers.
+ *
+ * @category mix
+ */
+export type Columns<O> = {
+    [K in keyof O as NonNullable<O[K]> extends number | readonly number[] ? K : never]?: Float64Array;
+};
 /**
  * The live voices over one kit, folded into one pose per subject per frame.
  *
@@ -302,6 +501,19 @@ export interface Mix<I, O> {
     rebase(): void;
     /** The merged pose for one subject at the synced frame. */
     probe(subject: I, out?: O): O;
+    /**
+     * Writes each subject's pose into arrays, one per channel, subject by subject in the order given:
+     * what `probe(subject, out)` gives, without a pose object per subject. A channel of `n` numbers
+     * takes `n` places per subject, side by side; one with no value for a subject writes NaN there.
+     * Fastest while every voice runs on a lane. Throws when an array is too short for the subjects.
+     */
+    pull(subjects: Iterable<I>, into: Columns<O>): void;
+    /**
+     * Reads the mix at another timestamp, on the host's clock, without moving it. Ahead of the last
+     * sync it plays what is cued forward; behind it, it needs `history`, and throws for a timestamp
+     * older than the history reaches.
+     */
+    project(timestamp: number): Projection<I, O>;
     /** Every channel at rest for this subject this frame, so a host can skip the write. */
     atRest(subject: I): boolean;
     /** Anything still contributing, fading, or pending. */
@@ -310,15 +522,34 @@ export interface Mix<I, O> {
     mute(opts?: {
         over?: number;
     }): void;
-    /** Forgets per-subject state. */
+    /** Forgets per-subject state, a motion patch's for the subject included. */
     drop(subject: I): void;
+    /**
+     * Puts a named mark on a score, for anchors to target as they target a voice's marks: a voice
+     * placed `{ with: 'reply' }` waits until the host announces `reply`. `at` is a timestamp on the
+     * host's clock, default now, and may lie ahead, so a read ahead sees it. A mark stays while it is
+     * ahead or while the mix's history reaches it.
+     */
+    announce(name: string, opts?: {
+        at?: number;
+        score?: string;
+        tags?: readonly string[];
+    }): void;
+    /**
+     * Every mark the plan knows between two timestamps on the host's clock, earliest first: when
+     * voices start, are fully in, begin to fade and are gone, and what the host announced. A mark
+     * nothing has fixed yet, such as the out of a voice that loops for good, is not listed.
+     */
+    marks(from: number, to: number): Marked[];
     /**
      * Every event patches have sent since the last drain, earliest first, in the order they were sent
      * where two share a timestamp. A subject's events are made while it catches up, which is when it is
-     * probed, so one nobody probes has sent nothing yet: promptness is the host's, by probing. Under
-     * `stepMs` each carries the end of the interval it happened in, so what is sent and when does not
-     * depend on how the host spaces its probes. Time `rebase` took out sends nothing. Given a tag, it
-     * takes only the events of voices carrying it and leaves the rest for whoever drains them.
+     * probed, so one nobody probes has sent nothing yet: promptness is the host's, by probing. A
+     * stateless patch's `at` on a lane is the exception: it runs for every subject the mix has met, at
+     * the frame's first probe. Under `stepMs` each carries the end of the interval it happened in, so
+     * what is sent and when does not depend on how the host spaces its probes. Time `rebase` took out
+     * sends nothing. Given a tag, it takes only the events of voices carrying it and leaves the rest for
+     * whoever drains them.
      */
     drain<E = unknown>(tag?: string): Sent<I, E>[];
 }
@@ -330,6 +561,6 @@ export interface Mix<I, O> {
 export interface Engine {
     readonly name: string;
     /** Which patch forms this engine can run. A voice it cannot run is refused at `cue`, by name. */
-    readonly runs: ReadonlySet<'fn' | 'keys'>;
+    readonly runs: ReadonlySet<'fn' | 'keys' | 'motion'>;
     create<I, O>(kit: Kit<O>, opts: MixOptions): Mix<I, O>;
 }