@msb235/blits 0.3.0 → 0.5.0

package/dist/motion.js

@@ -2,6 +2,7 @@ import { curve } from './easing.js';
 import { absent, Numbers } from './numbers.js';
 import { reading } from './reading.js';
 import { Store } from './store.js';
+import { eased, progress, sloped } from './tweened.js';
 const UNDER = 0;
 const CRITICAL = 1;
 const OVER = 2;
@@ -13,32 +14,47 @@ const EASED = 4;
  * the buffer a sample already reads rather than in an object of their own.
  */
 const HEAD = 5;
-/** A motion patch's `frame` while no mix plays it: no subject has a latest frame. */
-export const noFrame = () => Number.NaN;
 const solved = { y: 0, dy: 0 };
 /** Where every patch's `sample` leaves a value on its way to the mix; none outlives its call. */
 let shared = { xs: new Float64Array(4), vs: new Float64Array(4) };
-/** A subject's flags: its value is a number; it has changes pending; it has older stretches. */
+/** What a patch's `xs` and `vs` are before its first subject sets its axes. */
+const unsized = new Float64Array(0);
+/**
+ * A subject's flags: its value is a number; it has changes pending; it has older stretches; the
+ * stretch it is playing was found landed, which holds until another replaces it.
+ */
 const SCALAR = 1;
 const PENDING = 2;
 const OLDER = 4;
+const LANDED = 8;
 /**
  * The terms of a stretch that depend only on how long since its release, the same on every axis, so
  * a sample works them out once rather than once per axis.
  */
 const timed = { e: 0, e2: 0, cos: 0, sin: 0 };
-/** How far a tween's slope is read either side of `u`, for an easing that is only a function. */
-const SPAN = 1e-4;
-/**
- * Whether an evaluation wants a tween's velocity, which costs two more reads of its easing. Only
- * `read` reports it; a mix and a retarget never use it.
- */
-let slope = false;
-/** The last tween sample's time, curve and length, and the share of the way it had left to go. */
-const memo = { dt: Number.NaN, ease: undefined, secs: 0, left: 0 };
+/** The law and time `timed` was last worked out for: subjects released together share them. */
+const prepared = {
+    form: Number.NaN,
+    k1: Number.NaN,
+    k2: Number.NaN,
+    k3: Number.NaN,
+    t: Number.NaN,
+};
 /** `t` seconds after release, the terms every axis shares, into `timed`. */
 function prepare(law, t) {
-    switch (law[0]) {
+    const form = law[0];
+    const k1 = law[2];
+    const k2 = law[3];
+    const k3 = law[4];
+    const p = prepared;
+    if (Object.is(t, p.t) && form === p.form && k1 === p.k1 && k2 === p.k2 && k3 === p.k3)
+        return;
+    p.form = form;
+    p.k1 = k1;
+    p.k2 = k2;
+    p.k3 = k3;
+    p.t = t;
+    switch (form) {
         case UNDER: {
             const zeta = law[2];
             const w0 = law[3];
@@ -112,78 +128,173 @@ function solve(law, y0, v0, t) {
     }
 }
 const axes = (v) => (typeof v === 'number' ? [v] : [...v]);
+/** Zero on every axis `x` has: a motion's velocity where its options give none. */
+const still = (x) => new Array(x.length).fill(0);
 const per = (p, subject) => typeof p === 'function' ? p(subject) : p;
+const scalarOf = (p) => typeof p === 'function' ? undefined : typeof p === 'number';
+const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel} holds ${holdsNumber ? 'a number' : 'an array'}, and this motion patch gives a subject ${holdsNumber ? 'an array' : 'a number'}`);
 /**
  * A motion patch's subjects: the stretch each is playing, in one flat array by a number the patch
  * gives it, with earlier stretches a read back may reach and changes not yet applied beside them.
  * The one copy, read by `at` and by a mix's lane alike.
  *
- * After the law, each subject's run of `stride` numbers is its release time, its flags, then `x0`,
- * `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
+ * After the law, each subject's run of `stride` numbers is its release time, its flags, a tween's
+ * seconds for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
 export class Motions {
     shape;
-    numbers = new Numbers((slot) => this.forget(slot));
+    numbers = new Numbers(this);
+    /** Numbers by subject once a second is numbered: till then the one subject is found by `numbers`. */
     slots = new Store();
     /** Axes per subject; -1 until the first subject sets it. */
     n = -1;
     cap = 0;
     stride = 0;
-    runs;
+    /**
+     * The law, then each subject's run; empty until the first subject, the law read from `shape`.
+     * Read outside, at `bareAt`, and written only here.
+     */
+    runs = unsized;
     /**
      * Where `sample` leaves a subject's position and velocity, per axis. Shared by every patch, so
      * read it before the next sample.
      */
-    xs = new Float64Array(0);
-    vs = new Float64Array(0);
-    pending = new Map();
-    older = new Map();
+    xs = unsized;
+    vs = unsized;
     /**
-     * The subject's voice time at the mix's latest frame, which an untimed change and a `read` with
-     * no time take; NaN where no frame of the patch's voice has met the subject. Set by the mix that
-     * cues the patch, and put back when its voice retires.
+     * By subject number, changes not yet applied and earlier stretches a read back may reach: null
+     * until a subject first has one, since many patches are never changed. Each starts with room for
+     * one: an empty array written at 0 reserves 17, and most patches have one subject.
      */
-    frame = noFrame;
+    pending = null;
+    older = null;
+    /**
+     * The mix playing the patch and its voice's id, which an untimed change and a `read` with no time
+     * ask for the latest frame. Set by the mix that cues the patch, and cleared when its voice retires.
+     */
+    owner = null;
+    ownerId = -1;
+    /** Whether the channel it was cued on holds a number; undefined until it is cued. */
+    holdsNumber = undefined;
+    channel = '';
+    /**
+     * Records what the channel the patch is cued on holds, refusing a value of the other kind: at once
+     * where every subject's value is one kind, else on the first sample of a subject whose value is not.
+     */
+    cuedOn(channel, holdsNumber) {
+        const every = this.shape.scalarEvery();
+        if (every !== undefined && every !== holdsNumber)
+            throw wrongKind(channel, holdsNumber);
+        for (let s = 0; s < this.numbers.size; s++)
+            if (this.numbers.subject(s) !== absent &&
+                ((this.runs[this.base(s) + 1] & SCALAR) !== 0) !== holdsNumber)
+                throw wrongKind(channel, holdsNumber);
+        this.holdsNumber = holdsNumber;
+        this.channel = channel;
+    }
+    frame(subject) {
+        return this.owner === null ? Number.NaN : this.owner.frame(this.ownerId, subject);
+    }
     constructor(shape) {
         this.shape = shape;
-        this.runs = Float64Array.from(shape.law);
     }
     /** The patch's number for `subject`, made with its first stretch on first ask. */
     slot(subject) {
-        const known = this.slots.get(subject);
+        const known = this.known(subject);
         if (known !== undefined)
             return known;
         const x = this.shape.from(subject);
-        const v = this.shape.velocity(subject);
+        const v = this.shape.velocity(subject, x);
         const to = this.shape.aim(x, v, null, subject);
         const n = this.n < 0 ? x.length : this.n;
-        for (const a of [x, v, to])
-            this.check(a, n);
+        this.check(x, n);
+        this.check(v, n);
+        this.check(to, n);
+        const scalar = this.shape.scalar(subject);
+        if (this.holdsNumber !== undefined && scalar !== this.holdsNumber)
+            throw wrongKind(this.channel, this.holdsNumber);
         if (this.n < 0) {
             this.n = n;
-            this.stride = 2 + 3 * n;
+            this.stride = 3 + 3 * n;
             if (shared.xs.length < n)
                 shared = { xs: new Float64Array(n), vs: new Float64Array(n) };
             this.xs = shared.xs;
             this.vs = shared.vs;
         }
         const s = this.numbers.take(subject);
-        this.slots.set(subject, s);
+        if (s === 1) {
+            const first = this.numbers.subject(0);
+            if (first !== absent)
+                this.slots.set(first, 0);
+        }
+        if (this.numbers.size > 1)
+            this.slots.set(subject, s);
         this.grow(s + 1);
-        this.runs[this.base(s) + 1] = this.shape.scalar(subject) ? SCALAR : 0;
-        this.write(s, { at: 0, x0: x, v0: v, to });
+        this.runs[this.base(s) + 1] = scalar ? SCALAR : 0;
+        this.write(s, { at: 0, ms: this.shape.ms?.(subject) ?? 0, x0: x, v0: v, to });
         return s;
     }
+    /** The patch's number for `subject`, undefined where it has none. */
+    known(subject) {
+        if (this.numbers.size !== 1)
+            return this.slots.get(subject);
+        const only = this.numbers.subject(0);
+        return only !== absent && (only === subject || Object.is(only, subject)) ? 0 : undefined;
+    }
     /** Forgets a subject, so a later ask starts it afresh from `from`. */
     release(subject) {
-        const s = this.slots.get(subject);
+        const s = this.known(subject);
         if (s === undefined)
             return;
         this.slots.delete(subject);
         this.numbers.release(s);
     }
+    /**
+     * Told, with `watchId`, whenever a subject's stretch or what is pending for it changes, so a mix
+     * keeping a copy of it knows to read it again. Set by the mix, cleared when its voice retires. An
+     * owner and an id, where a callback cost a closure and its context per patch.
+     */
+    watcher = null;
+    watchId = -1;
+    /** The easing a tween's stretches follow; undefined for every other shape. */
+    get ease() {
+        return this.shape.ease;
+    }
+    /** The patch's kind and constants. */
+    spec() {
+        return this.shape.spec();
+    }
+    /** A copy of the patch's law, `[form, settle, k1, k2, k3]`. */
+    law() {
+        return this.cap === 0 ? Float64Array.from(this.shape.law) : this.runs.slice(0, HEAD);
+    }
+    /** Whether `law` holds this patch's law, number for number, as `Object.is` compares them. */
+    hasLaw(law) {
+        const own = this.cap === 0 ? this.shape.law : this.runs;
+        for (let i = 0; i < HEAD; i++)
+            if (!Object.is(law[i], own[i]))
+                return false;
+        return true;
+    }
+    /**
+     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its seconds, then
+     * `x0`, `v0` and `to` per axis; false, copying nothing, while it has a change pending or an
+     * earlier stretch kept, which only `sample` handles.
+     */
+    stretchInto(s, out, o) {
+        const runs = this.runs;
+        const b = this.base(s);
+        if ((runs[b + 1] & (PENDING | OLDER)) !== 0)
+            return false;
+        out[o] = runs[b];
+        out[o + 1] = runs[b + 2];
+        const n3 = 3 * this.n;
+        for (let i = 0; i < n3; i++)
+            out[o + 2 + i] = runs[b + 3 + i];
+        return true;
+    }
     /** Whether subject `s`'s value is a number rather than an array. */
     scalar(s) {
         return (this.runs[this.base(s) + 1] & SCALAR) !== 0;
@@ -215,13 +326,65 @@ export class Motions {
             if (t < at && runs[b + 1] & OLDER)
                 this.evaluateSegment(this.playing(s, t), t, xo, vo);
             else {
-                const x = b + 2;
-                this.evaluate(at, runs, x, runs, x + this.n, runs, x + 2 * this.n, t, xo, vo);
+                const x = b + 3;
+                const ms = runs[b + 2];
+                this.evaluate(at, ms, runs, x, runs, x + this.n, runs, x + 2 * this.n, t, xo, vo);
             }
             return;
         }
         this.peek(s, t, xo, vo);
     }
+    /**
+     * Where subject `s`'s run starts in `runs` (its release time, then flags, seconds, `x0`, `v0`
+     * and `to`) while it has nothing pending and no earlier stretch kept; -1 for any other.
+     */
+    bareAt(s) {
+        const b = this.base(s);
+        return (this.runs[b + 1] & (PENDING | OLDER)) !== 0 ? -1 : b;
+    }
+    /**
+     * A live `sample` at `t` for a subject with nothing pending and no earlier stretch kept, true
+     * then; false, writing nothing, for any other, which `quiet` and `sample` take instead.
+     */
+    sampleBare(s, t, xo, vo) {
+        const runs = this.runs;
+        const b = this.bareAt(s);
+        if (b < 0)
+            return false;
+        const x = b + 3;
+        const n = this.n;
+        this.evaluate(runs[b], runs[b + 2], runs, x, runs, x + n, runs, x + 2 * n, t, xo, vo);
+        return true;
+    }
+    /**
+     * Whether every subject has landed on its target at its voice time at the latest frame, as a
+     * sample there would find; one with a change waiting has not. Commits nothing.
+     */
+    landed() {
+        const runs = this.runs;
+        const n = this.n;
+        for (let s = 0; s < this.numbers.size; s++) {
+            const b = this.base(s);
+            const flags = runs[b + 1];
+            if ((flags & (LANDED | PENDING)) === LANDED)
+                continue;
+            const subject = this.numbers.subject(s);
+            if (subject === absent)
+                continue;
+            if (flags & PENDING)
+                return false;
+            const at = runs[b];
+            const t = this.frame(subject);
+            if (!(t >= at))
+                return false;
+            const x = b + 3;
+            const ms = runs[b + 2];
+            if (!this.evaluate(at, ms, runs, x, runs, x + n, runs, x + 2 * n, t, this.xs, this.vs))
+                return false;
+            runs[b + 1] = flags | LANDED;
+        }
+        return true;
+    }
     /**
      * Whether a live `sample` at `t` would leave the subject's state as it is: nothing to stamp or
      * commit by then, and nothing older than `reading.horizon` to let go of.
@@ -231,13 +394,13 @@ export class Motions {
         const b = this.base(s);
         const flags = runs[b + 1];
         if (flags & PENDING) {
-            const list = this.pending.get(s);
+            const list = this.pending[s];
             const first = list[0].at;
             if (first === undefined || first <= t || list[list.length - 1].at === undefined)
                 return false;
         }
         if (flags & OLDER) {
-            const list = this.older.get(s);
+            const list = this.older[s];
             const next = list.length > 1 ? list[1].at : runs[b];
             if (next <= reading.horizon)
                 return false;
@@ -246,7 +409,7 @@ export class Motions {
     }
     /** Position and velocity at `at`, default the latest frame; undefined until there is one. */
     read(subject, at) {
-        const s = this.slots.get(subject);
+        const s = this.known(subject);
         if (s === undefined)
             return undefined;
         const when = at ?? this.frame(subject);
@@ -254,12 +417,12 @@ export class Motions {
             return undefined;
         const x = new Float64Array(this.n);
         const v = new Float64Array(this.n);
-        slope = true;
+        sloped(true);
         try {
             this.peek(s, when, x, v);
         }
         finally {
-            slope = false;
+            sloped(false);
         }
         return { x, v, s };
     }
@@ -268,6 +431,7 @@ export class Motions {
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject, c) {
+        this.owner?.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
         this.check(c.v, this.n);
@@ -276,9 +440,11 @@ export class Motions {
             if (!Number.isNaN(at))
                 c.at = at;
         }
-        const list = this.pending.get(s);
+        const list = this.pending?.[s];
         if (list === undefined) {
-            this.pending.set(s, [c]);
+            if (this.pending === null)
+                this.pending = [undefined];
+            this.pending[s] = [c];
             this.flag(s, PENDING, true);
         }
         else if (c.at === undefined)
@@ -301,7 +467,7 @@ export class Motions {
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     peek(s, t, xo, vo) {
         let seg = this.playing(s, t);
-        const list = this.pending.get(s);
+        const list = this.pending?.[s];
         if (list !== undefined)
             for (const change of list) {
                 const a = change.at;
@@ -317,13 +483,16 @@ export class Motions {
             throw new Error('blits: a motion patch moves every subject on the same number of axes');
     }
     flag(s, bit, on) {
+        this.watcher?.stretchChanged(this.watchId, s);
         const i = this.base(s) + 1;
         const flags = this.runs[i];
         this.runs[i] = on ? flags | bit : flags & ~bit;
     }
     forget(s) {
-        this.pending.delete(s);
-        this.older.delete(s);
+        if (this.pending !== null)
+            this.pending[s] = undefined;
+        if (this.older !== null)
+            this.older[s] = undefined;
     }
     /** Where subject `s`'s run starts in `runs`. */
     base(s) {
@@ -334,26 +503,30 @@ export class Motions {
             return;
         const cap = Math.max(size, this.cap * 2);
         const runs = new Float64Array(HEAD + cap * this.stride);
-        runs.set(this.runs);
+        runs.set(this.cap === 0 ? this.shape.law : this.runs);
         this.runs = runs;
         this.cap = cap;
     }
     write(s, seg) {
         const n = this.n;
         const b = this.base(s);
+        this.watcher?.stretchChanged(this.watchId, s);
         this.runs[b] = seg.at;
+        this.runs[b + 1] = this.runs[b + 1] & ~LANDED;
+        this.runs[b + 2] = seg.ms;
         for (let i = 0; i < n; i++) {
-            this.runs[b + 2 + i] = seg.x0[i];
-            this.runs[b + 2 + n + i] = seg.v0[i];
-            this.runs[b + 2 + 2 * n + i] = seg.to[i];
+            this.runs[b + 3 + i] = seg.x0[i];
+            this.runs[b + 3 + n + i] = seg.v0[i];
+            this.runs[b + 3 + 2 * n + i] = seg.to[i];
         }
     }
     /** The stretch subject `s` is playing now, as an object. */
     latest(s) {
         const n = this.n;
-        const x = this.base(s) + 2;
+        const x = this.base(s) + 3;
         return {
             at: this.runs[this.base(s)],
+            ms: this.runs[this.base(s) + 2],
             x0: Array.from(this.runs.subarray(x, x + n)),
             v0: Array.from(this.runs.subarray(x + n, x + 2 * n)),
             to: Array.from(this.runs.subarray(x + 2 * n, x + 3 * n)),
@@ -361,7 +534,7 @@ export class Motions {
     }
     /** The stretch playing at voice time `t`: the latest released by then, else the first. */
     playing(s, t) {
-        const list = this.older.get(s);
+        const list = this.older?.[s];
         if (list === undefined || t >= this.runs[this.base(s)])
             return this.latest(s);
         if (list[0].at > t)
@@ -384,11 +557,13 @@ export class Motions {
         const xs = Array.from(x);
         const vs = change.v ?? Array.from(v);
         const subject = this.numbers.subject(s);
-        const to = this.shape.aim(xs, vs, change.to ?? seg.to, subject === absent ? undefined : subject);
-        return { at, x0: xs, v0: vs, to };
+        const known = subject === absent ? undefined : subject;
+        const to = this.shape.aim(xs, vs, change.to ?? seg.to, known);
+        const ms = subject === absent ? seg.ms : (this.shape.ms?.(known) ?? 0);
+        return { at, ms, x0: xs, v0: vs, to };
     }
     commit(s, t) {
-        const list = this.pending.get(s);
+        const list = this.pending[s];
         // The first read of a subject no frame had met: those waiting for a time take this one.
         if (list[list.length - 1].at === undefined) {
             let i = list.length;
@@ -408,27 +583,24 @@ export class Motions {
             this.insert(s, this.applied(s, this.playing(s, a), change, a));
         }
         if (list.length === 0) {
-            this.pending.delete(s);
+            this.pending[s] = undefined;
             this.flag(s, PENDING, false);
         }
     }
     insert(s, seg) {
-        let list = this.older.get(s);
+        let list = this.older?.[s];
+        if (list === undefined) {
+            list = [];
+            if (this.older === null)
+                this.older = [undefined];
+            this.older[s] = list;
+            this.flag(s, OLDER, true);
+        }
         if (seg.at >= this.runs[this.base(s)]) {
-            if (list === undefined) {
-                list = [];
-                this.older.set(s, list);
-                this.flag(s, OLDER, true);
-            }
             list.push(this.latest(s));
             this.write(s, seg);
             return;
         }
-        if (list === undefined) {
-            list = [];
-            this.older.set(s, list);
-            this.flag(s, OLDER, true);
-        }
         let i = list.length;
         while (i > 0 && list[i - 1].at > seg.at)
             i--;
@@ -436,7 +608,7 @@ export class Motions {
     }
     /** Lets go of stretches older than the one in force at `reading.horizon`. */
     prune(s) {
-        const list = this.older.get(s);
+        const list = this.older?.[s];
         if (list === undefined)
             return;
         while (list.length > 0 &&
@@ -444,91 +616,218 @@ export class Motions {
                 reading.horizon)
             list.shift();
         if (list.length === 0) {
-            this.older.delete(s);
+            this.older[s] = undefined;
             this.flag(s, OLDER, false);
         }
     }
     evaluateSegment(seg, t, xo, vo) {
-        this.evaluate(seg.at, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
+        this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
     }
-    evaluate(at, x0, x, v0, v, to, g, t, xo, vo) {
-        const n = this.n;
-        const dt = Math.max(0, t - at) / 1000;
-        const law = this.runs;
-        if (law[0] === EASED) {
-            this.eased(dt, law[2], x0, x, to, g, xo, vo);
-            return;
-        }
-        const settle = law[1];
-        let still = settle > 0;
-        prepare(law, dt);
-        for (let i = 0; i < n; i++) {
-            const goal = to[g + i];
-            solve(law, x0[x + i] - goal, v0[v + i], dt);
-            xo[i] = goal + solved.y;
-            vo[i] = solved.dy;
-            if (Math.abs(solved.y) > settle || Math.abs(solved.dy) > settle)
-                still = false;
-        }
-        if (still)
-            for (let i = 0; i < n; i++) {
-                xo[i] = to[g + i];
-                vo[i] = 0;
-            }
+    evaluate(at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+        return closed(this.runs, this.shape.ease, this.n, at, ms, x0, x, v0, v, to, g, t, xo, vo);
     }
-    /** A tween's stretch, `dt` seconds after release, kept out of `evaluate` so a spring's stays small. */
-    eased(dt, secs, x0, x, to, g, xo, vo) {
-        const ease = this.shape.ease;
-        const u = dt / secs;
-        // Subjects released together share `dt`, so a frame reads a bezier once, not once each.
-        if (dt !== memo.dt || ease !== memo.ease || secs !== memo.secs) {
-            memo.dt = dt;
-            memo.ease = ease;
-            memo.secs = secs;
-            memo.left = u >= 1 ? 0 : 1 - ease(u);
-        }
-        const left = memo.left;
-        let rate = 0;
-        if (slope && u < 1) {
-            const lo = Math.max(0, u - SPAN);
-            const hi = Math.min(1, u + SPAN);
-            rate = (ease(hi) - ease(lo)) / (hi - lo) / secs;
+}
+/**
+ * A stretch `t` voice ms into it, released at `at` from `x0` moving at `v0` toward `to` (each read
+ * from its offset), into `xo` and `vo`: the one copy of the closed forms, which `law` (a patch's
+ * `[form, settle, k1, k2, k3]`, the head of a patch's buffer or a copy of it) picks between. A tween reads `ease` and
+ * `ms`, the stretch's length, dividing in milliseconds so a boundary lands exactly; every other
+ * form ignores them.
+ */
+export function closed(law, ease, n, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+    if (law[0] === EASED)
+        return eased(ease, n, progress(t, at, ms), ms, x0, x, to, g, xo, vo);
+    const dt = Math.max(0, t - at) / 1000;
+    const settle = law[1];
+    let still = settle > 0;
+    prepare(law, dt);
+    for (let i = 0; i < n; i++) {
+        const goal = to[g + i];
+        solve(law, x0[x + i] - goal, v0[v + i], dt);
+        xo[i] = goal + solved.y;
+        vo[i] = solved.dy;
+        if (Math.abs(solved.y) > settle || Math.abs(solved.dy) > settle)
+            still = false;
+    }
+    if (still)
+        for (let i = 0; i < n; i++) {
+            xo[i] = to[g + i];
+            vo[i] = 0;
         }
-        for (let i = 0; i < this.n; i++) {
-            const goal = to[g + i];
-            const gap = x0[x + i] - goal;
-            xo[i] = left === 0 ? goal : goal + gap * left;
-            vo[i] = -gap * rate;
+    return still;
+}
+/** One `writes` array per channel, shared by every motion patch that writes it. */
+const writesOf = new Map();
+/**
+ * A `'motion'` patch: its methods on the prototype, where a closure each cost a function and its
+ * context per patch, and a mix may hold a patch per voice. Call them on the patch, not detached.
+ */
+class MotionPatch {
+    motions;
+    writes;
+    constructor(writes, motions) {
+        this.motions = motions;
+        let shared = writesOf.get(writes);
+        if (shared === undefined) {
+            shared = Object.freeze([writes]);
+            writesOf.set(writes, shared);
         }
+        this.writes = shared;
+    }
+    form = 'motion';
+    duration = 0;
+    period = 0;
+    get motion() {
+        return this.motions.spec();
+    }
+    at(_phase, subject, setting) {
+        const state = this.motions;
+        const s = state.slot(subject);
+        state.sample(s, setting.elapsed, state.xs, state.vs);
+        return { [this.writes[0]]: state.value(s, state.xs) };
+    }
+    read(subject, at) {
+        const state = this.motions;
+        const r = state.read(subject, at);
+        if (r === undefined)
+            return undefined;
+        return { value: state.value(r.s, r.x), velocity: state.value(r.s, r.v) };
+    }
+}
+class TweenPatch extends MotionPatch {
+    to(subject, goal, at) {
+        this.motions.change(subject, { at, to: axes(goal) });
+    }
+}
+class SpringPatch extends TweenPatch {
+    push(subject, velocity, at) {
+        this.motions.change(subject, { at, v: axes(velocity) });
+    }
+}
+class GlidePatch extends MotionPatch {
+    push(subject, velocity, at) {
+        this.motions.change(subject, { at, v: axes(velocity) });
     }
 }
-const states = new WeakMap();
 /** The state behind a `'motion'` patch, for an engine that reads it directly. */
 export function motionOf(p) {
-    return states.get(p);
+    return p instanceof MotionPatch ? p.motions : undefined;
 }
-function moving(writes, motion, shape) {
-    const state = new Motions(shape);
-    const push = (subject, velocity, at) => state.change(subject, { at, v: axes(velocity) });
-    const patch = {
-        form: 'motion',
-        period: 0,
-        writes: [writes],
-        motion,
-        at(_phase, subject, setting) {
-            const s = state.slot(subject);
-            state.sample(s, setting.elapsed, state.xs, state.vs);
-            return { [writes]: state.value(s, state.xs) };
-        },
-        read(subject, at) {
-            const r = state.read(subject, at);
-            if (r === undefined)
-                return undefined;
-            return { value: state.value(r.s, r.x), velocity: state.value(r.s, r.v) };
-        },
-    };
-    states.set(patch, state);
-    return { patch, state, push };
+/**
+ * The shapes of the stock motions, each one object over the options it reads, copied out of them so
+ * the caller's object is not kept: a closure per question cost a function and its context per
+ * patch, and a mix may hold a patch per voice.
+ */
+class SpringShape {
+    law;
+    motion;
+    ease = undefined;
+    ms = undefined;
+    goal;
+    start;
+    speed;
+    constructor(law, motion, opts) {
+        this.law = law;
+        this.motion = motion;
+        this.goal = opts.to;
+        this.start = opts.from ?? opts.to;
+        this.speed = opts.velocity;
+    }
+    spec() {
+        return this.motion;
+    }
+    from(s) {
+        return axes(per(this.start, s));
+    }
+    velocity(s, x) {
+        const v = this.speed;
+        return v === undefined ? still(x) : axes(per(v, s));
+    }
+    aim(_x, _v, was, s) {
+        return was ?? axes(per(this.goal, s));
+    }
+    scalar(s) {
+        return typeof per(this.goal, s) === 'number';
+    }
+    scalarEvery() {
+        return scalarOf(this.goal);
+    }
+}
+class GlideShape {
+    law;
+    motion;
+    tau;
+    ease = undefined;
+    ms = undefined;
+    start;
+    speed;
+    constructor(law, motion, opts, tau) {
+        this.law = law;
+        this.motion = motion;
+        this.tau = tau;
+        this.start = opts.from;
+        this.speed = opts.velocity;
+    }
+    spec() {
+        return this.motion;
+    }
+    from(s) {
+        return axes(per(this.start, s));
+    }
+    velocity(s, x) {
+        const v = this.speed;
+        return v === undefined ? still(x) : axes(per(v, s));
+    }
+    aim(x, v) {
+        return x.map((xi, i) => xi + v[i] * this.tau);
+    }
+    scalar(s) {
+        return typeof per(this.start, s) === 'number';
+    }
+    scalarEvery() {
+        return scalarOf(this.start);
+    }
+}
+const EASED_LAW = [EASED, 0, 0, 0, 0];
+class TweenShape {
+    law = EASED_LAW;
+    ease;
+    easing;
+    start;
+    goal;
+    length;
+    constructor(opts) {
+        this.easing = opts.ease ?? 'ease';
+        this.ease = curve(this.easing);
+        this.start = opts.from;
+        this.goal = opts.to;
+        this.length = opts.ms;
+    }
+    spec() {
+        const ms = this.length;
+        return { kind: 'tween', ms: typeof ms === 'number' ? ms : undefined, ease: this.easing };
+    }
+    from(s) {
+        return axes(per(this.start, s));
+    }
+    velocity(_s, x) {
+        return still(x);
+    }
+    aim(_x, _v, was, s) {
+        return was ?? axes(per(this.goal, s));
+    }
+    scalar(s) {
+        return typeof per(this.goal, s) === 'number';
+    }
+    scalarEvery() {
+        return scalarOf(this.goal);
+    }
+    ms(s) {
+        const length = per(this.length, s);
+        if (!(length > 0))
+            throw new Error('blits: a tween takes a positive ms');
+        return length;
+    }
 }
 /**
  * A damped spring toward a target, solved in closed form. `to(subject, target)` retargets one
@@ -554,19 +853,8 @@ export function spring(writes, opts) {
         const s = Math.sqrt(zeta * zeta - 1);
         law = [OVER, settle, -w0 * (zeta - s), -w0 * (zeta + s), 0];
     }
-    const target = (subject) => axes(per(opts.to, subject));
-    const { patch, state, push } = moving(writes, { kind: 'spring', stiffness: k, damping: c, mass: m, settle }, {
-        from: (s) => axes(per(opts.from ?? opts.to, s)),
-        velocity: (s) => opts.velocity === undefined ? target(s).map(() => 0) : axes(per(opts.velocity, s)),
-        aim: (_x, _v, was, s) => was ?? target(s),
-        law,
-        scalar: (s) => typeof per(opts.to, s) === 'number',
-        ease: undefined,
-    });
-    return Object.assign(patch, {
-        push,
-        to: (subject, goal, at) => state.change(subject, { at, to: axes(goal) }),
-    });
+    const motion = { kind: 'spring', stiffness: k, damping: c, mass: m, settle };
+    return new SpringPatch(writes, new Motions(new SpringShape(law, motion, opts)));
 }
 /**
  * Coasting under friction, a fling: a subject keeps its velocity, which falls by a factor of e every
@@ -579,17 +867,8 @@ export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
-    const { patch, push } = moving(writes, { kind: 'glide', ms, settle }, {
-        from: (s) => axes(per(opts.from, s)),
-        velocity: (s) => opts.velocity === undefined
-            ? axes(per(opts.from, s)).map(() => 0)
-            : axes(per(opts.velocity, s)),
-        aim: (x, v) => x.map((xi, i) => xi + v[i] * tau),
-        law: [COAST, settle, tau, 0, 0],
-        scalar: (s) => typeof per(opts.from, s) === 'number',
-        ease: undefined,
-    });
-    return Object.assign(patch, { push });
+    const shape = new GlideShape([COAST, settle, tau, 0, 0], { kind: 'glide', ms, settle }, opts, tau);
+    return new GlidePatch(writes, new Motions(shape));
 }
 /**
  * From one value to another over `ms` along an easing, solved in closed form, so frame rate does not
@@ -601,19 +880,8 @@ export function glide(writes, opts) {
  * @category patch
  */
 export function tween(writes, opts) {
-    if (!(opts.ms > 0))
-        throw new Error('blits: a tween takes a positive ms');
-    const ease = opts.ease ?? 'ease';
-    const target = (subject) => axes(per(opts.to, subject));
-    const { patch, state } = moving(writes, { kind: 'tween', ms: opts.ms, ease }, {
-        from: (s) => axes(per(opts.from, s)),
-        velocity: (s) => target(s).map(() => 0),
-        aim: (_x, _v, was, s) => was ?? target(s),
-        law: [EASED, 0, opts.ms / 1000, 0, 0],
-        scalar: (s) => typeof per(opts.to, s) === 'number',
-        ease: curve(ease),
-    });
-    return Object.assign(patch, {
-        to: (subject, goal, at) => state.change(subject, { at, to: axes(goal) }),
-    });
+    const shape = new TweenShape(opts);
+    if (typeof opts.ms === 'number')
+        shape.ms(undefined);
+    return new TweenPatch(writes, new Motions(shape));
 }