@msb235/blits 0.5.0 → 0.7.0

package/dist/motions.js

@@ -0,0 +1,724 @@
+import { closed } from './closed.js';
+import { absent, Numbers } from './numbers.js';
+import { reading } from './reading.js';
+import { Store } from './store.js';
+import { sloped } from './tweened.js';
+/**
+ * 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;
+/** A run that shares nothing with the patch's own. */
+const runOf = (r) => ({
+    flags: r.flags,
+    stretches: r.stretches.map((seg) => ({ ...seg })),
+    pending: r.pending?.map((c) => ({ ...c })),
+});
+/** `segs`, in time order, ahead of `list`: those older than its first, one per time. */
+function ahead(segs, list) {
+    const first = list[0].at;
+    const out = [];
+    for (const seg of [...segs].sort((x, y) => x.at - y.at))
+        if (seg.at < first && out[out.length - 1]?.at !== seg.at)
+            out.push(seg);
+    return out.length === 0 ? list : [...out, ...list];
+}
+/** 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;
+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;
+    /** By subject number, the change that released the stretch it is playing; null until one has. */
+    causes = 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.size(n);
+        const s = this.take(subject);
+        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;
+    }
+    /** Sets the axes every subject moves on, at the first. */
+    size(n) {
+        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;
+    }
+    /** Numbers `subject`, with room for its run. */
+    take(subject) {
+        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);
+        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;
+    }
+    /**
+     * Subjects released at a mix time a rewind may still reach, with their run as it stood, so a
+     * rewind before the release plays them on from there. Empty without history.
+     */
+    released = [];
+    /**
+     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at`, under
+     * history, its run is kept for a rewind before then, until `reach` passes it.
+     */
+    release(subject, at, reach = Number.NEGATIVE_INFINITY) {
+        const s = this.known(subject);
+        if (s === undefined)
+            return;
+        if (at !== undefined) {
+            const kept = [];
+            for (const e of this.released)
+                if (e.at >= reach)
+                    kept.push(e);
+                else
+                    this.owner?.page(this.ownerId, 'released', e.subject, [{ at: e.at, data: runOf(e) }]);
+            this.released = kept;
+            this.released.push({ subject, at, ...this.runAt(s) });
+        }
+        this.slots.delete(subject);
+        this.numbers.release(s);
+    }
+    /** Puts back each subject released after mix time `t`, as it stood when released. */
+    unrelease(t) {
+        const back = this.released.filter((e) => e.at > t).sort((a, b) => a.at - b.at);
+        if (back.length === 0)
+            return;
+        this.released = this.released.filter((e) => e.at <= t);
+        const done = new Set();
+        for (const e of back) {
+            if (done.has(e.subject))
+                continue;
+            done.add(e.subject);
+            this.unpack(e.subject, e);
+        }
+    }
+    /** Subject `s`'s run as it stands. */
+    runAt(s) {
+        const older = this.older?.[s];
+        const pending = this.pending?.[s];
+        return {
+            flags: this.runs[this.base(s) + 1],
+            stretches: older === undefined ? [this.latest(s)] : [...older, this.latest(s)],
+            pending: pending === undefined ? undefined : [...pending],
+        };
+    }
+    /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
+    pack(subject) {
+        const s = this.known(subject);
+        return s === undefined ? undefined : runOf(this.runAt(s));
+    }
+    /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
+    unpack(subject, run) {
+        const now = this.known(subject);
+        if (now !== undefined) {
+            this.slots.delete(subject);
+            this.numbers.release(now);
+        }
+        if (this.n < 0)
+            this.size(run.stretches[0].x0.length);
+        const s = this.take(subject);
+        this.runs[this.base(s) + 1] = run.flags & ~(OLDER | PENDING);
+        const latest = run.stretches[run.stretches.length - 1];
+        this.write(s, latest);
+        if (run.stretches.length > 1) {
+            if (this.older === null)
+                this.older = [undefined];
+            this.older[s] = run.stretches.slice(0, -1);
+            this.flag(s, OLDER, true);
+        }
+        if (run.pending !== undefined) {
+            if (this.pending === null)
+                this.pending = [undefined];
+            this.pending[s] = run.pending;
+            this.flag(s, PENDING, true);
+        }
+    }
+    /** A released run a history store gave back, for a rewind to before its release. */
+    reclaim(subject, at, run) {
+        if (this.released.some((e) => e.at === at && Object.is(e.subject, subject)))
+            return;
+        this.released.push({ subject, at, ...run });
+    }
+    /**
+     * Stretches a history store gave back, each by the mix time it was in force by: each life of the
+     * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
+     */
+    restretch(subject, back) {
+        const lives = this.released
+            .filter((e) => Object.is(e.subject, subject))
+            .sort((x, y) => x.at - y.at);
+        let from = Number.NEGATIVE_INFINITY;
+        const within = (to) => back.filter((r) => r.at > from && r.at <= to).map((r) => r.data);
+        for (const e of lives) {
+            e.stretches = ahead(within(e.at), e.stretches);
+            from = e.at;
+        }
+        const s = this.known(subject);
+        if (s === undefined)
+            return;
+        const older = this.older?.[s] ?? [];
+        const list = ahead(within(Number.POSITIVE_INFINITY), [...older, this.latest(s)]);
+        if (list.length === older.length + 1)
+            return;
+        if (this.older === null)
+            this.older = [undefined];
+        this.older[s] = list.slice(0, -1);
+        this.flag(s, OLDER, true);
+    }
+    /**
+     * 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);
+        c.made = this.owner === null ? Number.NaN : this.owner.now();
+        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++;
+        const made = { at: c.at, to: c.to, v: c.v };
+        this.owner?.changed(this.ownerId, this, subject, made);
+    }
+    /** 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;
+        if (this.causes !== null)
+            this.causes[s] = undefined;
+    }
+    /**
+     * Takes back every change made after mix time `t`: each subject plays from its earliest stretch
+     * kept, with the changes made by then queued to be applied again.
+     */
+    rewind(t) {
+        this.unrelease(t);
+        for (let s = 0; s < this.numbers.size; s++)
+            if (this.numbers.subject(s) !== absent)
+                this.cut(s, t);
+    }
+    cut(s, t) {
+        const older = this.older?.[s];
+        const pending = this.pending?.[s];
+        const current = this.latest(s);
+        const stretches = older === undefined ? [current] : [...older, current];
+        const kept = [];
+        let cut = false;
+        for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
+            if (c === undefined || c.made === undefined || !(c.made > t)) {
+                if (c !== undefined)
+                    kept.push(c);
+            }
+            else
+                cut = true;
+        if (!cut)
+            return;
+        if (older !== undefined) {
+            this.older[s] = undefined;
+            this.flag(s, OLDER, false);
+        }
+        this.write(s, stretches[0]);
+        // Applied again in the order they take effect; one never stamped waits for the next read.
+        const timed = kept
+            .filter((c) => c.at !== undefined)
+            .sort((a, b) => a.at - b.at);
+        const list = [...timed, ...kept.filter((c) => c.at === undefined)];
+        if (list.length === 0) {
+            if (pending !== undefined) {
+                this.pending[s] = undefined;
+                this.flag(s, PENDING, false);
+            }
+            return;
+        }
+        if (this.pending === null)
+            this.pending = [undefined];
+        this.pending[s] = list;
+        this.flag(s, PENDING, true);
+    }
+    /** 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);
+        if (seg.change !== undefined || this.causes !== null) {
+            this.causes ??= [];
+            this.causes[s] = seg.change;
+        }
+        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)),
+            change: this.causes?.[s],
+        };
+    }
+    /** 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, change };
+    }
+    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);
+    }
+    /**
+     * The mix time a stretch was in force by, which a store keys it under: when the change that
+     * ended it was made, which falls in the same life of the subject.
+     */
+    made(next) {
+        const made = next.change?.made;
+        return made === undefined || Number.isNaN(made) ? (this.owner?.now() ?? Number.NaN) : made;
+    }
+    /** Lets go of stretches older than the one in force at `reading.horizon`. */
+    prune(s) {
+        const list = this.older?.[s];
+        if (list === undefined)
+            return;
+        let n = 0;
+        while (n < list.length &&
+            (n + 1 < list.length ? list[n + 1].at : this.runs[this.base(s)]) <=
+                reading.horizon)
+            n++;
+        if (n === 0)
+            return;
+        const out = list.splice(0, n);
+        const subject = this.numbers.subject(s);
+        if (this.owner !== null && subject !== absent)
+            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({
+                at: this.made(out[i + 1] ?? list[0] ?? this.latest(s)),
+                data: seg,
+            })));
+        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);
+    }
+}