@msb235/blits 0.7.1 → 0.8.1

package/dist/origin.d.ts

@@ -0,0 +1,19 @@
+import { type Clock } from './clock.js';
+import type { Voice } from './voice.js';
+/** A clock a voice ran on before its current one, until its local time `until`. */
+export interface Past extends Clock {
+    until: number;
+    /** The voice's `rebuilds` while it ran on this clock. */
+    rebuilds: number;
+}
+/**
+ * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
+ * where a subject's origin could still be found on it.
+ */
+export declare function leave<I, O>(voice: Voice<I, O>, u: number): void;
+/**
+ * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
+ * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
+ * `rebuilt` starts from the last seek that rebuilt state, as a stateful record does.
+ */
+export declare function originOf<I, O>(voice: Voice<I, O>, elapsed: number, rebuilt: boolean): number;

package/dist/origin.js

@@ -0,0 +1,68 @@
+import { elapsedWith, timeWith } from './clock.js';
+/** The most past clocks a voice keeps. */
+const MOST = 256;
+/**
+ * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
+ * where a subject's origin could still be found on it.
+ */
+export function leave(voice, u) {
+    const past = voice.clocks;
+    if (past !== null && past.length >= MOST)
+        return;
+    // A voice with neither stagger nor children is only ever asked when its clock read 0.
+    const reach = voice.holding !== null || voice.spec.stagger !== undefined ? Number.POSITIVE_INFINITY : 0;
+    if (past !== null && reached(past, 0) >= reach && reached(past, fresh(voice)) >= reach)
+        return;
+    const { anchorNow, anchorElapsed, rate, ramp, rebuilds } = voice;
+    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds };
+    if (past === null)
+        voice.clocks = [left];
+    else
+        past.push(left);
+}
+/** The most a voice's past clocks from index `from` read before they were left. */
+function reached(past, from) {
+    let most = Number.NEGATIVE_INFINITY;
+    for (let i = from; i < past.length; i++) {
+        const p = past[i];
+        const e = elapsedWith(p, p.until);
+        if (e > most)
+            most = e;
+    }
+    return most;
+}
+/** Where a walk for a record rebuilt by the voice's last seek starts: its first clock since. */
+function fresh(voice) {
+    const past = voice.clocks;
+    if (past === null)
+        return 0;
+    let i = 0;
+    while (i < past.length && past[i].rebuilds !== voice.rebuilds)
+        i++;
+    return i;
+}
+/**
+ * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
+ * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
+ * `rebuilt` starts from the last seek that rebuilt state, as a stateful record does.
+ */
+export function originOf(voice, elapsed, rebuilt) {
+    const past = voice.clocks;
+    let t = Number.NaN;
+    if (past !== null) {
+        for (let i = rebuilt ? fresh(voice) : 0; i < past.length; i++) {
+            const p = past[i];
+            const at = timeWith(p, elapsed);
+            if (at <= p.until) {
+                t = at;
+                break;
+            }
+        }
+    }
+    if (Number.isNaN(t)) {
+        t = timeWith(voice, elapsed);
+        if (t === Number.POSITIVE_INFINITY)
+            t = voice.start + elapsed;
+    }
+    return voice.owner === null ? t : originOf(voice.owner, t, rebuilt);
+}

package/dist/owed.d.ts

@@ -17,8 +17,8 @@ export declare class Owed {
     owes(slot: number): boolean;
     /** Whether the subject at `slot` owes voice `id` this fill. */
     owesVoice(slot: number, id: number): boolean;
-    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
-    owe(slot: number, met: readonly number[]): void;
-    /** Whether `met` is the last list a subject came to owe this fill. */
-    last(met: readonly number[]): boolean;
+    /** The subject at `slot` owes the first `n` voices of `met`, which the caller may reuse after. */
+    owe(slot: number, met: readonly number[], n: number): void;
+    /** Whether the first `n` of `met` are the last list a subject came to owe this fill. */
+    last(met: readonly number[], n: number): boolean;
 }

package/dist/owed.js

@@ -31,19 +31,19 @@ export class Owed {
     owesVoice(slot, id) {
         return this.lists[this.at[slot]].includes(id);
     }
-    /** The subject at `slot` owes the voices `met`, which the caller may reuse after. */
-    owe(slot, met) {
-        if (!this.last(met))
-            this.lists.push(met.slice());
+    /** The subject at `slot` owes the first `n` voices of `met`, which the caller may reuse after. */
+    owe(slot, met, n) {
+        if (!this.last(met, n))
+            this.lists.push(met.slice(0, n));
         this.fill[slot] = this.now;
         this.at[slot] = this.lists.length - 1;
     }
-    /** Whether `met` is the last list a subject came to owe this fill. */
-    last(met) {
+    /** Whether the first `n` of `met` are the last list a subject came to owe this fill. */
+    last(met, n) {
         const last = this.lists[this.lists.length - 1];
-        if (last === undefined || last.length !== met.length)
+        if (last === undefined || last.length !== n)
             return false;
-        for (let i = 0; i < met.length; i++)
+        for (let i = 0; i < n; i++)
             if (last[i] !== met[i])
                 return false;
         return true;

package/dist/owner.d.ts

@@ -24,7 +24,7 @@ export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): voi
 /** A child left: its owner, where that was its last child and it should leave too. */
 export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
 /** A child finished its passes: its owner has played once every child it held has. */
-export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number): void;
+export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number, seq: number): void;
 /** Every voice an owner holds, its children's children included. */
 export declare function descendants<I, O>(owner: Voice<I, O>, visit: (v: Voice<I, O>) => void): void;
 /** Whether any owner above a voice reads a signal for its weight, which lanes cannot fill. */

package/dist/owner.js

@@ -48,10 +48,10 @@ export function orphan(child) {
     return h.children.length === 0 && owner.state !== 'done' ? owner : null;
 }
 /** A child finished its passes: its owner has played once every child it held has. */
-export function childPlayed(owner, at) {
+export function childPlayed(owner, at, seq) {
     const h = owner.holding;
     if (++h.played === h.kids)
-        owner.play(true, at);
+        owner.play(true, at, seq);
 }
 /** Every voice an owner holds, its children's children included. */
 export function descendants(owner, visit) {

package/dist/pace.d.ts

@@ -1,4 +1,8 @@
 import { type Clock } from './clock.js';
+/** A clock in a pace's log, with the frame that set it, which a history store's cut goes by. */
+export interface Paced extends Clock {
+    seq: number;
+}
 /**
  * A mix's own rate, as a clock: mix time as a function of host time, which here means the host's
  * timestamp less what `rebase` took out. Each entry is the clock from the host time it took effect,
@@ -9,7 +13,7 @@ import { type Clock } from './clock.js';
 export declare class Pace {
     private readonly keeps;
     private log;
-    constructor(keeps: boolean, log?: Clock[]);
+    constructor(keeps: boolean, log?: Paced[]);
     private get clock();
     /** Set before the first sync, the clock waits to be anchored there, reading host time until then. */
     private get waiting();
@@ -30,11 +34,15 @@ export declare class Pace {
     /** Whether the mix clock stands still from host time `u` on, short of another change. */
     stopped(u: number): boolean;
     /**
-     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
-     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
-     * time `reach`.
+     * Sets the rate from host time `u`, in frame `seq`, at once or over `over` host ms, the way a
+     * handle sets a voice's. Under history, lets go of the entries a read no longer reaches: those
+     * over before mix time `reach`.
      */
-    change(u: number, rate: number, over: number, reach: number): void;
+    change(u: number, rate: number, over: number, reach: number, seq: number): void;
+    /** Lets go of the clocks over before mix time `reach`, and answers them. */
+    shed(reach: number): Paced[];
+    /** Puts back clocks a history store kept, ahead of the oldest still held. */
+    unshed(back: readonly Paced[]): void;
     /** Lets go of the clocks set after host time `u`, for a seek back to then. */
     cut(u: number): void;
     /** A copy holding the clocks that took effect before host time `u`, for a read back to then. */

package/dist/pace.js

@@ -9,7 +9,9 @@ import { elapsedWith, rateWith, retime, timeWith } from './clock.js';
 export class Pace {
     keeps;
     log;
-    constructor(keeps, log = [{ anchorNow: 0, anchorElapsed: 0, rate: 1, ramp: null }]) {
+    constructor(keeps, log = [
+        { anchorNow: 0, anchorElapsed: 0, rate: 1, ramp: null, seq: Number.NEGATIVE_INFINITY },
+    ]) {
         this.keeps = keeps;
         this.log = log;
     }
@@ -75,13 +77,13 @@ export class Pace {
         return r.to === 0 && !this.waiting && u >= c.anchorNow + r.over;
     }
     /**
-     * Sets the rate from host time `u`, at once or over `over` host ms, the way a handle sets a
-     * voice's. Under history, lets go of the entries a read no longer reaches: those over before mix
-     * time `reach`.
+     * Sets the rate from host time `u`, in frame `seq`, at once or over `over` host ms, the way a
+     * handle sets a voice's. Under history, lets go of the entries a read no longer reaches: those
+     * over before mix time `reach`.
      */
-    change(u, rate, over, reach) {
+    change(u, rate, over, reach, seq) {
         const was = this.clock;
-        const next = { ...was };
+        const next = { ...was, seq };
         if (Number.isNaN(u) || this.waiting) {
             const from = this.rateAt(Number.NaN);
             next.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
@@ -96,11 +98,22 @@ export class Pace {
             log.push(next);
         else
             log[log.length - 1] = next;
+        this.shed(reach);
+    }
+    /** Lets go of the clocks over before mix time `reach`, and answers them. */
+    shed(reach) {
+        const log = this.log;
         let drop = 0;
         while (drop + 1 < log.length && log[drop + 1].anchorElapsed <= reach)
             drop++;
-        if (drop > 0)
-            log.splice(0, drop);
+        return drop > 0 ? log.splice(0, drop) : [];
+    }
+    /** Puts back clocks a history store kept, ahead of the oldest still held. */
+    unshed(back) {
+        const first = this.log[0].anchorNow;
+        const older = back.filter((c) => c.anchorNow < first).sort((a, b) => a.anchorNow - b.anchorNow);
+        if (older.length > 0)
+            this.log = [...older, ...this.log];
     }
     /** Lets go of the clocks set after host time `u`, for a seek back to then. */
     cut(u) {

package/dist/pack.d.ts

@@ -11,6 +11,7 @@ export interface PackedRecord {
     state: unknown;
     stepped: number;
     ticks: number;
+    rebuilt: number;
     /**
      * What `setting.keep` held, in the order its owners first kept it. An owner is code, which no
      * store keeps, and a voice revived from a descriptor has new ones; the same code keeps in the same
@@ -19,9 +20,10 @@ export interface PackedRecord {
     kept: unknown[] | null;
     base?: Record<string, unknown>;
     slope?: Record<string, unknown>;
-    snaps?: [at: number, held: PackedRecord][];
+    snaps?: [at: number, seq: number, held: PackedRecord][];
     inputs?: {
         at: number;
+        seq: number;
         value: number;
     }[];
 }

package/dist/pack.js

@@ -1,4 +1,5 @@
 import { clone } from './clone.js';
+import { record } from './record.js';
 /** A voice's record of one subject as plain data, its patch's `pack` taking its state. */
 export function packHeld(voice, h) {
     const patch = voice.patch;
@@ -14,6 +15,7 @@ export function packHeld(voice, h) {
         state: h.state === undefined ? undefined : patch.pack ? patch.pack(h.state) : clone(h.state),
         stepped: h.stepped,
         ticks: h.ticks,
+        rebuilt: h.rebuilt,
         kept: kept.length === 0 ? null : kept.map(clone),
     };
     if (h.base !== undefined)
@@ -21,7 +23,7 @@ export function packHeld(voice, h) {
     if (h.slope !== undefined)
         p.slope = clone(h.slope);
     if (h.snaps !== undefined)
-        p.snaps = h.snaps.map((s) => [s.at, packHeld(voice, s.held)]);
+        p.snaps = h.snaps.map((s) => [s.at, s.seq, packHeld(voice, s.held)]);
     if (h.inputs !== undefined)
         p.inputs = h.inputs.map((e) => ({ ...e }));
     return p;
@@ -29,28 +31,17 @@ export function packHeld(voice, h) {
 /** A record made again from `packHeld`'s data, for `voice`. */
 export function unpackHeld(voice, p) {
     const patch = voice.patch;
-    const h = {
-        reaches: p.reaches,
-        delay: p.delay,
-        since: p.since,
-        shown: p.shown,
-        weight: p.weight,
-        rested: p.rested,
-        bands: p.bands === null ? null : Uint8Array.from(p.bands),
-        state: p.state === undefined ? undefined : patch.unpack ? patch.unpack(p.state) : p.state,
-        stepped: p.stepped,
-        ticks: p.ticks,
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
-        kept: null,
-        voice,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+    const bands = p.bands === null ? null : Uint8Array.from(p.bands);
+    const h = record(voice, p.reaches, p.state === undefined ? undefined : patch.unpack ? patch.unpack(p.state) : p.state);
+    h.delay = p.delay;
+    h.since = p.since;
+    h.shown = p.shown;
+    h.weight = p.weight;
+    h.rested = p.rested;
+    h.bands = bands;
+    h.stepped = p.stepped;
+    h.ticks = p.ticks;
+    h.rebuilt = p.rebuilt;
     if (p.kept !== null)
         h.unkept = p.kept;
     if (p.base !== undefined)
@@ -58,7 +49,7 @@ export function unpackHeld(voice, p) {
     if (p.slope !== undefined)
         h.slope = p.slope;
     if (p.snaps !== undefined)
-        h.snaps = p.snaps.map(([at, held]) => ({ at, held: unpackHeld(voice, held) }));
+        h.snaps = p.snaps.map(([at, seq, held]) => ({ at, seq, held: unpackHeld(voice, held) }));
     if (p.inputs !== undefined)
         h.inputs = p.inputs;
     return h;

package/dist/paging.d.ts

@@ -51,13 +51,19 @@ export declare class Keys {
     subject(key: Key): unknown;
 }
 /**
- * Hands records leaving memory to the store, the last of any that share a time, which is the one
- * a read finds. `reach` is how far back memory still reaches.
+ * Hands records leaving memory to the store, the last of any made in one frame, which is the one a
+ * read finds. `reach` is how far back memory still reaches.
  */
 export declare function pageOut<I, O, E extends {
     at: number;
+    seq: number;
 }>(mix: Mixer<I, O>, stream: PagedStream, voice: number | undefined, subject: Key, out: readonly E[], data: (e: E) => unknown, reach: number): void;
 /** Gives records to the store; memory now reaches back no further than `reach`. */
 export declare function page(transport: Transport, records: Paged[], reach: number): void;
+/**
+ * With a store, hands it what the transport itself keeps from before memory's reach: announced
+ * marks, changes of its rate, and frames, the last at or before the reach staying.
+ */
+export declare function pageTransport(transport: Transport): void;
 /** Loads what a seek or read to `t` needs where it reaches past memory. */
 export declare function prepare(transport: Transport, t: number): Promise<void>;

package/dist/paging.js

@@ -68,8 +68,8 @@ export class Keys {
     }
 }
 /**
- * Hands records leaving memory to the store, the last of any that share a time, which is the one
- * a read finds. `reach` is how far back memory still reaches.
+ * Hands records leaving memory to the store, the last of any made in one frame, which is the one a
+ * read finds. `reach` is how far back memory still reaches.
  */
 export function pageOut(mix, stream, voice, subject, out, data, reach) {
     const pager = mix.transport.pager;
@@ -79,9 +79,9 @@ export function pageOut(mix, stream, voice, subject, out, data, reach) {
     const records = [];
     for (let i = 0; i < out.length; i++) {
         const e = out[i];
-        if (i + 1 < out.length && out[i + 1].at === e.at)
+        if (i + 1 < out.length && out[i + 1].seq === e.seq)
             continue;
-        const r = { mix: name, stream, at: e.at, data: data(e) };
+        const r = { mix: name, stream, at: e.at, seq: e.seq, data: data(e) };
         if (voice !== undefined)
             r.voice = voice;
         if (subject !== undefined)
@@ -100,6 +100,41 @@ export function page(transport, records, reach) {
     if (reach > transport.floor)
         transport.floor = reach;
 }
+/**
+ * With a store, hands it what the transport itself keeps from before memory's reach: announced
+ * marks, changes of its rate, and frames, the last at or before the reach staying.
+ */
+export function pageTransport(transport) {
+    const history = transport.history;
+    if (history === undefined || transport.pager === null)
+        return;
+    const reach = transport.now - history.ms;
+    const records = [];
+    transport.frames.shed(reach, (f) => records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u }));
+    const pace = transport.pace;
+    const timeOf = (u) => (pace === null ? u : pace.reading(u));
+    if (transport.announced.some((a) => timeOf(a.at) < reach)) {
+        const kept = [];
+        for (const a of transport.announced)
+            if (timeOf(a.at) < reach)
+                records.push({
+                    mix: '',
+                    stream: 'mark',
+                    subject: a.order,
+                    at: timeOf(a.at),
+                    seq: a.seq,
+                    data: a,
+                });
+            else
+                kept.push(a);
+        transport.announced = kept;
+    }
+    if (pace !== null)
+        for (const c of pace.shed(reach))
+            records.push({ mix: '', stream: 'pace', at: c.anchorElapsed, seq: c.seq, data: c });
+    if (records.length > 0)
+        page(transport, records, reach);
+}
 /** Loads what a seek or read to `t` needs where it reaches past memory. */
 export async function prepare(transport, t) {
     const pager = transport.pager;

package/dist/patch.d.ts

@@ -35,7 +35,7 @@ export interface KeysOptions<O> {
     ease?: Easing;
     /** A curve for one channel, where it differs from the rest. */
     easeBy?: (channel: keyof O) => Easing | undefined;
-    /** Milliseconds one channel waits before it starts moving, within the duration. */
+    /** Milliseconds one channel waits before it starts moving; it then travels in the time left. */
     delayBy?: (channel: keyof O) => number;
     /**
      * How one channel interpolates, where it should differ from the channel's own `lerp`. A mix hands
@@ -45,8 +45,6 @@ export interface KeysOptions<O> {
     /** The channels these stops were written against, which `cue` checks a mix's kit against. */
     kit?: Partial<Kit<O>>;
 }
-/** The options a `keys` patch was built with, for an engine reading its stops rather than calling it. */
-export declare function keysOptionsOf<I, O, S>(p: Patch<I, O, S>): KeysOptions<O> | undefined;
 interface Point {
     at: number;
     value: unknown;
@@ -66,6 +64,12 @@ export interface Track {
     tailAts: number[] | null;
     delay: number;
     lerp: ((a: never, b: never, u: number) => unknown) | undefined;
+    /** Where every stop is a plain number lerped straight across: the stops flat, for `readNumber`. */
+    numbers: {
+        ats: Float64Array;
+        values: Float64Array;
+        eases: (Curve | undefined)[];
+    } | null;
 }
 export interface Built {
     tracks: Track[];
@@ -96,14 +100,14 @@ export declare function shift(delay: number, phase: number, duration: number): n
 /**
  * Where `phase` falls among `n` stop phases `ats[off + k * stride]`, in order: -2 for no stops, -1
  * at or before the first, `n` at or past the last, and otherwise the first stop past it, where the
- * segment from the one before ends. With `segment`'s, the one copy of the search.
+ * segment from the one before ends. `segment` and `readNumber` make the same search.
  */
 export declare function locate(ats: ArrayLike<number>, off: number, stride: number, n: number, phase: number): number;
 /** How far along a segment from phase `a` to `b` a phase is, before easing. */
 export declare function fraction(phase: number, a: number, b: number): number;
 /**
- * Finds where one track is at a phase, into `seg`: the one copy of the search, which `read` and a
- * lane folding stops straight into a subject's values both make. `base` stands in for the value at
+ * Finds where one track is at a phase, into `seg`: the search `read` and a lane folding stops
+ * straight into a subject's values both make. `base` stands in for the value at
  * phase 0, which is how `from: 'current'` starts a voice wherever the subject already is.
  */
 export declare function segment(track: Track, phase: number, base: unknown): number;
@@ -125,9 +129,10 @@ export declare function intosOf(built: Built, channels: readonly Channel<unknown
 export declare function readKeys(built: Built, phase: number, out: Record<string, unknown>, base?: Record<string, unknown>, lerps?: readonly (Lerp | undefined)[], 
 /** Per channel, how fast a retargeted subject was moving, units per ms. */
 slopes?: Record<string, unknown>, intos?: readonly (LerpInto | undefined)[], scratch?: Scratch): Record<string, unknown>;
-/** A patch's `duration`, or the deprecated `period` where only that is set. */
-export declare const durationOf: <I, O, S>(p: Patch<I, O, S>) => number;
-/** The built form of a patch's stops, made on first ask for a patch `keys()` did not build. */
+/**
+ * The built form of a patch's stops, made on first ask for a patch `keys()` did not build: a copy
+ * of one, or one another copy of blits made, each read by the fields it carries.
+ */
 export declare function builtOf<I, O, S>(p: Patch<I, O, S>): Built;
 /** Evaluates a stop list into a fresh delta. */
 export declare function evalKeys<O>(stops: readonly Keyframe<O>[], writes: readonly (keyof O)[], phase: number, duration: number, opts: KeysOptions<O>, base?: Partial<O>): Partial<O>;