@msb235/blits 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -4,6 +4,22 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.7.1
+
+### Fixed
+
+- Under `history`, a mix whose subjects come and go no longer slows as the voices that have left
+  pile up. `drop` and a freed slot visit only the voices that left that can hold the subject,
+  history lets go of them from the front of the list, and the tape is pruned a second at a time
+  rather than every sync. A 200-subject roster replacing 4 subjects a frame climbed to about 1.2 ms
+  a frame as 14,000 voices that had left built up; it now holds at about 0.065 ms.
+- An anchor naming a score reads only the voices on that score, and only in the mixes on the
+  transport that hold one; it reads each voice that has left once rather than every frame, and
+  picks in one pass instead of sorting. astv's busy stage, whose rail waits on the latest `coast`
+  of its motion score, takes about 0.45 ms a frame in astv's motion bench, against 4.3 ms on 0.7.0.
+  With 200 mixes on scores of their own beside it, a frame's sync takes about 14 µs, against 21
+  before the transport listed the mixes holding each score (Node, medians of six alternated runs).
+
 ## 0.7.0
 
 ### Breaking

package/README.md

@@ -100,7 +100,7 @@ so the engine keeps no dependencies; its README says how it works.
 
 ## Status
 
-v0.7.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.7.1, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
 transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.

package/dist/cue.js

@@ -8,6 +8,7 @@ import { motionOf } from './motion.js';
 import { adopt, ownerPatch, ownerReading } from './owner.js';
 import { durationOf } from './patch.js';
 import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
+import { scoredAdd } from './scored.js';
 import { checkChild, refit } from './spans.js';
 import { motionOwner } from './strays.js';
 import { record } from './tape.js';
@@ -127,6 +128,7 @@ function enter(mix, voice) {
     while (i > 0 && cued[i - 1].id > voice.id)
         i--;
     cued.splice(i, 0, voice);
+    scoredAdd(mix, voice);
     index(mix, voice);
     changed(mix, voice);
     mix.stir();

package/dist/fade.js

@@ -4,6 +4,7 @@ import { schedule } from './due.js';
 import { leave, noted, releasing } from './history.js';
 import { orphan } from './owner.js';
 import { startOf } from './place.js';
+import { scoreTouched } from './scored.js';
 import { lingers, refit } from './spans.js';
 import { unreach } from './unreached.js';
 /** Starts one subject's ramp out of a voice, or takes it out at once for a ramp of 0. */
@@ -162,6 +163,7 @@ export function retire(mix, voice, at) {
     if (motion !== undefined && asks(mix, motion, voice))
         motion.owner = null;
     voice.state = 'done';
+    scoreTouched(mix, voice);
     // The record its setting last wrote to, which a retired voice no longer calls for.
     voice.keepOn = null;
     mix.retired.push(voice);

package/dist/gone.d.ts

@@ -0,0 +1,32 @@
+import type { Mixer } from './mixer.js';
+import { Store } from './store.js';
+import type { Voice } from './voice.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export declare class GoneIndex<I, O> {
+    /** The `gone` list it was built over, and how much of it. */
+    of: readonly Voice<I, O>[] | null;
+    count: number;
+    general: Voice<I, O>[];
+    named: Store<I, Voice<I, O>[]>;
+    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    latest: number;
+    slack: number;
+}
+/** The index caught up with `mix.gone`. */
+export declare function goneIndex<I, O>(mix: Mixer<I, O>): GoneIndex<I, O>;
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export declare function keepGone<I, O>(mix: Mixer<I, O>, keep: (v: Voice<I, O>) => boolean): void;
+/**
+ * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
+ * finish, so only the front can hold one: past the point where a voice finished `slack` after
+ * `reach`, none behind it finished before `reach`.
+ */
+export declare function expireGone<I, O>(mix: Mixer<I, O>, reach: number): void;

package/dist/gone.js

@@ -0,0 +1,134 @@
+import { scoredCut } from './scored.js';
+import { Store } from './store.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export class GoneIndex {
+    /** The `gone` list it was built over, and how much of it. */
+    of = null;
+    count = 0;
+    general = [];
+    named = new Store();
+    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    latest = Number.NEGATIVE_INFINITY;
+    slack = 0;
+}
+function add(ix, voice) {
+    if (voice.doneAt < ix.latest)
+        ix.slack = Math.max(ix.slack, ix.latest - voice.doneAt);
+    else
+        ix.latest = voice.doneAt;
+    if (voice.named === null) {
+        ix.general.push(voice);
+        return;
+    }
+    for (const subject of voice.named) {
+        const list = ix.named.get(subject);
+        if (list === undefined)
+            ix.named.set(subject, [voice]);
+        else
+            list.push(voice);
+    }
+}
+function remove(ix, out) {
+    let general = false;
+    for (const v of out) {
+        if (v.named === null) {
+            general = true;
+            continue;
+        }
+        for (const subject of v.named) {
+            const named = ix.named.get(subject);
+            if (named === undefined)
+                continue;
+            const at = named.indexOf(v);
+            if (at >= 0)
+                named.splice(at, 1);
+            if (named.length === 0)
+                ix.named.delete(subject);
+        }
+    }
+    if (general) {
+        const leaving = new Set(out);
+        ix.general = ix.general.filter((v) => !leaving.has(v));
+    }
+}
+/** The index caught up with `mix.gone`. */
+export function goneIndex(mix) {
+    const ix = mix.goneIx;
+    const list = mix.gone;
+    if (ix.of !== list || ix.count > list.length) {
+        ix.general = [];
+        ix.named = new Store();
+        ix.count = 0;
+        ix.of = list;
+        ix.latest = Number.NEGATIVE_INFINITY;
+        ix.slack = 0;
+    }
+    for (let i = ix.count; i < list.length; i++)
+        add(ix, list[i]);
+    ix.count = list.length;
+    return ix;
+}
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export function keepGone(mix, keep) {
+    const ix = goneIndex(mix);
+    const list = mix.gone;
+    let i = 0;
+    while (i < list.length && keep(list[i]))
+        i++;
+    if (i === list.length)
+        return;
+    const kept = list.slice(0, i);
+    const out = [list[i]];
+    for (i++; i < list.length; i++) {
+        const v = list[i];
+        (keep(v) ? kept : out).push(v);
+    }
+    remove(ix, out);
+    mix.gone = kept;
+    scoredCut(mix, list, out);
+    ix.of = kept;
+    ix.count = kept.length;
+}
+/**
+ * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
+ * finish, so only the front can hold one: past the point where a voice finished `slack` after
+ * `reach`, none behind it finished before `reach`.
+ */
+export function expireGone(mix, reach) {
+    const ix = goneIndex(mix);
+    if (!Number.isFinite(ix.slack)) {
+        keepGone(mix, (v) => v.doneAt >= reach);
+        return;
+    }
+    const list = mix.gone;
+    const edge = reach + ix.slack;
+    let end = 0;
+    let any = false;
+    for (let seen = Number.NEGATIVE_INFINITY; end < list.length && seen < edge; end++) {
+        const done = list[end].doneAt;
+        if (done < reach)
+            any = true;
+        if (done > seen)
+            seen = done;
+    }
+    if (!any)
+        return;
+    const kept = [];
+    const out = [];
+    for (let i = 0; i < end; i++) {
+        const v = list[i];
+        (v.doneAt < reach ? out : kept).push(v);
+    }
+    list.splice(0, end, ...kept);
+    remove(ix, out);
+    scoredCut(mix, list, out);
+    ix.count = list.length;
+}

package/dist/history.js

@@ -3,6 +3,7 @@ import { clone } from './clone.js';
 import { schedule } from './due.js';
 import { packHeld } from './pack.js';
 import { pageOut } from './paging.js';
+import { scoreTouched } from './scored.js';
 import { none } from './voice.js';
 /**
  * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
@@ -52,6 +53,7 @@ function ownerThen(mix, owner, t) {
 }
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
 export function noted(mix, voice) {
+    scoreTouched(mix, voice, true);
     mix.stir();
     schedule(mix, voice);
     const log = voice.log;

package/dist/hosts.js

@@ -3,6 +3,7 @@ import { numericOf } from './channels.js';
 import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
 import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
+import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
 import { noted, remember } from './history.js';
 import { hostOf, listed, markOf, readingAt } from './marks.js';
@@ -57,7 +58,7 @@ export function laneHost(mix) {
             // Only a voice over every subject keeps bits, and one gone may still be read back.
             for (const voice of mix.general)
                 unreach(voice, slot, false);
-            for (const voice of mix.gone)
+            for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
         },
         passes: (was, w) => mix.passes(was, w),

package/dist/mixer.d.ts

@@ -5,6 +5,7 @@ import { type LerpInto } from './channels.js';
 import type { Due } from './due.js';
 import { parting } from './fade.js';
 import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, type Key, keyed, linked, owedBy, passes, read, slopeFor, tick } from './fold.js';
+import { GoneIndex } from './gone.js';
 import type { HandleHost } from './handle.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
 import { Lanes } from './lanes.js';
@@ -15,6 +16,7 @@ import { Keys } from './paging.js';
 import { keep } from './pull.js';
 import { Steps } from './relink.js';
 import { Outs } from './revive.js';
+import { ScoreIndex } from './scored.js';
 import { Fitting } from './spans.js';
 import { Store } from './store.js';
 import { type Announced, Transport } from './transport.js';
@@ -27,6 +29,8 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     cued: Voice<I, O>[];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone: Voice<I, O>[];
+    goneIx: GoneIndex<I, O>;
+    scored: ScoreIndex<I, O>;
     /** Set on a projection's own mixer: it sends nothing, keeps no history, and reads without committing. */
     projecting: boolean;
     /** Set on a projection reading back: a subject it has nothing on starts from its voice's start. */

package/dist/mixer.js

@@ -4,6 +4,7 @@ import { lerpInto } from './channels.js';
 import { cue } from './cue.js';
 import { beginFade, parting } from './fade.js';
 import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, keyed, linked, near, owedBy, passes, read, slopeFor, tick, } from './fold.js';
+import { GoneIndex, goneIndex } from './gone.js';
 import { held, shownOf, sinceOf, unreachedOf } from './held.js';
 import { leave, releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
@@ -17,6 +18,7 @@ import { projectAll } from './project.js';
 import { keep, pull } from './pull.js';
 import { Steps } from './relink.js';
 import { Outs } from './revive.js';
+import { ScoreIndex } from './scored.js';
 import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
 import { Store } from './store.js';
@@ -31,6 +33,8 @@ export class Mixer {
     cued = [];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone = [];
+    goneIx = new GoneIndex();
+    scored = new ScoreIndex();
     /** Set on a projection's own mixer: it sends nothing, keeps no history, and reads without committing. */
     projecting = false;
     /** Set on a projection reading back: a subject it has nothing on starts from its voice's start. */
@@ -462,8 +466,13 @@ export class Mixer {
         if (named !== undefined)
             for (const voice of [...named])
                 forget(voice);
-        for (const voice of this.gone)
+        const gone = goneIndex(this);
+        for (const voice of gone.general)
             forget(voice);
+        const goneNaming = gone.named.get(subject);
+        if (goneNaming !== undefined)
+            for (const voice of goneNaming)
+                forget(voice);
         if (this.owners !== null)
             for (const voice of this.owners)
                 forget(voice);

package/dist/move.js

@@ -1,10 +1,12 @@
 import { changed, unindex } from './chain.js';
 import { popDue, schedule } from './due.js';
 import { beginFade, part, retire } from './fade.js';
+import { expireGone, keepGone } from './gone.js';
 import { started } from './held.js';
 import { ownerReading } from './owner.js';
 import { mixAt, place, repin, startOf } from './place.js';
 import { pageVoice } from './revive.js';
+import { scoredLeft, scoredRemove } from './scored.js';
 import { lapse } from './spans.js';
 import { unplay } from './strays.js';
 /** Numbers every mix's frames apart, so a blend's read is never taken for another mix's or frame's. */
@@ -173,8 +175,11 @@ function indexOf(voices, voice) {
 }
 /** Lets go of a retired voice's place in the mix; whether it was among the voices naming no subject. */
 function leave(mix, voice) {
-    if (mix.opts.history)
+    scoredRemove(mix, [voice]);
+    if (mix.opts.history) {
         mix.gone.push(voice);
+        scoredLeft(mix, voice);
+    }
     else
         mix.parters.delete(voice);
     unplay(mix, voice);
@@ -196,11 +201,10 @@ export function forget(mix) {
         // With a store a voice that has left pages out where it can, and stays where it cannot.
         if (mix.transport.pager !== null) {
             const reach = mix.now - history.ms;
-            mix.gone = mix.gone.filter((v) => v.doneAt >= reach || !pageVoice(mix, v, reach));
+            keepGone(mix, (v) => v.doneAt >= reach || !pageVoice(mix, v, reach));
         }
         else {
-            const reach = mix.transport.keepsFrom();
-            mix.gone = mix.gone.filter((v) => v.doneAt >= reach);
+            expireGone(mix, mix.transport.keepsFrom());
         }
     }
 }

package/dist/place.js

@@ -1,6 +1,7 @@
 import { noted } from './history.js';
 import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
+import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
 import { none } from './voice.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
 export function localNow(mix, voice) {
@@ -178,7 +179,7 @@ function resolve(mix, a, self) {
         mark = 'start';
         by = -by;
     }
-    const t = timeOf(mix, typeof query === 'string' ? { name: query } : query, mark, self);
+    const t = timeOf(mix, query, mark, self);
     if (t === undefined)
         return undefined;
     if (o === null)
@@ -200,46 +201,188 @@ function member(mix, a, self) {
     }
     return t;
 }
+/** Picks among the times a query meets, as its resolver says, in the order they are met. */
+class Pick {
+    resolver;
+    now;
+    any = false;
+    firstOrder = Number.POSITIVE_INFINITY;
+    lastOrder = Number.NEGATIVE_INFINITY;
+    first;
+    last;
+    pick;
+    constructor(resolver, now) {
+        this.resolver = resolver;
+        this.now = now;
+    }
+    take(order, t) {
+        this.any = true;
+        if (order < this.firstOrder) {
+            this.firstOrder = order;
+            this.first = t;
+        }
+        if (order > this.lastOrder) {
+            this.lastOrder = order;
+            this.last = t;
+        }
+        if (t !== undefined)
+            this.consider(t);
+    }
+    /** Takes what `o` picked as though its times had been met here. */
+    merge(o) {
+        if (!o.any)
+            return;
+        this.any = true;
+        if (o.firstOrder < this.firstOrder) {
+            this.firstOrder = o.firstOrder;
+            this.first = o.first;
+        }
+        if (o.lastOrder > this.lastOrder) {
+            this.lastOrder = o.lastOrder;
+            this.last = o.last;
+        }
+        if (o.pick !== undefined)
+            this.consider(o.pick);
+    }
+    consider(t) {
+        const p = this.pick;
+        if (this.resolver === 'earliest'
+            ? p === undefined || t < p
+            : this.resolver === 'latest'
+                ? p === undefined || t > p
+                : this.resolver === 'next' && t >= this.now && (p === undefined || t < p))
+            this.pick = t;
+    }
+    answer() {
+        if (!this.any)
+            return undefined;
+        if (this.resolver === 'first')
+            return this.first;
+        if (this.resolver === 'last')
+            return this.last;
+        return this.pick;
+    }
+}
 /**
  * The mix time a query answers: `mark` of the voice it picks, among those cued and those that have
  * left, never the asker; or a mark the host announced on the score, which is the same time for
  * any of the four. Undefined while what it picks has no such time. A query naming no score looks
  * among the asker's siblings, the voices its owner holds.
  */
-function timeOf(mix, q, mark, self) {
+function timeOf(mix, key, mark, self) {
+    const q = typeof key === 'string' ? { name: key } : key;
     const score = q.score ?? self.spec.score;
     const anywhere = q.score !== undefined;
-    const found = [];
-    // A query naming a score looks in every mix on the transport; one naming none, in its own.
-    const mixes = anywhere ? mix.transport.members : [mix];
-    for (const m of mixes)
-        for (const v of [...m.gone, ...m.cued])
-            if (v !== self &&
-                v.spec.score === score &&
-                (anywhere || v.owner === self.owner) &&
-                (q.name === undefined || v.spec.name === q.name) &&
-                (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
-                (q.writes === undefined || v.patch.writes.includes(q.writes)))
-                found.push({ order: v.id, t: markOf(m, v, mark) });
+    const resolver = q.resolver ?? 'last';
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    const picked = new Pick(resolver, now);
+    const matches = (v) => v !== self &&
+        v.spec.score === score &&
+        (anywhere || v.owner === self.owner) &&
+        (q.name === undefined || v.spec.name === q.name) &&
+        (q.tag === undefined || (v.spec.tags ?? none).includes(q.tag)) &&
+        (q.writes === undefined || v.patch.writes.includes(q.writes));
+    // A query naming a score looks in every mix on the transport that holds a voice on it; one
+    // naming none, in its own.
+    const listed = anywhere && score !== undefined && !mix.projecting;
+    const mixes = !anywhere
+        ? [mix]
+        : listed
+            ? holders(mix, score)
+            : mix.transport.members;
+    for (let i = 0; i < mixes.length; i++) {
+        const m = mixes[i];
+        if (score === undefined || m.projecting || mix.projecting) {
+            for (const v of [...m.gone, ...m.cued])
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const cued = scored(m, score);
+        const list = scoredGone(m, score);
+        if (cued.size === 0 && list.length === 0) {
+            if (listed) {
+                unhold(m, score);
+                i--;
+            }
+            continue;
+        }
+        // `next` asks what is still ahead of now, which a running pick cannot keep.
+        if (resolver === 'next') {
+            for (const v of cued)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            for (const v of list)
+                if (matches(v))
+                    picked.take(v.id, markOf(m, v, mark));
+            continue;
+        }
+        const fold = foldOf(m, list, key, mark, self, resolver);
+        const version = scoreVersion(m, score);
+        const reduced = m.reduced;
+        if (fold.live === null ||
+            fold.liveOf !== m.cued ||
+            fold.liveVersion !== version ||
+            fold.liveReduced !== reduced) {
+            const live = new Pick(resolver, Number.NEGATIVE_INFINITY);
+            let keeps = true;
+            for (const v of cued) {
+                if (!matches(v))
+                    continue;
+                if (v.owner !== null || v.holding !== null || v.fitting !== null)
+                    keeps = false;
+                live.take(v.id, markOf(m, v, mark));
+            }
+            fold.live = live;
+            fold.liveOf = keeps ? m.cued : null;
+            fold.liveVersion = version;
+            fold.liveReduced = reduced;
+        }
+        picked.merge(fold.live);
+        for (; fold.seen < list.length; fold.seen++) {
+            const v = list[fold.seen];
+            if (!matches(v))
+                continue;
+            if (v.owner === null)
+                fold.pick.take(v.id, markOf(m, v, mark));
+            else
+                fold.owned.push(v);
+        }
+        picked.merge(fold.pick);
+        for (const v of fold.owned)
+            picked.take(v.id, markOf(m, v, mark));
+    }
     if (q.writes === undefined && (anywhere || self.owner === null))
         for (const a of mix.announced)
             if (a.score === score &&
                 (score !== undefined || a.slot === mix.slot) &&
                 (q.name === undefined || a.name === q.name) &&
                 (q.tag === undefined || a.tags.includes(q.tag)))
-                found.push({ order: a.order, t: Number.isNaN(a.at) ? undefined : mixAt(mix, a.at) });
-    if (found.length === 0)
-        return undefined;
-    found.sort((x, y) => x.order - y.order);
-    const resolver = q.resolver ?? 'last';
-    if (resolver === 'first')
-        return found[0]?.t;
-    if (resolver === 'last')
-        return found[found.length - 1]?.t;
-    const times = found.flatMap((e) => (e.t === undefined ? [] : [e.t])).sort((x, y) => x - y);
-    if (resolver === 'next') {
-        const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
-        return times.find((t) => t >= now);
-    }
-    return resolver === 'earliest' ? times[0] : times[times.length - 1];
+                picked.take(a.order, Number.isNaN(a.at) ? undefined : mixAt(mix, a.at));
+    return picked.answer();
+}
+/** `self`'s read of `m`'s gone voices for one query, started over where the list has changed under it. */
+function foldOf(m, list, key, mark, self, resolver) {
+    self.folds ??= new Map();
+    let byMix = self.folds.get(key);
+    if (byMix === undefined) {
+        byMix = new Map();
+        self.folds.set(key, byMix);
+    }
+    let fold = byMix.get(m);
+    if (fold === undefined || fold.list !== list || fold.mark !== mark) {
+        fold = {
+            list,
+            mark,
+            seen: 0,
+            pick: new Pick(resolver, Number.NEGATIVE_INFINITY),
+            owned: [],
+            live: null,
+            liveOf: null,
+            liveVersion: -1,
+            liveReduced: false,
+        };
+        byMix.set(m, fold);
+    }
+    return fold;
 }

package/dist/scored.d.ts

@@ -0,0 +1,57 @@
+import type { Mixer } from './mixer.js';
+import type { Voice } from './voice.js';
+/**
+ * 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 declare class ScoreIndex<I, O> {
+    cued: readonly Voice<I, O>[] | null;
+    by: Map<string, Set<Voice<I, O>>>;
+    gone: readonly Voice<I, O>[] | null;
+    goneBy: Map<string, Voice<I, O>[]>;
+    /** Bumped for a score each time a voice on it is cued, retimed, retired or leaves. */
+    versions: Map<string, number>;
+    /** The scores whose list on the transport names this mix. */
+    held: Set<string>;
+}
+type Member = Mixer<unknown, unknown>;
+/**
+ * Per score, the mixes on a transport that may hold a voice on it, cued or gone, in the
+ * transport's order. Never short of one that does; one found holding none is let go on that read.
+ */
+export type ScoreHolders = Map<string, Member[]>;
+/** The mixes on `mix`'s transport that may hold a voice on `score`; the list is the transport's own. */
+export declare function holders<I, O>(mix: Mixer<I, O>, score: string): readonly Mixer<I, O>[];
+/** Takes `mix` off `score`'s list, having found it holds nothing there. */
+export declare function unhold<I, O>(mix: Mixer<I, O>, score: string): void;
+/** A mix joining its transport, with whatever voices it already has. */
+export declare function scoredJoin<I, O>(mix: Mixer<I, O>): void;
+/** A mix leaving its transport. */
+export declare function scoredDrop<I, O>(mix: Mixer<I, O>): void;
+/**
+ * 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 declare function scoreTouched<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, retimed?: boolean): void;
+/** How many times `score` has been touched in `mix`. */
+export declare function scoreVersion<I, O>(mix: Mixer<I, O>, score: string): number;
+/** The voices of `mix` cued on `score` and not yet gone, in no order. */
+export declare function scored<I, O>(mix: Mixer<I, O>, score: string): ReadonlySet<Voice<I, O>>;
+/** The voices of `mix` cued on `score` that have gone, in the order they left. */
+export declare function scoredGone<I, O>(mix: Mixer<I, O>, score: string): readonly Voice<I, O>[];
+/** A voice just pushed onto `gone`. */
+export declare function scoredLeft<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * 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 declare function scoredCut<I, O>(mix: Mixer<I, O>, was: readonly Voice<I, O>[], out: readonly Voice<I, O>[]): void;
+/** A voice just cued. */
+export declare function scoredAdd<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** Voices no longer cued. */
+export declare function scoredRemove<I, O>(mix: Mixer<I, O>, voices: Iterable<Voice<I, O>>): void;
+export {};

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/transport.d.ts

@@ -1,6 +1,7 @@
 import type { Mixer } from './mixer.js';
 import { Pace } from './pace.js';
 import { Pager } from './paging.js';
+import { type ScoreHolders } from './scored.js';
 import type { Marked, Mix, MixOptions, Tape, Transport as TransportApi, TransportOptions, TransportProjection } from './types.js';
 /**
  * A mark the host announced on a score: `at` in host time, so the rate never moves one, and NaN
@@ -37,6 +38,7 @@ export declare class Transport implements TransportApi {
     }[];
     /** Numbers the mixes as they join, for their order and for whose unnamed score a mark is on. */
     slots: number;
+    holders: ScoreHolders;
     private wakeFns;
     /** Whether it has woken since the last sync, so it wakes once. */
     private woken;
@@ -51,6 +53,8 @@ export declare class Transport implements TransportApi {
     floor: number;
     last: number;
     rebasing: boolean;
+    /** The reach the tape was last pruned to. */
+    taped: number;
     /** The rate; null while it has never been set, when mix time is host time. */
     pace: Pace | null;
     /** True while the tape makes a recorded call again, so it is not recorded twice. */

package/dist/transport.js

@@ -4,8 +4,11 @@ import { Pace } from './pace.js';
 import { Pager, prepare } from './paging.js';
 import { pin } from './place.js';
 import { projectAll } from './project.js';
+import { scoredDrop, scoredJoin } from './scored.js';
 import { seek } from './seek.js';
 import { record, replay, tapeOf } from './tape.js';
+/** How far the tape's reach moves before it is pruned again, ms of mix time. */
+const TAPE_STEP_MS = 1000;
 /**
  * The clock its mixes play on: host time less what `rebase` took out, at the rate its `pace`
  * sets, moved by `sync` and `seek`, and the tape of calls a seek plays again. A mix made alone
@@ -20,6 +23,7 @@ export class Transport {
     dropped = [];
     /** Numbers the mixes as they join, for their order and for whose unnamed score a mark is on. */
     slots = 0;
+    holders = new Map();
     wakeFns = [];
     /** Whether it has woken since the last sync, so it wakes once. */
     woken = false;
@@ -34,6 +38,8 @@ export class Transport {
     floor = Number.NEGATIVE_INFINITY;
     last = Number.NaN;
     rebasing = false;
+    /** The reach the tape was last pruned to. */
+    taped = Number.NEGATIVE_INFINITY;
     /** The rate; null while it has never been set, when mix time is host time. */
     pace = null;
     /** True while the tape makes a recorded call again, so it is not recorded twice. */
@@ -66,6 +72,7 @@ export class Transport {
             this.members.push(mix);
         else
             this.members.splice(i, 0, mix);
+        scoredJoin(mix);
     }
     drop(mix) {
         const m = mix;
@@ -73,6 +80,7 @@ export class Transport {
         if (i < 0)
             throw new Error(`blits: ${m.name ?? 'that mix'} is not on this transport`);
         this.members.splice(i, 1);
+        scoredDrop(m);
         m.dropped = true;
         if (this.history !== undefined) {
             this.dropped.push({ mix: m, at: this.now });
@@ -173,8 +181,12 @@ export class Transport {
         const history = this.history;
         this.kept();
         const reach = this.keepsFrom();
-        if (this.tape !== undefined && history !== undefined)
+        // In steps: the tape shifts every entry it keeps to let go of the oldest, and one a second
+        // behind reach is never played again.
+        if (this.tape !== undefined && history !== undefined && !(reach - this.taped < TAPE_STEP_MS)) {
             this.tape.prune(reach);
+            this.taped = reach;
+        }
         if (history !== undefined && this.dropped.length > 0)
             this.dropped = this.dropped.filter((d) => d.at >= reach);
         this.woken = false;

package/dist/unpage.js

@@ -1,6 +1,7 @@
 import { unpackHeld } from './pack.js';
 import { HistoryMiss } from './paging.js';
 import { reviveVoice } from './revive.js';
+import { scoredLeft } from './scored.js';
 /**
  * Makes memory reach mix time `t` for a seek or read there, from what `prepare` loaded; true where
  * it took records from the store. Throws before anything moves where it cannot.
@@ -66,6 +67,7 @@ function unpageMix(mix, records) {
             const v = reviveVoice(mix, r.voice, r.data);
             voices.set(v.id, v);
             mix.gone.push(v);
+            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);

package/dist/voice.d.ts

@@ -222,6 +222,8 @@ export declare class Voice<I, O> {
     placing: boolean;
     /** What each member of a join last answered, kept for once its target has left. */
     answers: Map<Anchor, number> | null;
+    /** What each of its anchors' queries has read of each mix's gone voices (`place.ts`'s `Fold`). */
+    folds: Map<unknown, Map<unknown, unknown>> | null;
     /** The record `setting.keep` writes to: the one its patch or signal is being called for. */
     keepOn: Subject<unknown> | null;
     /** What `setting.keep` holds when called before any record is. */

package/dist/voice.js

@@ -175,6 +175,8 @@ export class Voice {
     placing = false;
     /** What each member of a join last answered, kept for once its target has left. */
     answers = null;
+    /** What each of its anchors' queries has read of each mix's gone voices (`place.ts`'s `Fold`). */
+    folds = null;
     /** The record `setting.keep` writes to: the one its patch or signal is being called for. */
     keepOn = null;
     /** What `setting.keep` holds when called before any record is. */
@@ -317,6 +319,7 @@ export class Voice {
         this.doneAt = Number.POSITIVE_INFINITY;
         this.placing = false;
         this.answers = null;
+        this.folds = null;
         this.keepOn = null;
         this.ownKept = null;
         this.unreached = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",
@@ -53,7 +53,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.5.8",
     "@types/node": "^26.2.0",
-    "@weasel-js/history": "^1.9.0",
+    "@weasel-js/history": "^1.9.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   }