@msb235/blits 0.4.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,13 +14,11 @@ 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;
-export const noRevive = () => { };
-export const noTouch = () => { };
 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) };
+/** 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.
@@ -33,18 +32,29 @@ const LANDED = 8;
  * 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 = { u: Number.NaN, ease: undefined, 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];
@@ -118,7 +128,11 @@ 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.
@@ -131,47 +145,76 @@ const per = (p, subject) => typeof p === 'function' ? p(subject) : p;
  */
 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;
     /**
-     * Brings a subject its voice faded out back to it, so a change is not made for nothing. Set by
-     * the mix that cues the patch, and put back when its voice retires.
+     * 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.
      */
-    revive = noRevive;
+    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 = 3 + 3 * n;
@@ -181,32 +224,59 @@ export class Motions {
             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.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);
     }
     /**
-     * Called with a subject's number whenever its 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, put back when its voice retires.
+     * 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.
      */
-    touched = noTouch;
+    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.runs.slice(0, HEAD);
+        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
@@ -264,14 +334,22 @@ export class Motions {
         }
         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.base(s);
-        if ((runs[b + 1] & (PENDING | OLDER)) !== 0)
+        const b = this.bareAt(s);
+        if (b < 0)
             return false;
         const x = b + 3;
         const n = this.n;
@@ -316,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;
@@ -331,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);
@@ -339,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 };
     }
@@ -353,7 +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.revive(subject);
+        this.owner?.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
         this.check(c.v, this.n);
@@ -362,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)
@@ -387,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;
@@ -403,14 +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.touched(s);
+        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) {
@@ -421,14 +503,14 @@ 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.touched(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;
@@ -452,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)
@@ -481,7 +563,7 @@ export class Motions {
         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;
@@ -501,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--;
@@ -529,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 &&
@@ -537,7 +616,7 @@ export class Motions {
                 reading.horizon)
             list.shift();
         if (list.length === 0) {
-            this.older.delete(s);
+            this.older[s] = undefined;
             this.flag(s, OLDER, false);
         }
     }
@@ -557,7 +636,7 @@ export class Motions {
  */
 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, Math.max(0, t - at) / ms, ms, x0, x, to, g, xo, vo);
+        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;
@@ -577,56 +656,178 @@ export function closed(law, ease, n, at, ms, x0, x, v0, v, to, g, t, xo, vo) {
         }
     return still;
 }
-/** A tween's stretch, `dt` seconds after release, kept out of `closed` so a spring's stays small. */
-function eased(ease, n, u, ms, x0, x, to, g, xo, vo) {
-    // Subjects released together share `u`, so a frame reads a bezier once, not once each.
-    if (u !== memo.u || ease !== memo.ease) {
-        memo.u = u;
-        memo.ease = ease;
-        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)) * (1000 / ms);
+/** 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;
     }
-    for (let i = 0; i < 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;
+    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) });
     }
-    return left === 0;
 }
-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
@@ -652,20 +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,
-        ms: 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
@@ -678,18 +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,
-        ms: 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
@@ -701,27 +880,8 @@ export function glide(writes, opts) {
  * @category patch
  */
 export function tween(writes, opts) {
-    const fixed = typeof opts.ms === 'number';
-    const ms = (subject) => {
-        const length = per(opts.ms, subject);
-        if (!(length > 0))
-            throw new Error('blits: a tween takes a positive ms');
-        return length;
-    };
-    if (fixed)
-        ms(undefined);
-    const ease = opts.ease ?? 'ease';
-    const target = (subject) => axes(per(opts.to, subject));
-    const { patch, state } = moving(writes, { kind: 'tween', ms: fixed ? opts.ms : undefined, 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, 0, 0, 0],
-        scalar: (s) => typeof per(opts.to, s) === 'number',
-        ease: curve(ease),
-        ms,
-    });
-    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));
 }