@msb235/blits 0.10.0 → 0.12.0

package/dist/record.js

@@ -23,6 +23,7 @@ export function record(voice, reaches, state) {
         phase: 0,
         seeks: 0,
         rebuilt: 0,
+        copied: false,
         base: undefined,
         slope: undefined,
         kept: null,
@@ -39,5 +40,6 @@ export function record(voice, reaches, state) {
         slot: -1,
         run: -1,
         freed: -1,
+        restored: null,
     };
 }

package/dist/restored.d.ts

@@ -2,40 +2,92 @@ import type { Leavings } from './leavings.js';
 import { Store } from './store.js';
 import type { Cut } from './transport.js';
 import type { Subject } from './voice.js';
+/**
+ * The seeks back after the one a record was last put back, written or deleted at, which every
+ * record stamped then shares. The next seek fills it; a later seek to as early a moment joins it
+ * to its own, so the root it reaches holds the earliest moment sought since. Only records and the
+ * stamps joined beneath it hold it, so it is collected with the last record that can read it.
+ */
+/** A moment sought, the end of frame `seq`. */
+export interface Moment {
+    readonly t: number;
+    readonly seq: number;
+}
+export interface Stamp extends Moment {
+    /** On a root: the earliest moment sought since, and the frame that ended. */
+    t: number;
+    seq: number;
+    /** The stamp this one was joined to, null on a root. */
+    up: Stamp | null;
+    /** A bound on how deep the stamps joined beneath it go, so joining the lower keeps paths short. */
+    rank: number;
+    /** The records subjects left with after this seek's moment, and where it cut; null for none. */
+    left: Leavings<unknown> | null;
+    cut: Cut | null;
+    /** The store that made it; null on `gone`. */
+    readonly of: object | null;
+}
 /**
  * A voice's records once a seek has gone back: each subject's is put back from the record it had,
  * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
- * It is one store however many seeks there are: by subject it keeps how many seeks its record has
- * been put back for, and a record behind is put back to the earliest moment sought since, as a
- * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ * It is one store however many seeks there are: by subject it keeps the stamp of the seek its
+ * record was last put back at, and a record behind is put back to the earliest moment sought
+ * since, as a seek back cuts what came after it and a later seek ahead of that moment must not
+ * read past it.
  */
 export declare class Restored<I> extends Store<I, Subject<unknown>> {
     private readonly own;
+    private readonly now;
     private readonly make;
-    /** Seeks back so far. */
-    private n;
-    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    /** What a record put back now is stamped with, filled by the next seek. */
+    private stamp;
+    /** What a record never stamped reads as: the first seek's. */
+    private readonly first;
+    /**
+     * By subject, the stamp its record was last put back, written or deleted at; none reads as
+     * `first`. A record that reaches its subject is its own, and holds it as `restored` instead,
+     * sparing a write here per subject a seek puts back; one that does not may stand for many.
+     */
     private readonly at;
     /**
-     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
-     * moment sought since seek `n` is that of the first here at or after it.
+     * The roots, each moment earlier than the next, held weakly: one no record can reach is never
+     * read again, and those are cleared out once the list doubles.
+     */
+    private roots;
+    private kept;
+    /**
+     * Stamps made a batch ahead of their seeks: one made at its seek is young when every old record
+     * is written with it, and V8 notes each such write for its next scavenge.
      */
-    private readonly least;
-    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
-    private futures;
+    private ready;
+    private aging;
     /** The latest seek's moment. */
-    private t;
+    top: number;
     /**
-     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
-     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     * `own` holds the records as they stood before the first seek, and `now` gives the one a subject
+     * that has not left since and is not reached has there, as a seek to `at` takes it. `make` puts
+     * a record back as it stood at `at`, undefined where it had none then; `mine` says `live` is the
+     * record this store held, which nothing else does.
      */
-    constructor(own: Store<I, Subject<unknown>>, make: (live: Subject<unknown>, t: number, top: number) => Subject<unknown> | undefined);
+    constructor(own: Store<I, Subject<unknown>>, now: (key: I, held: Subject<unknown> | undefined, at: Moment) => Subject<unknown> | undefined, make: (live: Subject<unknown>, at: Moment, mine: boolean) => Subject<unknown> | undefined);
     /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
     back(t: number, cut: Cut, left: Leavings<I> | null): void;
-    /** The earliest moment sought by seek `from` or any after it. */
-    private since;
+    /** The next seek's stamp, from a batch made a batch of seeks ago, twice as many each time to 64. */
+    private fresh;
+    /**
+     * Whether a reaching record stamped by this store is still its record for the key it was found
+     * under: every record let go is stamped `gone`, copies are stamped with nothing, and this turns
+     * false if a stamped record is set again, which could put it under a second key.
+     */
+    private sure;
     get(key: I): Subject<unknown> | undefined;
+    /** A chain's record for a subject, found again without a lookup where this store stamped it. */
+    find(key: I, guess: Subject<unknown>): Subject<unknown> | undefined;
+    /** `get`, given what `own` holds for `key`. */
+    private from;
     set(key: I, value: Subject<unknown>): void;
     delete(key: I): void;
+    /** Lets go of the record held for `key`, stamping it `gone`. */
+    private shed;
     clear(): void;
 }

package/dist/restored.js

@@ -1,90 +1,203 @@
 import { Store } from './store.js';
+const stamp = (of) => ({
+    t: Number.NaN,
+    seq: 0,
+    up: null,
+    rank: 0,
+    left: null,
+    cut: null,
+    of,
+});
+/** What a reaching record a store has let go of is stamped with, so setting it again is seen. */
+const gone = stamp(null);
+/** The root `s` was joined to, halving the path there for the next read. */
+function rootOf(s) {
+    let x = s;
+    let up = x.up;
+    while (up !== null) {
+        const next = up.up;
+        if (next === null)
+            return up;
+        x.up = next;
+        x = next;
+        up = x.up;
+    }
+    return x;
+}
 /**
  * A voice's records once a seek has gone back: each subject's is put back from the record it had,
  * the first time it is asked for after a seek, since the subjects a store holds cannot be listed.
- * It is one store however many seeks there are: by subject it keeps how many seeks its record has
- * been put back for, and a record behind is put back to the earliest moment sought since, as a
- * seek back cuts what came after it and a later seek ahead of that moment must not read past it.
+ * It is one store however many seeks there are: by subject it keeps the stamp of the seek its
+ * record was last put back at, and a record behind is put back to the earliest moment sought
+ * since, as a seek back cuts what came after it and a later seek ahead of that moment must not
+ * read past it.
  */
 export class Restored extends Store {
     own;
+    now;
     make;
-    /** Seeks back so far. */
-    n = 0;
-    /** By subject, the `n` its record was last put back, written or deleted at; none reads as 0. */
+    /** What a record put back now is stamped with, filled by the next seek. */
+    stamp = stamp(this);
+    /** What a record never stamped reads as: the first seek's. */
+    first = this.stamp;
+    /**
+     * By subject, the stamp its record was last put back, written or deleted at; none reads as
+     * `first`. A record that reaches its subject is its own, and holds it as `restored` instead,
+     * sparing a write here per subject a seek puts back; one that does not may stand for many.
+     */
     at = new Store();
     /**
-     * Each seek back sought to an earlier moment than every one after it, oldest first: the earliest
-     * moment sought since seek `n` is that of the first here at or after it.
+     * The roots, each moment earlier than the next, held weakly: one no record can reach is never
+     * read again, and those are cleared out once the list doubles.
+     */
+    roots = [];
+    kept = 0;
+    /**
+     * Stamps made a batch ahead of their seeks: one made at its seek is young when every old record
+     * is written with it, and V8 notes each such write for its next scavenge.
      */
-    least = [];
-    /** By seek, the records subjects left with after its moment, and where it cut; null until one has any. */
-    futures = null;
+    ready = [];
+    aging = [];
     /** The latest seek's moment. */
-    t = Number.NaN;
+    top = Number.NaN;
     /**
-     * `own` holds the records as they stood before the first seek. `make` puts a record back as it
-     * stood at `t`, undefined where it had none then; `top` is the latest seek's moment.
+     * `own` holds the records as they stood before the first seek, and `now` gives the one a subject
+     * that has not left since and is not reached has there, as a seek to `at` takes it. `make` puts
+     * a record back as it stood at `at`, undefined where it had none then; `mine` says `live` is the
+     * record this store held, which nothing else does.
      */
-    constructor(own, make) {
+    constructor(own, now, make) {
         super();
         this.own = own;
+        this.now = now;
         this.make = make;
     }
     /** A seek back to `t`: `left` has the records subjects left with after `cut`, null for none. */
     back(t, cut, left) {
-        const n = ++this.n;
-        const least = this.least;
-        while (least.length > 0 && least[least.length - 1].t >= t)
-            least.pop();
-        least.push({ n, t });
-        this.t = t;
+        const s = this.stamp;
         if (left !== null) {
-            this.futures ??= new Map();
-            this.futures.set(n, { left, cut });
+            s.left = left;
+            s.cut = cut;
+        }
+        // Every root at or after `t` now reads `t`, so they and `s` are joined under one.
+        const roots = this.roots;
+        let root = s;
+        let ref = null;
+        while (roots.length > 0) {
+            const r = roots[roots.length - 1].deref();
+            if (r !== undefined && r.t < t)
+                break;
+            const w = roots.pop();
+            if (r === undefined)
+                continue;
+            if (r.rank > root.rank) {
+                root.up = r;
+                root = r;
+                ref = w;
+            }
+            else {
+                r.up = root;
+                if (r.rank === root.rank)
+                    root.rank++;
+            }
+        }
+        root.t = t;
+        root.seq = cut.seq;
+        roots.push(ref ?? new WeakRef(root));
+        if (roots.length > 2 * this.kept + 16) {
+            this.roots = roots.filter((w) => w.deref() !== undefined);
+            this.kept = this.roots.length;
         }
+        this.stamp = this.fresh();
+        this.top = t;
     }
-    /** The earliest moment sought by seek `from` or any after it. */
-    since(from) {
-        const least = this.least;
-        let lo = 0;
-        let hi = least.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (least[mid].n >= from)
-                hi = mid;
-            else
-                lo = mid + 1;
+    /** The next seek's stamp, from a batch made a batch of seeks ago, twice as many each time to 64. */
+    fresh() {
+        if (this.ready.length === 0) {
+            const n = Math.min(64, Math.max(1, this.aging.length * 2));
+            this.ready = this.aging.reverse();
+            this.aging = [];
+            for (let i = 0; i < n; i++)
+                this.aging.push(stamp(this));
         }
-        return least[lo].t;
+        return this.ready.pop() ?? stamp(this);
     }
+    /**
+     * Whether a reaching record stamped by this store is still its record for the key it was found
+     * under: every record let go is stamped `gone`, copies are stamped with nothing, and this turns
+     * false if a stamped record is set again, which could put it under a second key.
+     */
+    sure = true;
     get(key) {
-        const at = this.at.get(key) ?? 0;
-        if (at === this.n)
-            return this.own.get(key);
-        this.at.set(key, this.n);
+        return this.from(key, this.own.get(key));
+    }
+    /** A chain's record for a subject, found again without a lookup where this store stamped it. */
+    find(key, guess) {
+        const s = guess.restored;
+        return s !== null && s.of === this && this.sure ? this.from(key, guess) : this.get(key);
+    }
+    /** `get`, given what `own` holds for `key`. */
+    from(key, own) {
+        const mark = own !== undefined && own.reaches;
+        const at = (mark ? own.restored : this.at.get(key)) ?? this.first;
+        const now = this.stamp;
+        if (at === now)
+            return own;
+        if (mark)
+            own.restored = now;
+        else
+            this.at.set(key, now);
         // A subject that left after the moment the next seek sought had the record it left with,
         // whatever it has now. Leaving is a write, so no later seek's leavings can hold it.
-        const future = this.futures?.get(at + 1);
-        const live = future?.left.at(key, future.cut) ?? this.own.get(key);
-        if (live === undefined)
-            return undefined;
-        const made = this.make(live, this.since(at + 1), this.t);
-        if (made === undefined)
-            this.own.delete(key);
-        else
-            this.own.set(key, made);
+        const root = rootOf(at);
+        const left = at.left?.at(key, at.cut);
+        const live = left ?? this.now(key, own, root);
+        const made = live && this.make(live, root, left === undefined);
+        // Looked up again, not taken from `own`: a call made while it was put back may have set it.
+        if (made === undefined) {
+            this.shed(key);
+            if (mark)
+                this.at.set(key, now);
+        }
+        else if (made !== own)
+            this.set(key, made);
+        else if (!made.reaches)
+            this.at.set(key, now);
         return made;
     }
     set(key, value) {
+        const old = this.own.get(key);
+        if (old === value) {
+            if (value.reaches)
+                value.restored = this.stamp;
+            else
+                this.at.set(key, this.stamp);
+            return;
+        }
+        if (old?.reaches)
+            old.restored = gone;
+        // Stamped already, it may be in a chain under another key.
+        if (value.reaches && value.restored !== null)
+            this.sure = false;
         this.own.set(key, value);
-        this.at.set(key, this.n);
+        if (value.reaches)
+            value.restored = this.stamp;
+        else
+            this.at.set(key, this.stamp);
     }
     delete(key) {
+        this.shed(key);
+        this.at.set(key, this.stamp);
+    }
+    /** Lets go of the record held for `key`, stamping it `gone`. */
+    shed(key) {
+        const old = this.own.get(key);
+        if (old?.reaches)
+            old.restored = gone;
         this.own.delete(key);
-        this.at.set(key, this.n);
     }
     clear() {
+        this.sure = false;
         this.own.clear();
         this.at.clear();
     }

package/dist/revive.d.ts

@@ -4,7 +4,7 @@ import type { Past } from './origin.js';
 import { type PackedRecord } from './pack.js';
 import { type Key } from './paging.js';
 import type { Described } from './types.js';
-import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, type Parted, type Parting, type Ramp, type Rise, Voice } from './voice.js';
 /** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
 interface PackedVoice {
     as: Described;
@@ -24,6 +24,7 @@ interface PackedVoice {
     outOver: number;
     outSet: boolean;
     rebuilds: number;
+    hold: number;
     past: number;
     clocks: Past[] | null;
     cuedAt: number;
@@ -43,9 +44,11 @@ interface PackedVoice {
     playedSeq: number;
     records: [Key, PackedRecord][];
     runs: [Key, Run][];
-    left: [Key, number, number, PackedRecord, boolean][];
+    /** The fades are absent from a store written before a leaving kept them. */
+    left: [Key, number, number, PackedRecord, boolean, (Parting | null)?, (Parted | null)?][];
     parts: [Key, number, number, number][];
-    parted: [Key, number, number][];
+    /** With the ramp that took the subject out; absent from a store written before a voice kept it. */
+    parted: [Key, number, number, Parting?][];
 }
 /**
  * Voices a history store holds whose handles something still holds, by id: a seek that revives

package/dist/revive.js

@@ -83,6 +83,7 @@ function packVoice(voice, keys) {
         outOver: voice.outOver,
         outSet: voice.outSet,
         rebuilds: voice.rebuilds,
+        hold: voice.hold,
         past: voice.clocks?.length ?? 0,
         clocks: voice.clocks,
         cuedAt: voice.cuedAt,
@@ -107,9 +108,11 @@ function packVoice(voice, keys) {
             e.seq,
             packHeld(voice, e.held),
             e.sync,
+            e.ramp,
+            e.parted,
         ]),
         parts: [...(voice.parts ?? [])].map(([s, r]) => [keys.key(s), r.at, r.over, r.seq]),
-        parted: [...(voice.parted ?? [])].map(([s, p]) => [keys.key(s), p.at, p.seq]),
+        parted: [...(voice.parted ?? [])].map(([s, p]) => p.ramp === undefined ? [keys.key(s), p.at, p.seq] : [keys.key(s), p.at, p.seq, p.ramp]),
     };
 }
 /** A voice a history store paged out, rebuilt from its descriptor and put back as it left. */
@@ -146,17 +149,22 @@ export function reviveVoice(mix, id, d) {
     }
     for (const [key, run] of d.runs)
         voice.motion?.unpack(subjectOf(key), run);
-    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync]) => ({
+    voice.left = Leavings.from(d.left.map(([key, at, seq, p, sync, ramp = null, parted = null]) => ({
         subject: subjectOf(key),
         at,
         seq,
         sync,
         held: unpackHeld(voice, p),
+        ramp,
+        parted,
     })));
     if (d.parts.length > 0)
         voice.parts = new Map(d.parts.map(([key, at, over, seq]) => [subjectOf(key), { at, over, seq }]));
     if (d.parted.length > 0)
-        voice.parted = new Map(d.parted.map(([key, at, seq]) => [subjectOf(key), { at, seq }]));
+        voice.parted = new Map(d.parted.map(([key, at, seq, ramp]) => [
+            subjectOf(key),
+            { at, seq, ramp: ramp ?? undefined },
+        ]));
     const h = mix.outs?.take(id);
     if (h === undefined)
         voice.handle = handle(mix, voice);

package/dist/roster.js

@@ -4,7 +4,8 @@ import { Store } from './store.js';
 function tally(mix, voice, by) {
     if (voice.spec.locus !== undefined)
         mix.loci += by;
-    if (voice.spec.anchor !== undefined)
+    const e = voice.spec.earliest;
+    if (voice.spec.anchor !== undefined || (e !== undefined && typeof e !== 'number'))
         mix.anchored += by;
 }
 /** Counts a voice just put in the list into everything a sync and a fold skip work by. */

package/dist/rows.js

@@ -16,8 +16,11 @@ function same(a, b) {
 /** Takes a crowd row off its subject, to be placed again if a probe meets it again. */
 export function unplace(lanes, c, p) {
     const slot = c.list[p];
-    if (c.idle && slot >= 0)
-        reach(lanes, slot, -1);
+    if (slot >= 0) {
+        if (c.idle)
+            reach(lanes, slot, -1);
+        lanes.placed.remove(slot, c.voices[p].id);
+    }
     c.list[p] = -1;
     c.records[p] = undefined;
     c.deltas[p] = null;
@@ -167,15 +170,20 @@ export function bury(lanes, c, p) {
     lanes.crowdOf.delete(v.id);
     c.dead++;
 }
+/** Copies `n` numbers of a row; a view of them to hand `set` was three objects a row moved. */
+function carry(from, a, to, b, n) {
+    for (let i = 0; i < n; i++)
+        to[b + i] = from[a + i];
+}
 function copyRow(from, p, to, q, keys = from.keys) {
     from.fix(p);
     to.list[q] = from.list[p];
-    to.data.set(from.data.subarray(p * 8 /* Row.STRIDE */, (p + 1) * 8 /* Row.STRIDE */), q * 8 /* Row.STRIDE */);
-    to.hot.set(from.hot.subarray(p * from.stride, (p + 1) * from.stride), q * to.stride);
+    carry(from.data, p * 8 /* Row.STRIDE */, to.data, q * 8 /* Row.STRIDE */, 8 /* Row.STRIDE */);
+    carry(from.hot, p * from.stride, to.hot, q * to.stride, from.stride);
     copyKeys(keys, to, q);
     if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0)
         to.stale = true;
-    to.samples.set(from.samples.subarray(p * from.axes, (p + 1) * from.axes), q * to.axes);
+    carry(from.samples, p * from.axes, to.samples, q * to.axes, from.axes);
     to.deltas[q] = from.deltas[p] ?? null;
     to.records[q] = from.records[p];
     to.voices[q] = from.voices[p];
@@ -257,6 +265,8 @@ function leaveCrowd(lanes, c, p) {
     const slot = c.list[p];
     const rec = c.records[p];
     if (slot >= 0) {
+        // Its row is emptied or left behind with its crowd, so the subject has it placed no longer.
+        lanes.placed.remove(slot, c.voices[p].id);
         if (c.idle)
             reach(lanes, slot, -1);
         const w = reportedRow(lanes, c, p, slot);

package/dist/seek.d.ts

@@ -1,3 +1,8 @@
 import type { Transport } from './transport.js';
-/** Moves every mix on the transport to mix time `t`, as it stood at the end of that frame. */
-export declare function seek(transport: Transport, t: number): void;
+/**
+ * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
+ * the end of the frame numbered `to.frame`.
+ */
+export declare function seek(transport: Transport, to: number | {
+    readonly frame: number;
+}): void;