@msb235/blits 0.4.0 → 0.5.0

package/dist/book.js

@@ -0,0 +1,218 @@
+/** A clock read further than this from the offset's prediction is a jump, not jitter. */
+const RESYNC_MS = 50;
+/** The share of each frame's residual folded into the offset. */
+const SLEW = 0.05;
+/** A booking whose time moves by more than this is stopped and taken again. */
+const RETIME_MS = 1;
+const none = [];
+/** Refuses hits a voice could never play. */
+export function checkHits(hits, duration) {
+    for (const h of hits)
+        if (!(h.at >= 0) || (duration > 0 ? !(h.at < duration) : !Number.isFinite(h.at)))
+            throw new RangeError(duration > 0
+                ? `blits: a hit's at is voice ms into a pass, 0 up to ${duration}, not ${h.at}`
+                : `blits: a hit's at is voice ms, 0 or more, not ${h.at}`);
+}
+/** One `book` call: maps host time onto the outside clock and takes each item once. */
+export class Book {
+    host;
+    opts;
+    /** The outside clock at the last sync, smoothed; NaN until the first. */
+    est = Number.NaN;
+    last = Number.NaN;
+    /** The mix clock at the previous sync, where a voice's clock change counts from. */
+    prev = Number.NaN;
+    round = 0;
+    stopped = false;
+    /** Bookings of marks, by `keyOf`, kept while listed so one already taken is not taken late. */
+    marked = new Map();
+    tracks = new Map();
+    due = [];
+    constructor(host, opts) {
+        this.host = host;
+        this.opts = opts;
+    }
+    /** Books what comes within `ahead` of this sync, and retracts what moved. */
+    sync() {
+        if (this.stopped)
+            return;
+        const host = this.host;
+        const now = host.timestamp;
+        const c = this.opts.clock();
+        if (Number.isNaN(this.est))
+            this.est = c;
+        else {
+            const est = this.est + (now - this.last);
+            const residual = c - est;
+            this.est = Math.abs(residual) > RESYNC_MS ? c : est + residual * SLEW;
+        }
+        this.last = now;
+        const prev = Number.isNaN(this.prev) ? host.now : this.prev;
+        this.prev = host.now;
+        this.round++;
+        this.marks(now);
+        this.hits(now, prev);
+        const due = this.due;
+        due.sort((a, b) => a.time - b.time);
+        const late = this.opts.late;
+        for (const d of due) {
+            const lateBy = d.time < now ? now - d.time : 0;
+            if (lateBy > late)
+                continue;
+            const at = this.est + (d.time - now);
+            const booking = { time: d.time, at, taken: undefined };
+            d.into.set(d.key, booking);
+            booking.taken = this.opts.take(d.item, lateBy > 0 ? c : Math.max(at, c), lateBy);
+        }
+        due.length = 0;
+        for (const t of this.tracks.values())
+            for (const [k, b] of t.booked)
+                if (b.time <= now)
+                    t.booked.delete(k);
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        for (const b of this.marked.values())
+            if (b.time > this.last)
+                b.taken?.stop();
+        for (const t of this.tracks.values())
+            for (const b of t.booked.values())
+                if (b.time > this.last)
+                    b.taken?.stop();
+        this.marked.clear();
+        this.tracks.clear();
+        this.host.unhook(this);
+    }
+    /** Whether a standing booking now falls at host time `time` within `RETIME_MS`. */
+    stands(b, time) {
+        if (time === undefined || !Number.isFinite(time))
+            return false;
+        return Math.abs(this.est + (time - this.last) - b.at) <= RETIME_MS;
+    }
+    fits(score, tags) {
+        const { tag, score: wants } = this.opts;
+        return (wants === undefined || score === wants) && (tag === undefined || tags.includes(tag));
+    }
+    marks(now) {
+        const listed = this.host.marks(now - this.opts.late, now + this.opts.ahead);
+        const marked = this.marked;
+        const seen = new Set();
+        for (const m of listed) {
+            if (!this.fits(m.score, m.tags))
+                continue;
+            const key = keyOf(m);
+            seen.add(key);
+            const b = marked.get(key);
+            if (b !== undefined) {
+                if (b.time <= now || this.stands(b, m.timestamp))
+                    continue;
+                b.taken?.stop();
+                marked.delete(key);
+            }
+            const { order: _, ...item } = m;
+            this.due.push({ time: m.timestamp, item, into: marked, key });
+        }
+        for (const [key, b] of marked)
+            if (!seen.has(key)) {
+                if (b.time > now)
+                    b.taken?.stop();
+                marked.delete(key);
+            }
+    }
+    hits(now, prev) {
+        const host = this.host;
+        const round = this.round;
+        const { ahead, late } = this.opts;
+        const hiAt = host.readingAt(now + ahead);
+        const loAt = Number.isFinite(late) ? host.readingAt(now - late) : Number.NEGATIVE_INFINITY;
+        for (const voice of host.voices) {
+            const hits = voice.spec.hits;
+            if (hits === undefined || hits.length === 0 || voice.state === 'done')
+                continue;
+            if (!this.fits(voice.spec.score, voice.spec.tags ?? none))
+                continue;
+            let t = this.tracks.get(voice);
+            if (t === undefined) {
+                t = { seenTo: Number.NEGATIVE_INFINITY, seeks: voice.seeks, booked: new Map(), met: round };
+                this.tracks.set(voice, t);
+            }
+            t.met = round;
+            // A seek counts from where it put the clock: what it jumped over is not late.
+            if (t.seeks !== voice.seeks) {
+                t.seeks = voice.seeks;
+                t.seenTo = voice.elapsedAt(prev);
+            }
+            const end = host.endOf(voice);
+            const n = hits.length;
+            let moved = false;
+            for (const [key, b] of t.booked) {
+                if (b.time <= now)
+                    continue;
+                const time = this.timeOfHit(voice, hits, Math.floor(key / n), key % n, end);
+                if (this.stands(b, time))
+                    continue;
+                b.taken?.stop();
+                t.booked.delete(key);
+                moved = true;
+            }
+            // What moved is looked for again from the last sync on, so one now past is taken late.
+            if (moved)
+                t.seenTo = Math.min(t.seenTo, voice.elapsedAt(prev));
+            const hi = voice.elapsedAt(hiAt);
+            if (!(hi > t.seenTo))
+                continue;
+            const lo = Math.max(t.seenTo, voice.elapsedAt(loAt));
+            const d = voice.duration;
+            const last = d > 0 ? Math.min(voice.passes - 1, Math.floor(hi / d)) : 0;
+            for (let pass = d > 0 ? Math.max(0, Math.floor(lo / d)) : 0; pass <= last; pass++) {
+                for (let i = 0; i < n; i++) {
+                    const e = pass * d + hits[i].at;
+                    if (!(e > t.seenTo && e <= hi))
+                        continue;
+                    const key = pass * n + i;
+                    if (t.booked.has(key))
+                        continue;
+                    const time = this.timeOfHit(voice, hits, pass, i, end);
+                    if (time === undefined || !Number.isFinite(time))
+                        continue;
+                    const item = {
+                        timestamp: time,
+                        voice: voice.id,
+                        hit: i,
+                        pass,
+                        event: hits[i].event,
+                        score: voice.spec.score,
+                        name: voice.spec.name,
+                        tags: voice.spec.tags ?? none,
+                    };
+                    this.due.push({ time, item, into: t.booked, key });
+                }
+            }
+            t.seenTo = hi;
+        }
+        for (const [voice, t] of this.tracks) {
+            if (t.met === round)
+                continue;
+            for (const b of t.booked.values())
+                if (b.time > now)
+                    b.taken?.stop();
+            this.tracks.delete(voice);
+        }
+    }
+    /** Host time of a hit's pass, or undefined where the voice no longer plays it. */
+    timeOfHit(voice, hits, pass, i, end) {
+        if (voice.state === 'done' || pass >= voice.passes)
+            return undefined;
+        const t = voice.timeAt(pass * voice.duration + hits[i].at);
+        if (!Number.isFinite(t) || (end !== undefined && t >= end))
+            return undefined;
+        return this.host.hostOf(t);
+    }
+}
+const markIndex = { start: 1, in: 2, out: 3, end: 4 };
+/** A mark's identity: its voice and which of the four, or the announcement. */
+function keyOf(m) {
+    return m.order * 5 + (m.mark === undefined ? 0 : markIndex[m.mark]);
+}

package/dist/chain.d.ts

@@ -0,0 +1,22 @@
+import type { Mixer } from './mixer.js';
+import type { Subject, Voice } from './voice.js';
+/**
+ * The first of this subject's records, linked through every live voice that reaches it. A voice
+ * is asked once, through the record it keeps for the subject anyway; a pending one is linked when
+ * it goes live, since `target` is asked on first sight, and sight only comes once a voice plays
+ * or holds before.
+ */
+export declare function chain<I, O>(this: Mixer<I, O>, subject: I, now: number): Subject<unknown>;
+/** A voice's record for a subject where its chain links it: the voice plays or holds, and reaches it. */
+export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, slot: number): Subject<unknown> | null;
+/** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
+export declare function aims<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): boolean;
+/**
+ * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
+ * are relinked, every subject's for a voice over all of them and only its own for one naming
+ * its subjects, and lanes take it on or off.
+ */
+export declare function changed<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Files a voice under each subject it names, or among the voices that name none. */
+export declare function index<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+export declare function unindex<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;

package/dist/chain.js

@@ -0,0 +1,150 @@
+/** The first record of a subject no live voice reaches, so a probe of it still makes one lookup. */
+function stub() {
+    return {
+        reaches: false,
+        delay: 0,
+        since: 0,
+        shown: 0,
+        weight: 0,
+        rested: false,
+        bands: null,
+        state: undefined,
+        stepped: 0,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        kept: null,
+        voice: null,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+    };
+}
+/**
+ * The first of this subject's records, linked through every live voice that reaches it. A voice
+ * is asked once, through the record it keeps for the subject anyway; a pending one is linked when
+ * it goes live, since `target` is asked on first sight, and sight only comes once a voice plays
+ * or holds before.
+ */
+export function chain(subject, now) {
+    const was = this.chains.get(subject);
+    if (was !== undefined && was.version === this.version)
+        return was;
+    const slot = was !== undefined ? was.slot : this.lanes !== null ? this.lanes.number(subject) : -1;
+    // Where only voices over every subject changed since, those alone are taken off or put on.
+    let first = was === undefined
+        ? undefined
+        : this.steps.patch(was.voice === null ? null : was, was.version, (voice) => this.linkable(voice, subject, now, slot));
+    if (first === undefined) {
+        let prev = null;
+        first = null;
+        const link = (voice) => {
+            const held = this.linkable(voice, subject, now, slot);
+            if (held === null)
+                return;
+            held.voice = voice;
+            held.next = null;
+            if (prev === null)
+                first = held;
+            else
+                prev.next = held;
+            prev = held;
+        };
+        const named = this.naming === 0 ? undefined : this.named.get(subject);
+        let j = 0;
+        for (const voice of this.general) {
+            while (named !== undefined && j < named.length && named[j].id < voice.id)
+                link(named[j++]);
+            link(voice);
+        }
+        while (named !== undefined && j < named.length)
+            link(named[j++]);
+    }
+    const head = first ?? stub();
+    head.version = this.version;
+    if (was !== undefined && was !== head) {
+        head.loci = was.loci;
+        was.loci = null;
+        head.slot = was.slot;
+        was.slot = -1;
+    }
+    else if (was === undefined)
+        head.slot = slot;
+    if (was !== head)
+        this.chains.set(subject, head);
+    return head;
+}
+/** A voice's record for a subject where its chain links it: the voice plays or holds, and reaches it. */
+export function linkable(voice, subject, now, slot) {
+    const state = voice.state;
+    if (state === 'done' || (state === 'pending' && !voice.holdsBefore))
+        return null;
+    const held = this.held(voice, subject, now, slot);
+    return held.reaches ? held : null;
+}
+/** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
+export function aims(voice, subject) {
+    // A read back to before a subject left still finds it reached.
+    const left = voice.parted?.get(subject);
+    if (left !== undefined && !(this.now < left))
+        return false;
+    if (voice.named !== null)
+        return voice.named.has(subject);
+    return voice.spec.target ? voice.spec.target(subject) : true;
+}
+/**
+ * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
+ * are relinked, every subject's for a voice over all of them and only its own for one naming
+ * its subjects, and lanes take it on or off.
+ */
+export function changed(mix, voice) {
+    // An owner is in no chain and on no lane; what it changes in its children, a fill reads afresh.
+    if (voice.holding !== null) {
+        mix.lanes?.refill();
+        return;
+    }
+    mix.lanes?.touch(voice);
+    if (voice.named === null) {
+        mix.steps.push(voice, ++mix.version);
+        return;
+    }
+    for (const subject of voice.named) {
+        const head = mix.chains.get(subject);
+        if (head !== undefined)
+            head.version = Number.NaN;
+    }
+    mix.relinks++;
+}
+/** Files a voice under each subject it names, or among the voices that name none. */
+export function index(mix, voice) {
+    if (voice.holding !== null)
+        return;
+    if (voice.named === null) {
+        mix.general.push(voice);
+        return;
+    }
+    mix.naming++;
+    for (const subject of voice.named) {
+        const list = mix.named.get(subject);
+        if (list === undefined)
+            mix.named.set(subject, [voice]);
+        else
+            list.push(voice);
+    }
+}
+export function unindex(mix, voice) {
+    mix.naming--;
+    for (const subject of voice.named) {
+        const list = mix.named.get(subject);
+        if (list === undefined)
+            continue;
+        const i = list.indexOf(voice);
+        if (i >= 0)
+            list.splice(i, 1);
+        if (list.length === 0)
+            mix.named.delete(subject);
+    }
+}

package/dist/channels.d.ts

@@ -1,4 +1,6 @@
 import type { Channel, Kit } from './types.js';
+/** The stock numeric channels' `lerp`, which `vec` applies per axis and lanes call directly. */
+export declare const lerpNumber: (a: number, b: number, u: number) => number;
 /**
  * Writes `lerp(a, b, u)` into `out` and returns it, or returns a new array where `out` is absent or
  * the wrong length. The caller must own `out`: nothing else may hold it.

package/dist/channels.js

@@ -1,4 +1,6 @@
-const mix = (a, b, u) => a + (b - a) * u;
+/** The stock numeric channels' `lerp`, which `vec` applies per axis and lanes call directly. */
+export const lerpNumber = (a, b, u) => a + (b - a) * u;
+const mix = lerpNumber;
 const inPlace = new WeakMap();
 /**
  * The in-place form of a stock array channel's `lerp`. Keyed by the channel rather than its `lerp`,

package/dist/clock.d.ts

@@ -2,18 +2,65 @@ import type { Curve } from './easing.js';
 /** How many passes a voice's `loop` plays. */
 export declare function passesOf(loop: boolean | number | undefined): number;
 /**
- * The phase `elapsed` voice ms into a patch of `period` ms playing `passes` passes, held at 1 once
+ * The phase `elapsed` voice ms into a patch of `duration` ms playing `passes` passes, held at 1 once
  * they are done. A pure function rather than one writing phase and pass together, so a hot caller
  * keeps both in registers.
  */
-export declare function phaseAt(elapsed: number, period: number, passes: number): number;
+export declare function phaseAt(elapsed: number, duration: number, passes: number): number;
 /** The pass `elapsed` voice ms falls in, held at the last once they are done. */
-export declare function passAt(elapsed: number, period: number, passes: number): number;
+export declare function passAt(elapsed: number, duration: number, passes: number): number;
 /** A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, and out along its ramp. */
 export declare function envelope(fadeIn: number, out: {
     at: number;
     over: number;
     rest: boolean;
 } | null, ease: Curve | undefined, reduced: boolean, now: number, since: number): number;
+/**
+ * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
+ * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ */
+export declare function heldTime(raw: number, before: boolean, after: boolean, span: number): number;
 /** A weight held to 0..1. */
 export declare function clampWeight(raw: number): number;
+/**
+ * A voice's weight for one subject: its own `base`, times its fade and what the subject's own ramp
+ * out of it leaves (1 without one), held to 0..1 once, after both.
+ */
+export declare function weighed(base: number, fade: number, parting: number): number;
+/**
+ * Whether a voice's `at` goes unasked for a subject at `weight`: nothing it returns would fold. A voice
+ * fading to rest is still asked, since its delta is what says it has arrived.
+ */
+export declare function silent(voice: {
+    readonly out: {
+        readonly rest: boolean;
+    } | null;
+}, weight: number): boolean;
+/** What sets a clock: its rate, and where it was last anchored. */
+export interface Clock {
+    anchorNow: number;
+    anchorElapsed: number;
+    rate: number;
+    ramp: {
+        from: number;
+        to: number;
+        over: number;
+    } | null;
+}
+/**
+ * What a clock reads at `now`: `anchorElapsed` plus its rate integrated from `anchorNow`. Without a
+ * ramp the rate is constant; with one it moves linearly from `from` to `to` over `over` ms from the
+ * anchor, and holds `to` after.
+ */
+export declare function elapsedWith(c: Clock, now: number): number;
+/** The time a clock reads `elapsed`, inverting `elapsedWith`; Infinity where it never will. */
+export declare function timeWith(c: Clock, elapsed: number): number;
+/** A clock's rate at `now`. */
+export declare function rateWith(c: Clock, now: number): number;
+/** Moves a clock's anchor to `now`, carrying what is left of a ramp. */
+export declare function rebaseWith(c: Clock, now: number): void;
+/**
+ * Sets a clock's rate from `now`: at once, or moving there linearly over `over` ms from the rate it
+ * has then, so what it reads stays continuous and so does its speed.
+ */
+export declare function retime(c: Clock, now: number, rate: number, over: number): void;

package/dist/clock.js

@@ -3,23 +3,23 @@ export function passesOf(loop) {
     const l = loop ?? true;
     return l === true ? Number.POSITIVE_INFINITY : l === false ? 1 : l;
 }
-/** Whether `elapsed` voice ms is past the last of `passes` passes of a patch of `period` ms. */
-const over = (elapsed, period, passes) => Number.isFinite(passes) && elapsed >= period * passes;
+/** Whether `elapsed` voice ms is past the last of `passes` passes of a patch of `duration` ms. */
+const over = (elapsed, duration, passes) => Number.isFinite(passes) && elapsed >= duration * passes;
 /**
- * The phase `elapsed` voice ms into a patch of `period` ms playing `passes` passes, held at 1 once
+ * The phase `elapsed` voice ms into a patch of `duration` ms playing `passes` passes, held at 1 once
  * they are done. A pure function rather than one writing phase and pass together, so a hot caller
  * keeps both in registers.
  */
-export function phaseAt(elapsed, period, passes) {
-    if (!(period > 0))
+export function phaseAt(elapsed, duration, passes) {
+    if (!(duration > 0))
         return 0;
-    return over(elapsed, period, passes) ? 1 : (elapsed % period) / period;
+    return over(elapsed, duration, passes) ? 1 : (elapsed % duration) / duration;
 }
 /** The pass `elapsed` voice ms falls in, held at the last once they are done. */
-export function passAt(elapsed, period, passes) {
-    if (!(period > 0))
+export function passAt(elapsed, duration, passes) {
+    if (!(duration > 0))
         return 0;
-    return over(elapsed, period, passes) ? passes - 1 : Math.floor(elapsed / period);
+    return over(elapsed, duration, passes) ? passes - 1 : Math.floor(elapsed / duration);
 }
 /** A voice's own fade this frame, 0..1: in from `since` over `fadeIn`, and out along its ramp. */
 export function envelope(fadeIn, out, ease, reduced, now, since) {
@@ -38,7 +38,100 @@ export function envelope(fadeIn, out, ease, reduced, now, since) {
     }
     return w;
 }
+/**
+ * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
+ * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ */
+export function heldTime(raw, before, after, span) {
+    if (raw < 0)
+        return before ? 0 : Number.NaN;
+    return after && raw > span ? span : raw;
+}
 /** A weight held to 0..1. */
 export function clampWeight(raw) {
     return raw < 0 ? 0 : raw > 1 ? 1 : raw;
 }
+/**
+ * A voice's weight for one subject: its own `base`, times its fade and what the subject's own ramp
+ * out of it leaves (1 without one), held to 0..1 once, after both.
+ */
+export function weighed(base, fade, parting) {
+    return clampWeight(base * (fade * parting));
+}
+/**
+ * Whether a voice's `at` goes unasked for a subject at `weight`: nothing it returns would fold. A voice
+ * fading to rest is still asked, since its delta is what says it has arrived.
+ */
+export function silent(voice, weight) {
+    return !(weight > 0) && voice.out?.rest !== true;
+}
+/**
+ * What a clock reads at `now`: `anchorElapsed` plus its rate integrated from `anchorNow`. Without a
+ * ramp the rate is constant; with one it moves linearly from `from` to `to` over `over` ms from the
+ * anchor, and holds `to` after.
+ */
+export function elapsedWith(c, now) {
+    const dt = now - c.anchorNow;
+    const r = c.ramp;
+    if (r === null)
+        return c.anchorElapsed + dt * c.rate;
+    if (dt <= 0)
+        return c.anchorElapsed + dt * r.from;
+    const d = r.to - r.from;
+    if (dt <= r.over)
+        return c.anchorElapsed + r.from * dt + (d * dt * dt) / (2 * r.over);
+    return c.anchorElapsed + r.from * r.over + (d * r.over) / 2 + r.to * (dt - r.over);
+}
+/** The time a clock reads `elapsed`, inverting `elapsedWith`; Infinity where it never will. */
+export function timeWith(c, elapsed) {
+    const e0 = c.anchorElapsed;
+    const r = c.ramp;
+    if (r === null) {
+        if (c.rate > 0)
+            return c.anchorNow + (elapsed - e0) / c.rate;
+        return elapsed <= e0 ? c.anchorNow : Number.POSITIVE_INFINITY;
+    }
+    if (elapsed <= e0)
+        return r.from > 0 ? c.anchorNow + (elapsed - e0) / r.from : c.anchorNow;
+    const a = (r.to - r.from) / (2 * r.over);
+    const atEnd = e0 + r.from * r.over + a * r.over * r.over;
+    if (elapsed <= atEnd) {
+        const k = e0 - elapsed;
+        const dt = Math.abs(a) < 1e-12
+            ? -k / r.from
+            : (-r.from + Math.sqrt(Math.max(0, r.from * r.from - 4 * a * k))) / (2 * a);
+        return c.anchorNow + dt;
+    }
+    if (r.to <= 0)
+        return Number.POSITIVE_INFINITY;
+    return c.anchorNow + r.over + (elapsed - atEnd) / r.to;
+}
+/** A clock's rate at `now`. */
+export function rateWith(c, now) {
+    const r = c.ramp;
+    if (r === null)
+        return c.rate;
+    const u = (now - c.anchorNow) / r.over;
+    return u >= 1 ? r.to : u <= 0 ? r.from : r.from + (r.to - r.from) * u;
+}
+/** Moves a clock's anchor to `now`, carrying what is left of a ramp. */
+export function rebaseWith(c, now) {
+    const rate = rateWith(c, now);
+    c.anchorElapsed = elapsedWith(c, now);
+    const r = c.ramp;
+    if (r !== null) {
+        const left = c.anchorNow + r.over - now;
+        c.ramp = left > 0 ? { from: rate, to: r.to, over: left } : null;
+    }
+    c.anchorNow = now;
+}
+/**
+ * Sets a clock's rate from `now`: at once, or moving there linearly over `over` ms from the rate it
+ * has then, so what it reads stays continuous and so does its speed.
+ */
+export function retime(c, now, rate, over) {
+    rebaseWith(c, now);
+    const from = rateWith(c, now);
+    c.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
+    c.rate = rate;
+}

package/dist/clone.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `structuredClone(v)`, made directly for what records mostly hold — numbers, strings, and plain
+ * objects and arrays of them two deep — with what `structuredClone` would give; anything else, or
+ * anything it would refuse, goes to it. A read back copies a record per voice and subject.
+ */
+export declare function clone<T>(v: T): T;
+export declare function copy(v: unknown): unknown;

package/dist/clone.js

@@ -0,0 +1,57 @@
+const slow = Symbol('slow');
+/**
+ * `structuredClone(v)`, made directly for what records mostly hold — numbers, strings, and plain
+ * objects and arrays of them two deep — with what `structuredClone` would give; anything else, or
+ * anything it would refuse, goes to it. A read back copies a record per voice and subject.
+ */
+export function clone(v) {
+    const quick = copied(v, 2);
+    met.length = 0;
+    return quick === slow ? structuredClone(v) : quick;
+}
+/** The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. */
+const met = [];
+function copied(v, depth) {
+    if (typeof v === 'symbol' || typeof v === 'function')
+        return slow;
+    if (typeof v !== 'object' || v === null)
+        return v;
+    if (depth === 0 || met.includes(v))
+        return slow;
+    met.push(v);
+    if (Array.isArray(v)) {
+        if (Object.getPrototypeOf(v) !== Array.prototype)
+            return slow;
+        const out = [];
+        for (let i = 0; i < v.length; i++) {
+            if (!(i in v))
+                return slow;
+            const x = copied(v[i], depth - 1);
+            if (x === slow)
+                return slow;
+            out.push(x);
+        }
+        // A property besides the elements, which `structuredClone` keeps.
+        let keys = 0;
+        for (const _ in v)
+            if (++keys > v.length)
+                return slow;
+        return out;
+    }
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null)
+        return slow;
+    const out = {};
+    for (const k in v) {
+        if (k === '__proto__')
+            return slow;
+        const x = copied(v[k], depth - 1);
+        if (x === slow)
+            return slow;
+        out[k] = x;
+    }
+    return out;
+}
+export function copy(v) {
+    return Array.isArray(v) ? [...v] : v;
+}