@msb235/blits 0.5.0 → 0.7.0

package/dist/motion.js

@@ -1,661 +1,11 @@
+import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 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;
-const COAST = 3;
-const EASED = 4;
-/**
- * A patch's law, `[form, settle, k1, k2, k3]`: which closed form its stretches follow, its `settle`,
- * and up to three constants that form reads. It heads the patch's `runs`, so `solve` finds them in
- * the buffer a sample already reads rather than in an object of their own.
- */
-const HEAD = 5;
-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.
- */
-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 };
-/** 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) {
-    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];
-            const wd = law[4];
-            timed.e = Math.exp(-zeta * w0 * t);
-            timed.cos = Math.cos(wd * t);
-            timed.sin = Math.sin(wd * t);
-            return;
-        }
-        case CRITICAL: {
-            const w0 = law[3];
-            timed.e = Math.exp(-w0 * t);
-            return;
-        }
-        case OVER: {
-            timed.e = Math.exp(law[2] * t);
-            timed.e2 = Math.exp(law[3] * t);
-            return;
-        }
-        default:
-            timed.e = Math.exp(-t / law[2]);
-    }
-}
-/**
- * One axis, `t` seconds after release, `y0` from where it heads and moving at `v0`, into `solved`,
- * with `timed` prepared for `t`.
- */
-function solve(law, y0, v0, t) {
-    switch (law[0]) {
-        case UNDER: {
-            const zeta = law[2];
-            const w0 = law[3];
-            const wd = law[4];
-            const e = timed.e;
-            const b = (v0 + zeta * w0 * y0) / wd;
-            const cos = timed.cos;
-            const sin = timed.sin;
-            const y = e * (y0 * cos + b * sin);
-            solved.y = y;
-            solved.dy = -zeta * w0 * y + e * wd * (b * cos - y0 * sin);
-            return;
-        }
-        case CRITICAL: {
-            const w0 = law[3];
-            const e = timed.e;
-            const b = v0 + w0 * y0;
-            const y = e * (y0 + b * t);
-            solved.y = y;
-            solved.dy = e * b - w0 * y;
-            return;
-        }
-        case OVER: {
-            const r1 = law[2];
-            const r2 = law[3];
-            const a = (v0 - r2 * y0) / (r1 - r2);
-            const b = y0 - a;
-            const e1 = timed.e;
-            const e2 = timed.e2;
-            solved.y = a * e1 + b * e2;
-            solved.dy = a * r1 * e1 + b * r2 * e2;
-            return;
-        }
-        default: {
-            // Released at x moving at v, a glide comes to rest at x + v·τ; y is the distance still to go,
-            // which friction closes as e^(−t/τ), and its derivative at release is v again.
-            const tau = law[2];
-            const e = timed.e;
-            solved.y = y0 * e;
-            solved.dy = (-y0 / tau) * e;
-        }
-    }
-}
+import { Motions } from './motions.js';
 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, 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(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;
-    /**
-     * 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 = unsized;
-    vs = unsized;
-    /**
-     * 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.
-     */
-    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;
-    }
-    /** The patch's number for `subject`, made with its first stretch on first ask. */
-    slot(subject) {
-        const known = this.known(subject);
-        if (known !== undefined)
-            return known;
-        const x = this.shape.from(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;
-        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;
-            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);
-        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] = 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.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;
-    }
-    /** The value `at` hands the mix: the first axis for a number, a fresh array otherwise. */
-    value(s, xs) {
-        if ((this.runs[this.base(s) + 1] & SCALAR) !== 0)
-            return xs[0];
-        const n = this.n;
-        const out = new Array(n);
-        for (let i = 0; i < n; i++)
-            out[i] = xs[i];
-        return out;
-    }
-    /**
-     * Position and velocity at voice time `t` into `xo` and `vo`, a tween's velocity left at 0. A live
-     * read stamps every untimed change with `t` and commits every change due by then, in time order;
-     * a projection's read applies the timed ones to a copy and commits nothing.
-     */
-    sample(s, t, xo, vo) {
-        if (reading.live) {
-            const runs = this.runs;
-            const b = this.base(s);
-            if (runs[b + 1] & PENDING)
-                this.commit(s, t);
-            if (runs[b + 1] & OLDER)
-                this.prune(s);
-            const at = runs[b];
-            if (t < at && runs[b + 1] & OLDER)
-                this.evaluateSegment(this.playing(s, t), t, xo, vo);
-            else {
-                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.
-     */
-    quiet(s, t) {
-        const runs = this.runs;
-        const b = this.base(s);
-        const flags = runs[b + 1];
-        if (flags & PENDING) {
-            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[s];
-            const next = list.length > 1 ? list[1].at : runs[b];
-            if (next <= reading.horizon)
-                return false;
-        }
-        return true;
-    }
-    /** Position and velocity at `at`, default the latest frame; undefined until there is one. */
-    read(subject, at) {
-        const s = this.known(subject);
-        if (s === undefined)
-            return undefined;
-        const when = at ?? this.frame(subject);
-        if (Number.isNaN(when))
-            return undefined;
-        const x = new Float64Array(this.n);
-        const v = new Float64Array(this.n);
-        sloped(true);
-        try {
-            this.peek(s, when, x, v);
-        }
-        finally {
-            sloped(false);
-        }
-        return { x, v, s };
-    }
-    /**
-     * Queues a retarget or push, untimed at the latest frame, for `subject`'s next read past its time.
-     * 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);
-        if (c.at === undefined) {
-            const at = this.frame(subject);
-            if (!Number.isNaN(at))
-                c.at = at;
-        }
-        const list = this.pending?.[s];
-        if (list === undefined) {
-            if (this.pending === null)
-                this.pending = [undefined];
-            this.pending[s] = [c];
-            this.flag(s, PENDING, true);
-        }
-        else if (c.at === undefined)
-            list.push(c);
-        else
-            this.queue(list, c, c.at);
-        reading.moved++;
-    }
-    /** Files a change with a time after every one due by then, ahead of those still waiting for one. */
-    queue(list, c, at) {
-        let i = list.length;
-        while (i > 0) {
-            const before = list[i - 1].at;
-            if (before !== undefined && before <= at)
-                break;
-            i--;
-        }
-        list.splice(i, 0, c);
-    }
-    /** 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?.[s];
-        if (list !== undefined)
-            for (const change of list) {
-                const a = change.at;
-                if (a === undefined || !(a <= t))
-                    break;
-                if (a >= seg.at)
-                    seg = this.applied(s, seg, change, a);
-            }
-        this.evaluateSegment(seg, t, xo, vo);
-    }
-    check(a, n) {
-        if (a !== undefined && a.length !== n)
-            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) {
-        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) {
-        return HEAD + s * this.stride;
-    }
-    grow(size) {
-        if (size <= this.cap)
-            return;
-        const cap = Math.max(size, this.cap * 2);
-        const runs = new Float64Array(HEAD + cap * this.stride);
-        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 + 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) + 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)),
-        };
-    }
-    /** The stretch playing at voice time `t`: the latest released by then, else the first. */
-    playing(s, t) {
-        const list = this.older?.[s];
-        if (list === undefined || t >= this.runs[this.base(s)])
-            return this.latest(s);
-        if (list[0].at > t)
-            return list[0];
-        let lo = 0;
-        let hi = list.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi + 1) >> 1;
-            if (list[mid].at <= t)
-                lo = mid;
-            else
-                hi = mid - 1;
-        }
-        return list[lo];
-    }
-    applied(s, seg, change, at) {
-        const x = new Float64Array(this.n);
-        const v = new Float64Array(this.n);
-        this.evaluateSegment(seg, at, x, v);
-        const xs = Array.from(x);
-        const vs = change.v ?? Array.from(v);
-        const subject = this.numbers.subject(s);
-        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[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;
-            while (i > 0 && list[i - 1].at === undefined)
-                i--;
-            for (const c of list.splice(i)) {
-                c.at = t;
-                this.queue(list, c, t);
-            }
-        }
-        while (list.length > 0) {
-            const change = list[0];
-            const a = change.at;
-            if (a > t)
-                break;
-            list.shift();
-            this.insert(s, this.applied(s, this.playing(s, a), change, a));
-        }
-        if (list.length === 0) {
-            this.pending[s] = undefined;
-            this.flag(s, PENDING, false);
-        }
-    }
-    insert(s, seg) {
-        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)]) {
-            list.push(this.latest(s));
-            this.write(s, seg);
-            return;
-        }
-        let i = list.length;
-        while (i > 0 && list[i - 1].at > seg.at)
-            i--;
-        list.splice(i, 0, seg);
-    }
-    /** Lets go of stretches older than the one in force at `reading.horizon`. */
-    prune(s) {
-        const list = this.older?.[s];
-        if (list === undefined)
-            return;
-        while (list.length > 0 &&
-            (list.length > 1 ? list[1].at : this.runs[this.base(s)]) <=
-                reading.horizon)
-            list.shift();
-        if (list.length === 0) {
-            this.older[s] = undefined;
-            this.flag(s, OLDER, false);
-        }
-    }
-    evaluateSegment(seg, t, xo, vo) {
-        this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
-    }
-    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 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;
-        }
-    return still;
-}
 /** One `writes` array per channel, shared by every motion patch that writes it. */
 const writesOf = new Map();
 /**