@msb235/blits 0.7.0 → 0.8.0

package/dist/scored.js

@@ -0,0 +1,196 @@
+/**
+ * A mix's voices by the score they were cued on, for an anchor that asks for a score's marks: the
+ * cued ones as a set, the gone ones in the order they left, which an anchor reads once each. Built
+ * over the lists it saw: a seek or a copy that replaces either rebuilds that half on the next read.
+ * A score whose gone voices history lets go of gets a fresh list, so a read of the old one starts
+ * over.
+ */
+export class ScoreIndex {
+    cued = null;
+    by = new Map();
+    gone = null;
+    goneBy = new Map();
+    /** Bumped for a score each time a voice on it is cued, retimed, retired or leaves. */
+    versions = new Map();
+    /** The scores whose list on the transport names this mix. */
+    held = new Set();
+}
+function hold(mix, score) {
+    const held = mix.scored.held;
+    // A dropped mix is off the transport's lists until a seek puts it back, and `scoredJoin` then.
+    if (held.has(score) || mix.dropped)
+        return;
+    held.add(score);
+    const by = mix.transport.holders;
+    const m = mix;
+    const list = by.get(score);
+    if (list === undefined) {
+        by.set(score, [m]);
+        return;
+    }
+    const i = list.findIndex((o) => o.slot > m.slot);
+    if (i < 0)
+        list.push(m);
+    else
+        list.splice(i, 0, m);
+}
+/** The mixes on `mix`'s transport that may hold a voice on `score`; the list is the transport's own. */
+export function holders(mix, score) {
+    return (mix.transport.holders.get(score) ?? none);
+}
+/** Takes `mix` off `score`'s list, having found it holds nothing there. */
+export function unhold(mix, score) {
+    mix.scored.held.delete(score);
+    const by = mix.transport.holders;
+    const list = by.get(score);
+    if (list === undefined)
+        return;
+    const i = list.indexOf(mix);
+    if (i >= 0)
+        list.splice(i, 1);
+    if (list.length === 0)
+        by.delete(score);
+}
+/** A mix joining its transport, with whatever voices it already has. */
+export function scoredJoin(mix) {
+    for (const v of mix.cued)
+        if (v.spec.score !== undefined)
+            hold(mix, v.spec.score);
+    for (const v of mix.gone)
+        if (v.spec.score !== undefined)
+            hold(mix, v.spec.score);
+}
+/** A mix leaving its transport. */
+export function scoredDrop(mix) {
+    for (const score of [...mix.scored.held])
+        unhold(mix, score);
+}
+/**
+ * A voice on its score was cued, retimed, retired or left: what was read of the score is stale. A
+ * host can still retime a gone voice through a handle it kept, so `retimed` on a done voice
+ * replaces its score's gone list too, which starts every read of it over.
+ */
+export function scoreTouched(mix, voice, retimed = false) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const ix = mix.scored;
+    ix.versions.set(score, (ix.versions.get(score) ?? 0) + 1);
+    if (!retimed || voice.state !== 'done')
+        return;
+    const gone = ix.goneBy.get(score);
+    if (gone !== undefined)
+        ix.goneBy.set(score, [...gone]);
+}
+/** How many times `score` has been touched in `mix`. */
+export function scoreVersion(mix, score) {
+    return mix.scored.versions.get(score) ?? 0;
+}
+function put(by, voice) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const set = by.get(score);
+    if (set === undefined)
+        by.set(score, new Set([voice]));
+    else
+        set.add(voice);
+}
+/** The voices of `mix` cued on `score` and not yet gone, in no order. */
+export function scored(mix, score) {
+    const ix = mix.scored;
+    if (ix.cued !== mix.cued) {
+        ix.by = new Map();
+        for (const v of mix.cued)
+            put(ix.by, v);
+        ix.cued = mix.cued;
+    }
+    return ix.by.get(score) ?? noVoices;
+}
+const noVoices = new Set();
+/** The voices of `mix` cued on `score` that have gone, in the order they left. */
+export function scoredGone(mix, score) {
+    const ix = mix.scored;
+    if (ix.gone !== mix.gone) {
+        ix.goneBy = new Map();
+        for (const v of mix.gone)
+            goneAdd(ix.goneBy, v);
+        ix.gone = mix.gone;
+    }
+    return ix.goneBy.get(score) ?? none;
+}
+const none = [];
+function goneAdd(by, voice) {
+    const score = voice.spec.score;
+    if (score === undefined)
+        return;
+    const list = by.get(score);
+    if (list === undefined)
+        by.set(score, [voice]);
+    else
+        list.push(voice);
+}
+/** A voice just pushed onto `gone`. */
+export function scoredLeft(mix, voice) {
+    if (voice.spec.score !== undefined)
+        hold(mix, voice.spec.score);
+    const ix = mix.scored;
+    if (ix.gone === mix.gone)
+        goneAdd(ix.goneBy, voice);
+}
+/**
+ * Gone voices history let go of, out of `was`; `mix.gone` is already what is left, whether that
+ * is `was` cut in place or a new list.
+ */
+export function scoredCut(mix, was, out) {
+    const ix = mix.scored;
+    if (ix.gone !== was)
+        return;
+    ix.gone = mix.gone;
+    const by = new Map();
+    for (const v of out) {
+        const score = v.spec.score;
+        if (score === undefined)
+            continue;
+        const set = by.get(score);
+        if (set === undefined)
+            by.set(score, new Set([v]));
+        else
+            set.add(v);
+    }
+    for (const [score, gone] of by) {
+        const left = (ix.goneBy.get(score) ?? []).filter((v) => !gone.has(v));
+        if (left.length === 0)
+            ix.goneBy.delete(score);
+        else
+            ix.goneBy.set(score, left);
+    }
+}
+/** A voice just cued. */
+export function scoredAdd(mix, voice) {
+    scoreTouched(mix, voice);
+    if (voice.spec.score !== undefined)
+        hold(mix, voice.spec.score);
+    const ix = mix.scored;
+    if (ix.cued === mix.cued)
+        put(ix.by, voice);
+}
+/** Voices no longer cued. */
+export function scoredRemove(mix, voices) {
+    for (const v of voices)
+        scoreTouched(mix, v);
+    const ix = mix.scored;
+    if (ix.cued !== mix.cued)
+        return;
+    for (const v of voices) {
+        const score = v.spec.score;
+        if (score === undefined)
+            continue;
+        const set = ix.by.get(score);
+        if (set === undefined)
+            continue;
+        set.delete(v);
+        if (set.size === 0)
+            ix.by.delete(score);
+    }
+}

package/dist/seek.js

@@ -1,10 +1,14 @@
-import { index } from './chain.js';
 import { schedule } from './due.js';
-import { copyHeld, last, leftAt } from './history.js';
+import { copyHeld, last, lastWithin } from './history.js';
 import { laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
-import { move } from './move.js';
+import { Leavings } from './leavings.js';
+import { move, nextFrame } from './move.js';
 import { ownerReading } from './owner.js';
+import { place } from './place.js';
+import { unpull } from './pull.js';
+import { Restored } from './restored.js';
+import { recount } from './roster.js';
 import { refitAll } from './spans.js';
 import { Store } from './store.js';
 import { hostAt, replay } from './tape.js';
@@ -35,44 +39,6 @@ function restore(voice, live, t) {
     h.inputs = inputs;
     return h;
 }
-/**
- * A voice's records after a seek back: each subject's is put back from the records it had, the first
- * time it is asked for, since the subjects a store holds cannot be listed.
- */
-class Restored extends Store {
-    was;
-    make;
-    left;
-    constructor(was, make, left) {
-        super();
-        this.was = was;
-        this.make = make;
-        this.left = left;
-    }
-    /** Subjects whose record has been put back or deleted, which `left` no longer answers for. */
-    settled = new Store();
-    get(key) {
-        const v = super.get(key);
-        if (v !== undefined)
-            return v;
-        // A subject that left after the moment sought had the record it left with, whatever it has now.
-        const kept = this.settled.get(key) === undefined ? this.left(key) : undefined;
-        this.settled.set(key, true);
-        const live = kept ?? this.was.get(key);
-        if (live === undefined)
-            return undefined;
-        this.was.delete(key);
-        const made = this.make(live);
-        if (made !== undefined)
-            super.set(key, made);
-        return made;
-    }
-    delete(key) {
-        super.delete(key);
-        this.was.delete(key);
-        this.settled.set(key, true);
-    }
-}
 /** Takes a voice cued after the moment sought out of the mix, until the tape cues it again. */
 function park(mix, voice) {
     const owner = voice.owner;
@@ -86,34 +52,27 @@ function park(mix, voice) {
         motion.owner = null;
     voice.park();
 }
-/** Puts a voice's controls and records back as they stood at mix time `t`. */
-function restoreVoice(voice, t) {
+/** Puts a voice's controls and records back as they stood at mix time `t`, the end of frame `seq`. */
+function restoreVoice(mix, voice, t, seq) {
+    const cut = { seq, strict: false };
     const log = voice.log;
-    const c = last(log, t, true) ?? log[0];
+    const c = lastWithin(log, cut) ?? log[0];
     log.length = log.indexOf(c) + 1;
-    voice.anchorNow = c.anchorNow;
-    voice.anchorElapsed = c.anchorElapsed;
-    voice.rate = c.rate;
-    voice.ramp = c.ramp;
-    voice.weight = c.weight;
-    voice.out = c.out;
-    voice.start = c.start;
-    voice.outAt = c.outAt;
-    voice.outOver = c.outOver;
-    voice.outSet = c.outSet;
-    if (voice.reopen(t) && voice.owner?.holding)
+    voice.take(c);
+    if (voice.reopen(seq) && voice.owner?.holding)
         voice.owner.holding.played--;
     voice.doneAt = Number.POSITIVE_INFINITY;
+    voice.doneSeq = Number.POSITIVE_INFINITY;
     if (voice.parts !== null) {
         for (const [subject, r] of voice.parts)
-            if (r.at > t)
+            if (r.seq > seq)
                 voice.parts.delete(subject);
         if (voice.parts.size === 0)
             voice.parts = null;
     }
     if (voice.parted !== null) {
-        for (const [subject, at] of voice.parted)
-            if (at > t)
+        for (const [subject, p] of voice.parted)
+            if (p.seq > seq)
                 voice.parted.delete(subject);
         if (voice.parted.size === 0)
             voice.parted = null;
@@ -127,30 +86,43 @@ function restoreVoice(voice, t) {
     voice.unreached = null;
     voice.unreachedBits = null;
     voice.seeks++;
-    const left = voice.left;
-    voice.left = left === null ? null : left.filter((e) => e.at <= t);
-    const future = left === null ? [] : left.filter((e) => e.at > t);
-    voice.subjects = new Restored(voice.subjects, (live) => {
-        const h = restore(voice, live, t);
-        if (h === undefined)
+    const left = voice.left?.all() ?? [];
+    voice.left = Leavings.from(left.filter((e) => e.seq <= seq));
+    const future = Leavings.from(left.filter((e) => e.seq > seq));
+    let records = voice.subjects;
+    if (!(records instanceof Restored)) {
+        records = new Restored(records, (live, least, top) => {
+            const h = restore(voice, live, least);
+            if (h === undefined)
+                return h;
+            if (h.reaches)
+                voice.seen++;
+            if (h.rested)
+                voice.restedCount++;
+            if (!(h.since <= least)) {
+                // Kept while its origin was still ahead: where the controls put back place it now.
+                h.since = mix.sinceOf(voice, h.delay);
+                h.shown = mix.shownOf(voice, h.since);
+                if (h.ticks === 0 && h.stepped > h.since)
+                    h.stepped = h.since;
+            }
+            if (!(h.since <= top)) {
+                voice.early ??= [];
+                voice.early.push(h);
+            }
             return h;
-        if (h.reaches)
-            voice.seen++;
-        if (h.rested)
-            voice.restedCount++;
-        if (voice.state === 'pending') {
-            voice.early ??= [];
-            voice.early.push(h);
-        }
-        return h;
-    }, (key) => leftAt(future, key, t));
+        });
+        voice.subjects = records;
+    }
+    records.back(t, cut, future);
 }
 /** Each voice's state at mix time `t`, once every clock above it is back where it was. */
 function stateAt(voice, t) {
+    // A fade begins at once, even one whose ramp starts later, at the voice's start.
+    if (voice.out !== null)
+        return 'fading';
     if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
         return 'pending';
-    if (voice.out !== null && voice.out.at <= t)
-        return 'fading';
     if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
         return 'frozen';
     return 'live';
@@ -172,34 +144,43 @@ export function seek(transport, t) {
     if (!(t >= transport.born))
         throw new Error(`blits: ${t} is older than this mix's history reaches`);
     const unpaged = cover(transport, t);
-    if (t >= transport.now)
-        replay(transport, () => t);
-    // Under the rate the recorded calls up to `t` set, ahead; behind, under the rate it had then.
-    const u = hostAt(transport, t);
-    if (!Number.isFinite(u))
-        throw new RangeError(`blits: the mix's rate never reaches ${t}`);
     if (t >= transport.now) {
+        // Ahead, under the rate the recorded calls up to `t` set, past any frames rate 0 held at `t`.
+        const last = replay(transport, (at) => (transport.pace === null ? at : transport.pace.reading(at)) <= t);
+        const u = Number.isNaN(last) ? hostAt(transport, t) : Math.max(last, hostAt(transport, t));
+        if (!Number.isFinite(u))
+            throw new RangeError(`blits: the mix's rate never reaches ${t}`);
         transport.u = u;
         for (const m of transport.members)
             move(m, t);
     }
     else {
-        const n = tape.depthAt(t);
-        if (n < tape.undoDepth())
-            tape.goto(n);
-        transport.undrop(t);
-        // What history kept after `t` is let go; the tape holds the calls that made it.
-        transport.announced = transport.announced.filter((a) => a.made <= t);
-        transport.pace?.cut(u);
+        const frame = transport.frameAt(t);
+        if (frame === undefined)
+            throw new Error(`blits: ${t} is older than this mix's history reaches`);
+        // On the frame itself, its own host time: rate 0 may have held the clock there for several.
+        const u = frame.at === t ? frame.u : hostAt(transport, t);
+        const seq = frame.seq;
+        tape.goto(tape.depthAt(u));
+        transport.undrop(seq);
+        // What history kept after the frame is let go; the tape holds the calls that made it.
+        transport.announced = transport.announced.filter((a) => a.seq <= seq);
+        transport.frames = transport.frames.filter((f) => f.seq <= seq);
+        if (transport.pacedSeq > seq) {
+            transport.pace = null;
+            transport.pacedSeq = Number.POSITIVE_INFINITY;
+        }
+        else
+            transport.pace?.cut(u);
         transport.u = u;
         transport.now = t;
         for (const m of transport.members)
-            back(m, t);
-        cut(transport, t, unpaged);
+            back(m, t, seq, frame.at < t);
+        cut(transport, seq, unpaged);
     }
+    transport.tick(t);
     // The host's clock reads on from here: its next sync reads `t` plus its time since its last.
-    transport.offset = transport.last - u;
-    transport.u = u;
+    transport.offset = transport.last - transport.u;
     transport.kept();
     for (const m of transport.members) {
         m.stir();
@@ -209,8 +190,11 @@ export function seek(transport, t) {
                 b.sought();
     }
 }
-/** Puts one mix back as it stood at the end of frame `t`, its transport already there. */
-function back(mix, t) {
+/**
+ * Puts one mix back as it stood at mix time `t`, the end of frame `seq`, its transport already
+ * there; `on` past that frame's own time, where it moves on to `t`.
+ */
+function back(mix, t, seq, on) {
     const all = [...mix.cued, ...mix.gone].sort((a, b) => a.id - b.id);
     const kept = [];
     const gone = [];
@@ -220,14 +204,14 @@ function back(mix, t) {
         if (voice.motion !== undefined)
             motions.add(voice.motion);
     for (const voice of all)
-        if (voice.cuedAt > t)
+        if (voice.cuedSeq > seq)
             park(mix, voice);
-        else if (voice.doneAt <= t)
+        else if (voice.doneSeq <= seq)
             gone.push(voice);
         else
             kept.push(voice);
     for (const voice of kept)
-        restoreVoice(voice, t);
+        restoreVoice(mix, voice, t, seq);
     for (const voice of kept)
         voice.state = stateAt(voice, t);
     mix.cued = kept;
@@ -242,28 +226,17 @@ function back(mix, t) {
     if (oldLanes !== null)
         mix.lanes = new Lanes(laneHost(mix));
     mix.chains = new Store();
-    mix.named = new Store();
-    mix.naming = 0;
-    mix.general = [];
-    for (const voice of kept)
-        index(mix, voice);
     mix.owners = kept.some((v) => v.holding !== null) ? kept.filter((v) => v.holding !== null) : null;
-    mix.loci = kept.filter((v) => v.spec.locus !== undefined).length;
-    mix.anchored = kept.filter((v) => v.spec.anchor !== undefined).length;
+    recount(mix);
     mix.parters.clear();
     for (const voice of [...kept, ...gone])
         if (voice.parts !== null || voice.parted !== null)
             mix.parters.add(voice);
-    mix.steps.push(null, ++mix.version);
     mix.relinks++;
     mix.pose = new Store();
     if (mix.restStamps !== null)
         mix.restStamps = new Store();
-    mix.pulled = [];
-    mix.pulledHeads = [];
-    mix.pulledSlots = new Int32Array(0);
-    mix.pulledVersion = Number.NaN;
-    mix.pulledRelinks = -1;
+    unpull(mix);
     for (const voice of [...kept, ...gone]) {
         voice.unreached = null;
         voice.unreachedBits = null;
@@ -290,10 +263,10 @@ function back(mix, t) {
     for (const motion of motions) {
         if (oldLanes !== null && motion.watcher === oldLanes)
             motion.watcher = null;
-        motion.rewind(t);
+        motion.rewind(seq);
     }
     // What history kept after `t` is let go; the tape holds the calls that made it.
-    mix.hostLog = mix.hostLog.filter((e) => e.at <= t);
+    mix.hostLog = mix.hostLog.filter((e) => e.seq <= seq);
     mix.sent = mix.sent.filter((e) => e.timestamp <= t);
     mix.sentTo = t;
     mix.pins = null;
@@ -307,5 +280,15 @@ function back(mix, t) {
     for (const voice of kept)
         schedule(mix, voice);
     mix.stir();
-    move(mix, t);
+    // On the frame's own time its move is behind it: a second would land what the next frame does.
+    if (on)
+        move(mix, t);
+    else {
+        mix.frame = nextFrame();
+        mix.reducedNow = mix.reduced;
+        // A voice history let go of may have placed an anchor then: placed again from what it holds.
+        const ms = mix.opts.history.ms;
+        if (mix.anchored > 0 && mix.transport.forgotTo >= t - ms)
+            place(mix);
+    }
 }

package/dist/shared.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
+ * patch or channel it made is read by another copy's mix. The name carries a version, bumped when
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export declare function shared<K extends object, V>(name: string): WeakMap<K, V>;

package/dist/shared.js

@@ -0,0 +1,15 @@
+/**
+ * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
+ * patch or channel it made is read by another copy's mix. The name carries a version, bumped when
+ * what is stored changes shape, so copies that disagree on the shape keep apart.
+ */
+export function shared(name) {
+    const key = Symbol.for(`@msb235/blits/${name}`);
+    const g = globalThis;
+    let map = g[key];
+    if (map === undefined) {
+        map = new WeakMap();
+        g[key] = map;
+    }
+    return map;
+}

package/dist/signals.d.ts

@@ -1,4 +1,6 @@
-import type { Signal } from './types.js';
+import type { Setting, Signal } from './types.js';
+/** Whether a change to an input signal reaches `reading.inputs`, so a lane fill can see it. */
+export declare const heard: (signal: object) => boolean;
 /**
  * The loudest of several signals.
  *
@@ -6,7 +8,26 @@ import type { Signal } from './types.js';
  */
 export declare function peak<I, H = unknown>(...signals: readonly Signal<I, H>[]): Signal<I, H>;
 /**
- * A signal the host writes. klieg's `level`.
+ * Marks `read` as a signal driven from outside the clock, which a host's own signal has to be for
+ * `assess` and a history's `inputs` to treat it as one. Two uses:
+ *
+ * `input(read)` is an input of the host's own: a pointer, a volume, a value in a store. The host
+ * calls `touch()` after each change to what `read` reads, and a voice weighted by the signal, or by
+ * `peak`, `slew`, `lag` or `gate` over it, keeps its lane. A change nobody reports shows once the
+ * mix's clock next moves.
+ *
+ * `input(read, of)` is a signal built on others, as a wrapper that clamps one is: `of` lists every
+ * signal `read` calls, and the result is an input where any of them is, and reports its changes
+ * where they all do.
+ *
+ * @category signal
+ */
+export declare function input<I, H = unknown>(read: (subject: I, setting: Setting<void, H>) => number, of?: readonly Signal<I, H>[]): Signal<I, H> & {
+    touch(): void;
+};
+/**
+ * A signal the host writes: `input` over one number, with `set` reporting each change. klieg's
+ * `level`.
  *
  * @category signal
  */
@@ -14,7 +35,7 @@ export declare function level<I, H = unknown>(initial?: number): Signal<I, H> &
     set(v: number): void;
 };
 /**
- * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
+ * The package's linear decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
  * handed the same slew each follow on their own. A subject starts on its input, or at `from`
  * unless `dt` is infinite.