@msb235/blits 0.7.1 → 0.8.0

package/dist/unpage.d.ts

@@ -4,5 +4,5 @@ import type { Transport } from './transport.js';
  * it took records from the store. Throws before anything moves where it cannot.
  */
 export declare function cover(transport: Transport, t: number): boolean;
-/** A seek back to `t`: what the store and `prepare` hold after it is from a future the tape makes again. */
-export declare function cut(transport: Transport, t: number, unpaged: boolean): void;
+/** A seek back to frame `seq`: what the store and `prepare` hold after it is from a future the tape makes again. */
+export declare function cut(transport: Transport, seq: number, unpaged: boolean): void;

package/dist/unpage.js

@@ -1,3 +1,4 @@
+import { Leavings } from './leavings.js';
 import { unpackHeld } from './pack.js';
 import { HistoryMiss } from './paging.js';
 import { reviveVoice } from './revive.js';
@@ -28,24 +29,25 @@ export function cover(transport, t) {
     transport.floor = loaded.t;
     return true;
 }
-/** A seek back to `t`: what the store and `prepare` hold after it is from a future the tape makes again. */
-export function cut(transport, t, unpaged) {
+/** A seek back to frame `seq`: what the store and `prepare` hold after it is from a future the tape makes again. */
+export function cut(transport, seq, unpaged) {
     const pager = transport.pager;
     if (pager === null)
         return;
     if (unpaged)
-        pager.store.cut(t);
+        pager.store.cut(seq);
     const loaded = pager.loaded;
     if (loaded !== null)
-        loaded.records = loaded.records.filter((r) => r.at <= t);
+        loaded.records = loaded.records.filter((r) => r.seq <= seq);
 }
 /** Puts records a store gave back into memory ahead of what it still holds, as if never paged. */
 function unpage(transport, records) {
+    unpageTransport(transport, records);
     const mixes = new Map();
     for (const m of [...transport.members, ...transport.dropped.map((d) => d.mix)])
         mixes.set(m.name ?? '', m);
     const by = new Map();
-    for (const r of [...records].sort((a, b) => a.at - b.at)) {
+    for (const r of [...records].sort((a, b) => a.seq - b.seq)) {
         const m = mixes.get(r.mix);
         if (m === undefined)
             continue;
@@ -58,6 +60,23 @@ function unpage(transport, records) {
     for (const [m, list] of by)
         unpageMix(m, list);
 }
+/** The transport's own records: its rate changes, the frames it played and the marks announced on it. */
+function unpageTransport(transport, records) {
+    const own = records.filter((r) => r.mix === '' && r.voice === undefined);
+    const paces = own.filter((r) => r.stream === 'pace').map((r) => r.data);
+    if (paces.length > 0)
+        transport.pace?.unshed(paces);
+    const frames = own
+        .filter((r) => r.stream === 'frame')
+        .map((r) => ({ seq: r.seq, at: r.at, u: r.data }));
+    transport.frames = before(frames, transport.frames);
+    const held = new Set(transport.announced.map((a) => a.order));
+    const marks = own
+        .filter((r) => r.stream === 'mark' && !held.has(r.data.order))
+        .map((r) => r.data);
+    if (marks.length > 0)
+        transport.announced = [...marks, ...transport.announced].sort((a, b) => a.order - b.order);
+}
 function unpageMix(mix, records) {
     const voices = new Map();
     for (const v of [...mix.cued, ...mix.gone])
@@ -70,7 +89,7 @@ function unpageMix(mix, records) {
             scoredLeft(mix, v);
         }
     const host = records.filter((r) => r.stream === 'host');
-    mix.hostLog = before(host.map((r) => ({ at: r.at, fields: r.data })), mix.hostLog);
+    mix.hostLog = before(host.map((r) => ({ at: r.at, seq: r.seq, fields: r.data })), mix.hostLog);
     const byVoice = new Map();
     for (const r of records) {
         if (r.voice === undefined)
@@ -92,29 +111,38 @@ function unpageVoice(voice, records, keys) {
     const of = (stream) => records.filter((r) => r.stream === stream);
     if (voice.log !== null)
         voice.log = before(of('controls').map((r) => r.data), voice.log);
-    const left = voice.left ?? [];
-    for (const r of of('left')) {
-        const subject = keys.subject(r.subject);
-        if (!left.some((e) => e.at === r.at && Object.is(e.subject, subject)))
-            left.push({ subject, at: r.at, held: unpackHeld(voice, r.data) });
+    const paged = of('left');
+    if (paged.length > 0) {
+        const left = [...(voice.left?.all() ?? [])];
+        for (const r of paged) {
+            const subject = keys.subject(r.subject);
+            if (left.some((e) => e.seq === r.seq && Object.is(e.subject, subject)))
+                continue;
+            const [p, sync] = r.data;
+            left.push({ subject, at: r.at, seq: r.seq, sync, held: unpackHeld(voice, p) });
+        }
+        left.sort((a, b) => a.seq - b.seq);
+        voice.left = Leavings.from(left);
     }
-    left.sort((a, b) => a.at - b.at);
-    voice.left = left.length === 0 ? null : left;
     for (const [key, list] of bySubject(of('snap'))) {
         const subject = keys.subject(key);
         for (const [held, snaps] of lives(voice, subject, list))
-            held.snaps = before(snaps.map((r) => ({ at: r.at, held: unpackHeld(voice, r.data) })), held.snaps ?? []);
+            held.snaps = before(snaps.map((r) => ({
+                at: r.at,
+                seq: r.seq,
+                held: unpackHeld(voice, r.data),
+            })), held.snaps ?? []);
     }
     for (const [key, list] of bySubject(of('input'))) {
         const subject = keys.subject(key);
         for (const [held, inputs] of lives(voice, subject, list))
-            held.inputs = before(inputs.map((r) => ({ at: r.at, value: r.data })), held.inputs ?? []);
+            held.inputs = before(inputs.map((r) => ({ at: r.at, seq: r.seq, value: r.data })), held.inputs ?? []);
     }
     const motion = voice.motion;
     if (motion === undefined)
         return;
     for (const r of of('released'))
-        motion.reclaim(keys.subject(r.subject), r.at, r.data);
+        motion.reclaim(keys.subject(r.subject), r.at, r.seq, r.data);
     for (const [key, list] of bySubject(of('stretch')))
         motion.restretch(keys.subject(key), list);
 }
@@ -134,29 +162,29 @@ function bySubject(records) {
  * subject leaves the voice, and the record it has now began after its last leaving.
  */
 function lives(voice, subject, records) {
-    const left = (voice.left ?? []).filter((e) => Object.is(e.subject, subject));
+    const left = voice.left?.of(subject) ?? [];
     const out = [];
     let from = Number.NEGATIVE_INFINITY;
     for (const e of left) {
-        out.push([e.held, records.filter((r) => r.at > from && r.at <= e.at)]);
-        from = e.at;
+        out.push([e.held, records.filter((r) => r.seq > from && r.seq <= e.seq)]);
+        from = e.seq;
     }
     const live = voice.subjects.get(subject);
     if (live?.reaches)
-        out.push([live, records.filter((r) => r.at > from)]);
+        out.push([live, records.filter((r) => r.seq > from)]);
     return out;
 }
 /**
- * `loaded`, in time order, ahead of `list`: those older than its first entry, the last of any that
- * share a time, which is the one a read finds.
+ * `loaded`, in the order it was made, ahead of `list`: those older than its first entry, the last
+ * of any that share a frame, which is the one a read finds.
  */
 function before(loaded, list) {
-    const first = list[0]?.at ?? Number.POSITIVE_INFINITY;
+    const first = list[0]?.seq ?? Number.POSITIVE_INFINITY;
     const out = [];
     for (const e of loaded) {
-        if (!(e.at < first))
+        if (!(e.seq < first))
             continue;
-        if (out.length > 0 && out[out.length - 1].at === e.at)
+        if (out.length > 0 && out[out.length - 1].seq === e.seq)
             out[out.length - 1] = e;
         else
             out.push(e);

package/dist/voice.d.ts

@@ -1,13 +1,26 @@
 import type { Blend } from './blend.js';
 import { type Clock } from './clock.js';
 import { type Curve } from './easing.js';
+import type { Leavings } from './leavings.js';
 import type { Motions } from './motions.js';
 import { Named } from './named.js';
+import type { Past } from './origin.js';
 import { Holding } from './owner.js';
 import { type Built, intosOf, type Scratch } from './patch.js';
 import type { Fitting } from './spans.js';
 import { Store } from './store.js';
 import type { Anchor, Channel, FadeSpec, Handle, Patch, Setting, VoiceSpec } from './types.js';
+/**
+ * A subject's record as it left a voice, faded out of it or dropped: the mix time and frame it
+ * left at, and `sync` where the frame's sync made it, before the frame was read.
+ */
+export interface Left<I> {
+    subject: I;
+    at: number;
+    seq: number;
+    sync: boolean;
+    held: Subject<unknown>;
+}
 export declare const none: readonly string[];
 /** Everything one voice holds for one subject, chained through the next voice that reaches it. */
 export interface Subject<S> {
@@ -41,6 +54,8 @@ export interface Subject<S> {
     phase: number;
     /** The voice's `seeks` when `delta` was read, so a seek later in the frame reads it again. */
     seeks: number;
+    /** The voice's `rebuilds` when its state was last made, so a seek's rebuild reaches it once. */
+    rebuilt: number;
     /** Stop 0 for a `from: 'current'` voice, taken the first frame this subject is seen. */
     base?: Record<string, unknown>;
     /** The pose's velocity per channel at that moment, units per ms, so the first segment leaves at it. */
@@ -52,6 +67,7 @@ export interface Subject<S> {
     /** Under `history`, copies of this record by the mix time they were taken, oldest first. */
     snaps?: {
         at: number;
+        seq: number;
         held: Subject<S>;
     }[];
     /** In a projection: where this record started from, and whether nothing known could be. */
@@ -60,6 +76,7 @@ export interface Subject<S> {
     /** Under `history` with `inputs`, what an input weight signal read for this subject, when it changed. */
     inputs?: {
         at: number;
+        seq: number;
         value: number;
     }[];
     /** In a projection reading back: that record, to read in place of the signal. */
@@ -80,10 +97,15 @@ export interface Subject<S> {
     loci: Map<string, Uint8Array> | null;
     /** On the first record: the number lanes index this subject by, -1 without one. */
     slot: number;
+    /** A motion voice's number for this subject in its patch, good while `freed` is the patch's own. */
+    run: number;
+    freed: number;
 }
 /** A voice's clock, weight and fade from one mix time on, kept under `history`. */
 export interface Controls extends Clock {
     at: number;
+    /** The frame it was made in. */
+    seq: number;
     weight: number;
     out: Ramp | null;
     back: Rise | null;
@@ -93,7 +115,10 @@ export interface Controls extends Clock {
     /** A fade the host set for `outAt`: its ramp, NaN for the voice's own `fade.out`. */
     outOver: number;
     outSet: boolean;
-    /** Made by a sync, so it shows in that frame; a host's change between frames shows from the next. */
+    rebuilds: number;
+    /** How many of the voice's past clocks it had then. */
+    past: number;
+    /** Shows in its own frame: made by a sync, or before anything read the mix that frame. */
     sync: boolean;
 }
 export interface Ramp {
@@ -158,26 +183,39 @@ export declare class Voice<I, O> {
     holder: Subject<unknown> | null;
     /** Whether its channels run as lanes this frame, so the general fold passes it by. */
     laned: boolean;
-    /** How many times it has been sought, so a delta read before a seek is not handed out after it. */
+    /**
+     * How many times it has been sought or touched, so a delta read before either is not handed out
+     * after it.
+     */
     seeks: number;
+    /** Whether the host has written to its handle, so it no longer plays as it was cued. */
+    written: boolean;
+    /** How many of `seeks` were the mix's `touch`, which moves no clock. */
+    touches: number;
+    /** How many times its clock has jumped, which a booker counts hits again from. */
+    get jumps(): number;
+    /** Seeks that rebuild state; a record stamped with fewer makes its state again before stepping. */
+    rebuilds: number;
+    /** Whether its span's last fit jumped it to its end, which leaves it no time in that fit. */
+    skipped: boolean;
     /** Whether its patch has kept state on a record through `setting.keep`, which makes it stateful. */
     keeping: boolean;
     /** Subjects fading out of this voice alone, by the ramp each started; null while none are. */
     parts: Map<I, {
         at: number;
         over: number;
+        seq: number;
+    }> | null;
+    /** Subjects faded out of this voice, by the mix time and frame each left at; null while none have. */
+    parted: Map<I, {
+        at: number;
+        seq: number;
     }> | null;
-    /** Subjects faded out of this voice, by the mix time each left at; null while none have. */
-    parted: Map<I, number> | null;
     /**
-     * Under history, the records of subjects that left this voice, by the mix time each left at,
-     * while a seek or a read back may reach them; null while none have.
+     * Under history, the records of subjects that left this voice, by the mix time and frame each
+     * left at, while a seek or a read back may reach them; null while none have.
      */
-    left: {
-        subject: I;
-        at: number;
-        held: Subject<unknown>;
-    }[] | null;
+    left: Leavings<I> | null;
     readonly ease: Curve | undefined;
     /** How many passes its `loop` plays, worked out once. */
     readonly passes: number;
@@ -193,8 +231,13 @@ export declare class Voice<I, O> {
     opened: number;
     /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */
     dueToken: number;
-    /** Records made while it was pending, whose `since` its start may since have moved. */
+    /**
+     * Records whose `since` was still ahead when last worked out, which a later start, rate change
+     * or seek moves; null while none are.
+     */
     early: Subject<unknown>[] | null;
+    /** The clocks it ran on before its current one, where a subject's origin may lie; null for none. */
+    clocks: Past[] | null;
     /** Reused for every call this voice makes, so it is valid only during the call. */
     readonly setting: Setting<unknown>;
     /** Every subject this voice has been asked about, so a handover knows when it is finished. */
@@ -204,8 +247,12 @@ export declare class Voice<I, O> {
     restedCount: number;
     /** The mix time it was cued at; -Infinity before the first sync. */
     cuedAt: number;
-    /** The mix time it left at. */
+    /** The frame it was cued in. */
+    cuedSeq: number;
+    /** The mix time it left at, which a fade or seek given a time already passed puts behind now. */
     doneAt: number;
+    /** The frame its leaving was decided in, which a seek or read back partitions by. */
+    doneSeq: number;
     /** Under `history`, its controls after each change, oldest first. */
     log: Controls[] | null;
     /** Under `history`, its controls as `cue` left them, which a voice parked by a seek takes back. */
@@ -237,6 +284,20 @@ export declare class Voice<I, O> {
     unreached: Subject<unknown> | null;
     /** By subject number, a bit set where `unreached` stands for the subject; null until one is. */
     unreachedBits: Uint32Array | null;
+    /** Whether one record stands for every subject: see `shares` in `everyone.ts`. */
+    sharing: boolean;
+    /** That record, null until a chain first asks and once the voice shares no more. */
+    everyone: Subject<unknown> | null;
+    /** While sharing, by subject number: a bit where a chain has asked about the subject. */
+    sighted: Uint32Array | null;
+    /** While sharing, by subject number: the weight last given the subject on the general path. */
+    weights: Float64Array | null;
+    /**
+     * While sharing a patch that is called, by subject number: when it was last called for the
+     * subject and at what `seeks`, side by side, and the delta that call gave.
+     */
+    stamps: Float64Array | null;
+    deltas: (Record<string, unknown> | null)[] | null;
     /** The handle `cue` returned, which `voices` hands back too. */
     handle: Handle<I> | null;
     /** With a history store, the key of every subject it has a record of; null without one. */
@@ -251,8 +312,10 @@ export declare class Voice<I, O> {
      */
     private finished;
     private playedAs;
-    /** The mix time `played` was settled at, so a seek back to before it can open it again. */
+    /** The mix time `played` was settled at. */
     private playedAt;
+    /** The frame `played` was settled in, so a seek back to before it can open it again. */
+    private playedSeq;
     private donePromise;
     private doneSettle;
     private playedPromise;
@@ -267,21 +330,24 @@ export declare class Voice<I, O> {
      * Its finite loop ended (true) or it left first (false), whichever comes first, noticed at mix
      * time `at`: `played` resolves.
      */
-    play(played: boolean, at: number): void;
-    /** How `played` settled, and the mix time it did; undefined while it has not. */
+    play(played: boolean, at: number, seq: number): void;
+    /** How `played` settled, and the mix time and frame it did; undefined while it has not. */
     get settled(): {
         played: boolean | undefined;
         at: number;
+        seq: number;
     };
     /** Whether `played` settled true, which its owner counted. */
     get passed(): boolean;
     /** Whether `played` settled false: it left before its last pass ended. */
     get unplayed(): boolean;
     /**
-     * A seek back to mix time `t`: `done` and `played`, where they settled after it, start over with
+     * A seek back to frame `seq`: `done` and `played`, where they settled after it, start over with
      * fresh promises. True where `played` had settled true, which its owner counted.
      */
-    reopen(t: number): boolean;
+    reopen(seq: number): boolean;
+    /** Takes on a set of controls: its clock, weight, fades and where its anchors put it. */
+    take(c: Omit<Controls, 'at' | 'seq' | 'sync'>): void;
     /**
      * A seek back to before its cue: out of the mix, as `cue` left it, until the mix plays the cue
      * again. What it played since is forgotten, and `done` and `played` start over where they had
@@ -295,13 +361,15 @@ export declare class Voice<I, O> {
     elapsedAt(now: number): number;
     /** The mix time its clock reads `elapsed`, inverting `elapsedAt`; Infinity where it never will. */
     timeAt(elapsed: number): number;
-    /** Records this voice's controls as they stand, from mix time `at`. */
-    note(at: number, sync?: boolean): void;
+    /** Records this voice's controls as they stand, from mix time `at` in frame `seq`. */
+    note(at: number, seq: number, sync?: boolean): void;
     /**
      * A copy for a projection: its own setting, which sends nothing, and its own per-subject records,
-     * filled from `fill`. With `controls` it takes those, as the voice stood at an earlier time.
+     * filled from `fill`. With `controls` it takes those, as the voice stood at an earlier time. With
+     * `share`, a voice keeping one record for every subject gives its copy a copy of that one, which
+     * a read ahead starts every subject from; `fill` then serves only a copy that shares no more.
      */
-    copy(fill: (subject: I) => Subject<unknown> | undefined, controls?: Controls): Voice<I, O>;
+    copy(fill: (subject: I) => Subject<unknown> | undefined, controls?: Controls, share?: boolean): Voice<I, O>;
     rateAt(now: number): number;
     /** Moves the anchor to `now`, carrying what is left of a ramp. */
     rebase(now: number): void;