@msb235/blits 0.12.1 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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.13.0
+
+### Breaking
+
+- A mix's stock `band` is on at any weight above 0 and off at 0, where it was on above 0.6 and off
+  below 0.4. A channel with no rest, such as `last()`, now shows its value through a whole fade in or
+  out. Pass `band: { on: 0.6, off: 0.4 }` for the old behavior. `fold` follows the same default.
+
+### Added
+
+- A mix's `loci`: tags that act as loci, so a voice carrying one folds with the others carrying it,
+  as if its `locus` named the tag.
+
+### Fixed
+
+- A seek with `state: 'keep'` that sends a subject back before its start now starts it afresh there.
+  It kept the state it had stepped to, so what it showed, and how it played on from its start,
+  depended on how often the host had read it, and a mix seek could put back the state from before.
+- A mix sought back and then ahead to where it stood reads the same `now` on its next sync as one
+  never sought. At some mix rates it read one rounding step off, and every later sync kept the error.
+- Replacing voices costs less a frame: a crowd catches up only the rows marked stale, where it
+  scanned every row, and a few retired voices are spliced out of the list. One subject leaving for
+  good each frame and a new one coming (`turnover^`, 10,000 subjects) takes 0.286 ms a frame
+  against 0.315, and one voice replaced in place each frame (`churn^`) 0.224 against 0.252 (teitou,
+  medians of nine runs of 5,000 frames, each in its own process); steady voices are unchanged.
+
 ## 0.12.1
 
 ### Added

package/dist/channels.d.ts

@@ -1,4 +1,9 @@
 import type { Channel, Kit } from './types.js';
+/** The band a mix switches a rest-less channel's contribution across where its options name none. */
+export declare const STOCK_BAND: {
+    readonly on: number;
+    readonly off: 0;
+};
 /** The stock numeric channels' `lerp`, which `vec` applies per axis and lanes call directly. */
 export declare const lerpNumber: (a: number, b: number, u: number) => number;
 /**

package/dist/channels.js

@@ -1,4 +1,6 @@
 import { shared } from './shared.js';
+/** The band a mix switches a rest-less channel's contribution across where its options name none. */
+export const STOCK_BAND = { on: Number.MIN_VALUE, off: 0 };
 /** The stock numeric channels' `lerp`, which `vec` applies per axis and lanes call directly. */
 export const lerpNumber = (a, b, u) => a + (b - a) * u;
 const mix = lerpNumber;

package/dist/crowd.d.ts

@@ -92,6 +92,8 @@ export declare class Crowd<I, O> implements Positions<I, O> {
     dead: number;
     /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
     stale: boolean;
+    /** The rows marked stale since the last `freshen`, which checks each is still stale. */
+    staleRows: number[];
     readonly xs: Float64Array;
     readonly vs: Float64Array;
     /** What a keys row reads into, folded before the next row reads. */

package/dist/crowd.js

@@ -54,6 +54,8 @@ export class Crowd {
     dead = 0;
     /** Whether some row is `Flag.STALE`, for `freshen` to copy before the fill's loop. */
     stale = false;
+    /** The rows marked stale since the last `freshen`, which checks each is still stale. */
+    staleRows = [];
     xs;
     vs;
     /** What a keys row reads into, folded before the next row reads. */
@@ -82,6 +84,7 @@ export class Crowd {
     restale(p, flags) {
         this.hot[p * this.stride + 0 /* Hot.FLAGS */] = flags | 4 /* Flag.STALE */;
         this.stale = true;
+        this.staleRows.push(p);
     }
     /** Samples of another width than the channel's, which `samples` cannot hold, by row. */
     odd = null;
@@ -347,7 +350,12 @@ export function freshen(c) {
     c.stale = false;
     const hot = c.hot;
     const H = c.stride;
-    for (let p = 0; p < c.list.length; p++) {
+    const rows = c.staleRows;
+    c.staleRows = [];
+    for (let i = 0; i < rows.length; i++) {
+        const p = rows[i];
+        if (p >= c.list.length)
+            continue;
         const f = hot[p * H + 0 /* Hot.FLAGS */];
         if ((f & 4 /* Flag.STALE */) === 0 || (f & 128 /* Flag.MOTION */) === 0)
             continue;

package/dist/cue.d.ts

@@ -1,6 +1,6 @@
 import type { Mixer } from './mixer.js';
 import type { Handle, Kit, Patch, VoiceSpec } from './types.js';
-export declare function cue<I, O>(mix: Mixer<I, O>, spec: VoiceSpec<I, O>): Handle<I>;
+export declare function cue<I, O>(mix: Mixer<I, O>, given: VoiceSpec<I, O>): Handle<I>;
 /** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
 export declare function fitsKit<I, O, S, H>(patch: Patch<I, O, S, H>, kit: Kit<O>): void;
 /** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */

package/dist/cue.js

@@ -17,7 +17,8 @@ import { checkChild, refit } from './spans.js';
 import { cuedById, motionOwner } from './strays.js';
 import { record, unplayable } from './tape.js';
 import { Voice } from './voice.js';
-export function cue(mix, spec) {
+export function cue(mix, given) {
+    const spec = locusOf(mix, given);
     const patch = spec.patch;
     playable(mix, spec);
     if (spec.from === 'current' && patch.form !== 'keys')
@@ -88,6 +89,22 @@ export function fitsKit(patch, kit) {
             throw new Error(`blits: channel ${String(channel)} is ${here.kind ?? 'a custom channel'} in this kit, but the patch was written for ${wanted.kind ?? 'a custom channel'}`);
     }
 }
+/** The spec with its `locus` set from a tag the mix declares one, where it carries one. */
+function locusOf(mix, spec) {
+    const loci = mix.opts.loci;
+    const tags = spec.tags;
+    if (loci === undefined || tags === undefined)
+        return spec;
+    let locus = spec.locus;
+    for (const tag of tags) {
+        if (!loci.includes(tag) || tag === locus)
+            continue;
+        if (locus !== undefined)
+            throw new Error(`blits: a voice folds in one locus, not both ${locus} and ${tag}`);
+        locus = tag;
+    }
+    return locus === spec.locus ? spec : { ...spec, locus };
+}
 /** Refuses a spec whose patch the mix cannot play, or whose state its history cannot keep. */
 export function playable(mix, spec) {
     const patch = spec.patch;

package/dist/fold.js

@@ -2,6 +2,7 @@ import { foldNumber } from './channels.js';
 import { passAt, phaseAt, phaseBefore, silent, stepOf } from './clock.js';
 import { copy as copyValue, first } from './clone.js';
 import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
+import { waits } from './held.js';
 import { apart, copyState, recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
 import { locusScratch } from './locus.js';
@@ -59,6 +60,13 @@ function rebuild(mix, voice, subject, now, held) {
     held.stepped = held.since < now ? held.since : now;
     held.probed = Number.NaN;
 }
+/** Whether a seek since its last read moved a stateful record's origin, as one back before it does. */
+function sentBack(mix, voice, held) {
+    const p = voice.patch;
+    if (p.state === undefined && p.step === undefined && !voice.keeping)
+        return false;
+    return mix.sinceOf(voice, held.delay) !== held.since;
+}
 /**
  * One live voice's delta for one subject this frame, through its record for the subject, or null
  * when it does not reach. Its weight is left in `w`.
@@ -71,6 +79,11 @@ export function contribution(voice, subject, now, held) {
         return null;
     if (held.rebuilt !== voice.rebuilds)
         rebuild(this, voice, subject, now, held);
+    else if (held.seeks !== voice.seeks && sentBack(this, voice, held)) {
+        // A seek sent it back before its start, so it starts afresh there, whatever state it kept.
+        rebuild(this, voice, subject, now, held);
+        waits(voice, held, now);
+    }
     const raw = voice.rawAt(now, held.delay);
     const early = voice.before(raw, now);
     if (early && !voice.holdsFirst)

package/dist/handle.js

@@ -115,7 +115,7 @@ export class VoiceHandle {
         // A pending voice's clock is anchored at its start, so it starts there on time.
         if (voice.state !== 'pending') {
             const u = this.#host.nowFor(voice);
-            leave(voice, u);
+            leave(voice, u, true);
             voice.rebase(u);
         }
         voice.anchorElapsed = elapsed;

package/dist/held.d.ts

@@ -24,6 +24,8 @@ export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, del
  * the voice first showed, for one freezing before.
  */
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
+/** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */
+export declare function waits<I, O>(voice: Voice<I, O>, held: Subject<unknown>, now: number): void;
 /**
  * A pending voice starts at `now`. Starting anywhere but 0 it was sought there, so a record made
  * while it waited is made again for where its clock is.

package/dist/held.js

@@ -64,19 +64,7 @@ export function held(voice, subject, slot, guess = null) {
         held.unknown = (this.backward && voice.spec.from === 'current') || fresh;
     }
     voice.subjects.set(subject, held);
-    if (!(since <= now)) {
-        voice.early ??= [];
-        const early = voice.early;
-        // Prunes at each doubling, so records whose origin has passed are not kept to the voice's end.
-        if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
-            let kept = 0;
-            for (const h of early)
-                if (!(h.since <= now))
-                    early[kept++] = h;
-            early.length = kept;
-        }
-        early.push(held);
-    }
+    waits(voice, held, now);
     // A subject a voice saw while it shared one record was counted then.
     if (sighted(voice, slot))
         inherit(voice, held, slot);
@@ -137,6 +125,22 @@ export function shownOf(voice, since) {
     const from = since < start ? start : since;
     return voice.freezesBefore && voice.opened < from ? voice.opened : from;
 }
+/** Lists a record whose origin is still ahead of `now`, for a later change to the clock to move. */
+export function waits(voice, held, now) {
+    if (held.since <= now)
+        return;
+    voice.early ??= [];
+    const early = voice.early;
+    // Prunes at each doubling, so records whose origin has passed are not kept to the voice's end.
+    if (early.length >= 64 && (early.length & (early.length - 1)) === 0) {
+        let kept = 0;
+        for (const h of early)
+            if (!(h.since <= now))
+                early[kept++] = h;
+        early.length = kept;
+    }
+    early.push(held);
+}
 /**
  * A pending voice starts at `now`. Starting anywhere but 0 it was sought there, so a record made
  * while it waited is made again for where its clock is.
@@ -154,7 +158,11 @@ export function begin(mix, voice, now) {
 }
 /** Counts a record whose `since` was still ahead from where its voice's clock now puts it. */
 export function origin(mix, voice, held) {
+    const was = held.since;
     held.since = mix.sinceOf(voice, held.delay);
+    // Sent back before a start it had passed: its next read starts it afresh.
+    if (held.since !== was && (held.ticks > 0 || held.stepped > was))
+        held.rebuilt = -1;
     held.shown = mix.shownOf(voice, held.since);
     if (held.ticks === 0 && held.stepped > held.since)
         held.stepped = held.since;

package/dist/mixer.js

@@ -1,7 +1,7 @@
 import { cueArc } from './arcs.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
 import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
-import { lerpInto, scalarOp } from './channels.js';
+import { lerpInto, STOCK_BAND, scalarOp } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
 import { beginFade, leaveVoice, parting } from './fade.js';
@@ -328,7 +328,7 @@ export class Mixer {
         return typeof r === 'function' ? r() : r === true;
     }
     get band() {
-        return this.opts.band ?? { on: 0.6, off: 0.4 };
+        return this.opts.band ?? STOCK_BAND;
     }
     cue(spec) {
         this.attached();

package/dist/move.js

@@ -172,6 +172,8 @@ function turn(mix, voice, now) {
  */
 const SEARCHED = 8;
 const SPARSE = 32;
+/** The most retired voices `prune` splices out one at a time, rather than closing up in one pass. */
+const SPLICED = 4;
 /**
  * Takes the voices retired since the last prune out of the list, in list order. A few, or a small
  * share of a long list, are found by their id, which the list is in order of, so the voices still
@@ -200,16 +202,21 @@ function prune(mix) {
     if (at !== null) {
         for (const voice of retired)
             pruned = leave(mix, voice) || pruned;
-        // Closed up in one pass from the first to go: a splice for each moves the tail once a voice.
-        let kept = at[0];
-        let k = 0;
-        for (let i = kept; i < voices.length; i++) {
-            if (at[k] === i)
-                k++;
-            else
-                voices[kept++] = voices[i];
+        // A splice moves the tail natively, several times faster than a loop, but once a voice.
+        if (at.length <= SPLICED)
+            for (let k = at.length - 1; k >= 0; k--)
+                voices.splice(at[k], 1);
+        else {
+            let kept = at[0];
+            let k = 0;
+            for (let i = kept; i < voices.length; i++) {
+                if (at[k] === i)
+                    k++;
+                else
+                    voices[kept++] = voices[i];
+            }
+            voices.length = kept;
         }
-        voices.length = kept;
     }
     else {
         let kept = 0;

package/dist/origin.d.ts

@@ -5,12 +5,14 @@ export interface Past extends Clock {
     until: number;
     /** The voice's `rebuilds` while it ran on this clock. */
     rebuilds: number;
+    /** Whether the voice left it by a seek. */
+    sought: boolean;
 }
 /**
  * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
  * where a subject's origin could still be found on it.
  */
-export declare function leave<I, O>(voice: Voice<I, O>, u: number): void;
+export declare function leave<I, O>(voice: Voice<I, O>, u: number, sought?: boolean): void;
 /**
  * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
  * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.

package/dist/origin.js

@@ -5,7 +5,7 @@ const MOST = 256;
  * Keeps the clock a voice is leaving at its local time `u`, ahead of a rate change, ramp or seek,
  * where a subject's origin could still be found on it.
  */
-export function leave(voice, u) {
+export function leave(voice, u, sought = false) {
     const past = voice.clocks;
     if (past !== null && past.length >= MOST)
         return;
@@ -14,7 +14,7 @@ export function leave(voice, u) {
     if (past !== null && reached(past, 0) >= reach && reached(past, fresh(voice)) >= reach)
         return;
     const { anchorNow, anchorElapsed, rate, ramp, rebuilds } = voice;
-    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds };
+    const left = { anchorNow, anchorElapsed, rate, ramp, until: u, rebuilds, sought };
     if (past === null)
         voice.clocks = [left];
     else
@@ -41,6 +41,18 @@ function fresh(voice) {
         i++;
     return i;
 }
+/**
+ * Where a walk for a stateful record at `elapsed` starts after a seek back before it: the clock that
+ * seek entered, since a subject sent back before its start starts afresh.
+ */
+function backFrom(voice, past, elapsed) {
+    for (let i = past.length - 1; i >= 0; i--) {
+        const p = past[i];
+        if (p.sought && (past[i + 1]?.anchorElapsed ?? voice.anchorElapsed) < elapsed)
+            return i + 1;
+    }
+    return 0;
+}
 /**
  * The mix time a voice's clock first read `elapsed`, or will by its controls now, through its owners'
  * clocks. A clock entered already past it, by a seek, answers where that clock would have read it.
@@ -51,7 +63,8 @@ export function originOf(voice, elapsed, rebuilt) {
     // A voice with no first pass shows every subject from its start, whatever its stagger.
     let t = voice.beginless ? voice.start : Number.NaN;
     if (past !== null && Number.isNaN(t)) {
-        for (let i = rebuilt ? fresh(voice) : 0; i < past.length; i++) {
+        const from = rebuilt ? Math.max(fresh(voice), backFrom(voice, past, elapsed)) : 0;
+        for (let i = from; i < past.length; i++) {
             const p = past[i];
             const at = timeWith(p, elapsed);
             if (at <= p.until) {

package/dist/rows.js

@@ -181,8 +181,10 @@ function copyRow(from, p, to, q, keys = from.keys) {
     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)
+    if ((from.hot[p * from.stride + 0 /* Hot.FLAGS */] & 4 /* Flag.STALE */) !== 0) {
         to.stale = true;
+        to.staleRows.push(q);
+    }
     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];

package/dist/seek.js

@@ -252,7 +252,14 @@ export function seek(transport, to) {
     if (frame === undefined) {
         // 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 at = hostAhead(transport, t);
+        const left = transport.left;
+        // Inverting the rate can land an ulp from where the host stood, which every later sync would carry.
+        const at = left !== null &&
+            left.t === t &&
+            left.u >= transport.u &&
+            (transport.pace === null ? left.u : transport.pace.reading(left.u)) === t
+            ? left.u
+            : hostAhead(transport, t);
         const u = Number.isNaN(last) ? at : Math.max(last, at);
         if (!Number.isFinite(u))
             throw new RangeError(`blits: the mix's rate never reaches ${t}`);
@@ -266,6 +273,7 @@ export function seek(transport, to) {
         // 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;
+        transport.left = { t: transport.now, u: transport.u };
         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.

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.12.1";
+export declare const release = "0.13.0";
 /**
  * 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

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.12.1';
+export const release = '0.13.0';
 /**
  * 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

package/dist/stack.d.ts

@@ -3,8 +3,8 @@ import type { Kit } from './types.js';
  * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
  * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
  * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
- * a mix's default band first switches one on, and stays undefined where none is.
+ * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
+ * weight above 0, and stays undefined where none is.
  *
  * @category channel
  */

package/dist/stack.js

@@ -1,13 +1,12 @@
+import { STOCK_BAND } from './channels.js';
 import { copy, first } from './clone.js';
 import { bound, merged } from './fold.js';
-/** The weight a mix's default band first switches a rest-less channel on at. */
-const ON = 0.6;
 /**
  * Folds deltas into one pose by a kit's arithmetic, in order, with no mix and no clock: what a mix
  * gives for voices contributing these deltas at these weights. Each channel starts at its rest, a
  * weight (default 1, held to 0..1) fades a delta toward rest, and the pose is clamped to each
- * channel's bounds. A channel with no rest takes the last delta whose weight is 0.6 or more, where
- * a mix's default band first switches one on, and stays undefined where none is.
+ * channel's bounds. A channel with no rest takes the last delta a mix's default band switches on, any
+ * weight above 0, and stays undefined where none is.
  *
  * @category channel
  */
@@ -34,7 +33,7 @@ export function fold(kit, deltas, weights) {
                 pose[key] = channel.fold
                     ? channel.fold(pose[key], value, w)
                     : merged(channel, pose[key], channel.scale(value, w));
-            else if (w >= ON)
+            else if (w >= STOCK_BAND.on)
                 pose[key] = pose[key] === undefined ? first(value) : merged(channel, pose[key], value);
         }
     }

package/dist/transport.d.ts

@@ -73,6 +73,11 @@ export declare class Transport implements TransportApi {
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u: number;
     offset: number;
+    /** Where the last seek back left from, so a seek ahead to the same mix time lands on the same host time. */
+    left: {
+        t: number;
+        u: number;
+    } | null;
     /** The mix time of the first sync. */
     born: number;
     /** The earliest mix time what history keeps in memory restores exactly. */

package/dist/transport.js

@@ -45,6 +45,8 @@ export class Transport {
     /** Host time at the last sync: the host's timestamp less every gap `rebase` took out. */
     u = Number.NaN;
     offset = 0;
+    /** Where the last seek back left from, so a seek ahead to the same mix time lands on the same host time. */
+    left = null;
     /** The mix time of the first sync. */
     born = Number.NaN;
     /** The earliest mix time what history keeps in memory restores exactly. */

package/dist/types/mix.d.ts

@@ -17,13 +17,18 @@ export interface MixOptions<H = unknown> {
     /** Merged into every `setting.host`. Its type is the mix's `H`, which every patch and signal it cues reads. */
     host?: H;
     /**
-     * The band a rest-less channel's contribution switches on and off across. It has to clear the frame
-     * noise in a real signal; these are placeholders until the klieg port measures one.
+     * The band a rest-less channel's contribution switches on and off across. Default: on at any weight
+     * above 0, off at 0, so the contribution passes whole while its voice has any weight.
      */
     band?: {
         on: number;
         off: number;
     };
+    /**
+     * Tags that act as loci: a voice carrying one folds with the others carrying it, as if its `locus`
+     * named that tag.
+     */
+    loci?: readonly string[];
     /**
      * The most `dt` a `step` or signal is handed, however long the gap. Off by default, since a
      * patch with a closed form wants the whole gap; an integrator wants this set.

package/dist/types/voice.d.ts

@@ -399,7 +399,8 @@ export interface Handle<I = unknown> {
 }
 /**
  * What `Handle.seek` does with each subject's state: `rebuild` (the default) makes it fresh and
- * steps it to the new position; `keep` leaves it as it was.
+ * steps it to the new position; `keep` leaves it as it was, except for a subject the seek sends back
+ * before its start, which starts afresh there.
  *
  * @category voice
  */

package/docs/schema.html

@@ -295,7 +295,7 @@ type Kit<O> = { readonly [K in keyof O]-?: Channel<NonNullable<O[K]&
 
 <p><b>Color is a value; how it merges is a parameter.</b> A <code>color</code> value is OKLab <code>[L, a, b, coverage]</code>, and <code>oklab(0xrrggbb)</code> makes one at full coverage. <code>color()</code> averages: voices stack as a premultiplied sum, so the pose is <code>[Σw·L, Σw·a, Σw·b, Σw]</code>, which lanes and <code>pull</code> fold as any <code>vec(4, sum())</code>. blits knows no subject's own color, so the host lays the result over its base at write: <code>toHex(pose, under)</code> divides the coverage out, caps it at 1, mixes over <code>under</code> in OKLab and clips to sRGB per channel, and <code>css(pose)</code> writes an <code>oklab()</code> with the coverage as alpha. <code>color(last())</code> replaces, the last voice to pass winning behind the band. <code>mul</code> and <code>max</code> per OKLab axis mean nothing anyone asks for, so <code>color</code> refuses them; a tint, a hue shift, chroma and lightness are channels of their own. OKLab is the store because voices average per axis there, and OKLCH's hue wraps. How two colors interpolate is the channel's choice, <code>{ lerp: 'oklab' | 'oklch' }</code>: OKLab, the default, crosses opposite hues through a pale gray, and OKLCH goes round the hue as <code>mixHex</code> does, at the cost of leaving the lanes.</p>
 
-<p>A channel with no rest cannot fade. The mix handles that in one way: below a weight threshold the contribution is dropped, above it the value passes through whole. That is the rule hinge's blend mode already applies to color, and it is stated here once so no consumer rediscovers it. <b>The threshold is a band, not an edge</b> &mdash; it drops at <code>off</code> and passes at <code>on</code>, and between the two it holds whatever it last did. One edge chatters: a weight resting on it is carried back and forth by frame noise, and every crossing drops or restores the whole contribution. Retargeting is the way a rest-less channel does move smoothly, since a lerp from a sampled value needs no identity.</p>
+<p>A channel with no rest cannot fade. The mix handles that in one way: below a weight threshold the contribution is dropped, above it the value passes through whole. That is the rule hinge's blend mode already applies to color, and it is stated here once so no consumer rediscovers it. <b>The threshold is a band, not an edge</b> &mdash; it drops at <code>off</code> and passes at <code>on</code>, and between the two it holds whatever it last did. One edge chatters: a weight resting on it is carried back and forth by frame noise, and every crossing drops or restores the whole contribution. Retargeting is the way a rest-less channel does move smoothly, since a lerp from a sampled value needs no identity. <b>The stock band is no band</b>: on at any weight above 0 and off at 0, so a fade in shows the value at once and a fade out holds it to its end. The band was meant to be sized from frame noise in klieg's <code>near</code> and <code>dwell</code>, but klieg, its one measured user, set its mix to exactly this to match <code>hinge</code>, so it is the default (2026-10-23); a host whose weight rests near a threshold passes a band of its own.</p>
 
 <p>The stock set is not the limit: a consumer that needs arithmetic it lacks writes its own <code>Channel</code>, and nothing in the mix knows the difference. sherpa's <code>transform</code> is one, composed by the host from whatever it puts in a matrix. A channel whose values are objects can add <code>fold</code>, which writes each contribution into the pose's own value where <code>merge</code> and <code>scale</code> would each make a new one. The mix starts that value as a copy of the channel's <code>rest</code>, and copies an array, a typed array, or a plain object itself; where <code>rest</code> is anything else, such as a class instance, the channel gives <code>copy</code>, or <code>cue</code> refuses a patch that writes it.</p>
 
@@ -554,7 +554,7 @@ interface MixOptions&lt;H = unknown&gt; {
   reduce?: boolean | (() =&gt; boolean);
   <span class="cm">/** Merged into every `setting.host`. `H` types it for every patch and signal the mix cues, so none needs a cast. */</span>
   host?: H;
-  <span class="cm">/** The band a rest-less channel's contribution switches across. Default on at 0.6 and off at 0.4, a placeholder. */</span>
+  <span class="cm">/** The band a rest-less channel's contribution switches across. Default on above 0 and off at 0: no band. */</span>
   band?: { on: number; off: number };
   <span class="cm">/** The most `dt` a step or signal is handed, however long the gap. Off by default. */</span>
   maxDt?: number;
@@ -741,6 +741,7 @@ mix.book({
   <tr><td>Retarget on interruption</td><td><code>from: 'current'</code> on a <code>keys</code> voice takes stop 0 from the subject's pose in the frame before it first contributes &mdash; every other voice folded in, itself excluded &mdash; and lerps from there through the channel's <code>lerp</code>. It also leaves at the velocity the subject had, taken from its last two probed poses: the first segment gains <code>c·u(1−u)²</code>, which is zero at both ends and flat at the end, so the segment's own curve still lands on its stop while the start matches the subject's speed. A subject that was still leaves at rest. With fewer than two poses on record, as on a mix whose host probes into its own object before any retarget is cued, it starts on the segment's own curve.</td><td>wod's base-sampling. New to klieg: a regroup could tween from mid-float instead of carrying it away.</td></tr>
 </table></div>
 
+<p><b>A tag can be a locus.</b> A mix made with <code>loci: ['phase']</code> folds every voice carrying the tag <code>phase</code> as one locus, as if each had <code>locus: 'phase'</code>, so a source that already tags its voices need not name a locus too. A voice whose tags and <code>locus</code> name two loci is refused. Decided 2026-09-29 that tags absorb loci; the declaration was put on the mix (2026-10-23), and <code>locus</code> stays, since klieg, wod, magicsmoke and astv cue with it.</p>
 <p><b>A locus is folded by <code>lerp</code>, not by scaling and merging.</b> Voices sharing a <code>locus</code> are alternatives in time, so the mix combines them into one contribution first: each member weighted by its share of the locus's summed weight, through the channel's own <code>lerp</code>, in cue order. Each channel of that contribution then contributes at <code>min(1, &Sigma;w)</code> over the members that wrote it, and is scaled toward rest like any other: a channel only one member writes fades with that member, rather than holding at the whole locus&rsquo;s weight while it leaves. On a <code>sum</code> channel this is exactly <code>w&#8321;a + w&#8322;b</code>, the arithmetic klieg's timeline already runs, so the cap it was written as is a special case of the fold rather than a rule of its own. On <code>mul</code>, <code>max</code> and <code>last</code> it is the difference between an alternative and a pile-up: two voices halfway through a handover, both holding a gain of 0.06, fold to 0.06 &mdash; which is what one alternative means &mdash; where scaling and merging reads 0.28, the product of two half-scaled copies. A grouped voice may write only channels that have a <code>lerp</code>, which every stock channel does. A stock <code>last()</code> channel has nothing to interpolate, so the locus takes its heaviest member&rsquo;s value, and the later cued of two as heavy. Cue order is otherwise visible only to a <code>lerp</code> that is not linear: a <code>color({ lerp: 'oklch' })</code> or a <code>hex</code> takes the hue the short way round at each step, so three or more of them in a locus can read differently by the order they were cued in.</p>
 
 <div class="callout">
@@ -901,7 +902,7 @@ for (const step of steps) mix.arc({ owner: program, active: stage(step), hold: 4
     </ul>
     Decided 2026-10-06 and 2026-10-07, reversing the 2026-10-01 decision that mix time is only ever a reading. The mix goes back by itself rather than through snapshots the host saves and loads, since a host-kept log of its own calls would be a second record of what the mix did. What happened after <code>t</code> plays again rather than vanishing, because scrubbing must never cut off a recorded future. A call made while rewound branches rather than dropping the old future, and the mix drops its own copies of state after the fork rather than keeping them per branch, so memory stays inside the horizon. History lives only for the session. The mix's own logs hold what happened up to the playhead and the tape holds the calls after it, so nothing is recorded twice and the logs never branch. A recorded call's <code>invert</code> does nothing, since the mix restores rather than undoing; so the mix moves its tape back only with <code>goto</code>, forward one <code>redo</code> at a time, and opens no journals.</li>
   <li><b>How sure.</b> <code>assess</code> says per channel <code>held</code> where a voice feeding it reads input from outside the clock with no recording of it (a signal marked <code>input</code>, a patch that <code>reads</code> host fields, or a <code>from: 'current'</code> start read back with nothing kept), <code>stepped</code> where state crossed a gap in one go without <code>stepMs</code>, or a read back, or a seek back the record goes on from, stepped a stateful signal on from a copy, and <code>exact</code> otherwise; a read ahead reads a stateful signal at every known event, which makes it <code>exact</code>. The least sure voice decides. Under <code>stepMs</code> a read back lands on the pose the mix showed, so a scrub back and forth gives the same picture. A control change the host makes between a sync and the frame's first probe or pull showed in that frame, so a read back shows it there; one made after shows from the next frame.</li>
-  <li><b>A voice's own seek.</b> <code>handle.seek(elapsed)</code> moves one voice's clock, which leaves the state its patch steps and its signals keep belonging to the old position. By default each subject's state is rebuilt: made fresh and stepped from the voice's start to the new position at its next probe, on the <code>stepMs</code> grid where there is one, so under <code>stepMs</code> it lands where a voice cued fresh and played there would. <code>state: 'keep'</code> leaves it as it was. The seek answers how sure the state now is: <code>exact</code> for a voice with no state, or rebuilt under <code>stepMs</code> with no <code>maxDt</code>; <code>stepped</code> where it was caught up in one step, or a signal's kept state was started over; <code>held</code> where it was kept, or depends on host fields or an input weight a rebuild cannot know. A rebuild does not read <code>history</code> yet: starting from a copy kept near the new position would save the stepping, and could make state fed by recorded input exact. Decided and built 2026-10-08.</li>
+  <li><b>A voice's own seek.</b> <code>handle.seek(elapsed)</code> moves one voice's clock, which leaves the state its patch steps and its signals keep belonging to the old position. By default each subject's state is rebuilt: made fresh and stepped from the voice's start to the new position at its next probe, on the <code>stepMs</code> grid where there is one, so under <code>stepMs</code> it lands where a voice cued fresh and played there would. <code>state: 'keep'</code> leaves it as it was, except for a subject sent back before its start, which starts afresh there, since it has run no steps yet. The seek answers how sure the state now is: <code>exact</code> for a voice with no state, or rebuilt under <code>stepMs</code> with no <code>maxDt</code>; <code>stepped</code> where it was caught up in one step, or a signal's kept state was started over; <code>held</code> where it was kept, or depends on host fields or an input weight a rebuild cannot know. A rebuild does not read <code>history</code> yet: starting from a copy kept near the new position would save the stepping, and could make state fed by recorded input exact. Decided and built 2026-10-08.</li>
   <li><b>Cost.</b> A projection copies each subject's record on first probe: about 3&nbsp;ms for 1000 subjects under three voices, three times a live frame (<code>npm run bench</code>, rows <code>ahead</code> and <code>back</code>). That is cheap enough to make one per frame for a continuous scrub. History costs one control entry per handle change and one copy per stateful subject per <code>every</code>, all dropped past the horizon. A seek back puts each stateful record back from the last copy at or before the moment sought, at the subject's next probe, and steps it on from there. A seek lets go of the copies made after the moment it sought, so a mix sought back before every frame would step each subject from the same copy, further each time. The copy a record was put back from therefore keeps its state stepped ahead to near the moment sought, a state per copy a seek has used, moved on once that moment is <code>every</code> past it, and the next record put back from the copy steps on from that state where the steps due run past it. It does so only where the same steps give the same state: under <code>stepMs</code>, with no <code>maxDt</code>, for a patch that <code>reads</code> no host field.</li>
 </ul>
 
@@ -1059,13 +1060,11 @@ export const mixer: Engine;   <span class="cm">// the one that ships</span></cod
 <h2 id="open">Open</h2>
 <ul>
   <li><b>The shared channel list.</b> Channels a second package might write onto another's subject, fixed with a kind, a unit and a rest so that hosts and packages agree past what <code>kind</code> checks. Candidates, names unpicked: <code>opacity</code> mul 0..1; <code>scale</code> mul factor; <code>position</code> vec(3, sum) world units; <code>rotation</code> vec(3, sum) radians; <code>bump</code> vec(2, sum) CSS px, picked on 2026-09-30 over <code>offset</code>, which blits already split into delta and pose; <code>turn</code> sum radians, the flat rotation, counting past 2π so a wheel can spin many times, which is why it blends in a straight line &mdash; an orientation that wraps, where 350° and 10° must meet at 0°, is <code>angle</code>, whose <code>lerp</code> goes the short way round; <code>color</code> as <code>color()</code>, OKLab with coverage. Undecided too: whether wod's radial push takes a shared name, and whether sherpa's <code>clip</code> and wod's <code>aperture</code> are one shared <code>reveal</code>.</li>
-  <li><b>What the score still lacks.</b> The score is built (see Score). Decided 2026-09-29 and not built: <b>tags absorb loci</b>: a tag declared to fold its voices as alternatives does what <code>locus</code> does now; where the declaration lives is not decided.</li>
   <li><b>What spans do not do yet.</b> Hold back part of a budget for children the host knows are coming, short of a strategy of its own; skip a span held by a span; send the events a skipped child would have sent on the way. Found while building them, 2026-10-07.</li>
   <li><b>The package name.</b> Published as <code>@msb235/blits</code> for now, decided 2026-09-30, while npm answers a request for the bare <code>blits</code>, which the registry 404s. Moving to <code>blits</code> later changes every import. <code>@lightningjs/blits</code> is a live TV app framework with its own animation plugin, so searches for the name land there first.</li>
   <li><b>Whether <code>at</code> writes into a buffer: no, it returns.</b> A patch allocates one partial delta per subject per frame, and <code>writes</code> plus the fold order would let the mix hand it one scratch object instead. The port measured what that would buy: a frame of klieg&rsquo;s motion — 12 letters through four voices — costs 0.017&nbsp;ms, and a frame of its effects — 60 parts under three effects — costs 0.134&nbsp;ms, against a 16.7&nbsp;ms budget. Under 1% of a frame is not worth the nicest property <code>at</code> has, which is being a pure function a test calls once. The p99 of the effects frame is 1.3&nbsp;ms, which is the collector catching up on exactly these allocations, so a subject count an order of magnitude past klieg&rsquo;s would reopen it. <code>packages/core/test/bench/frame-cost.bench.ts</code> in klieg is the measurement</li>
   <li><b>A subject brought back, read back to while it was out.</b> Under <code>history</code> a voice keeps the record a subject left with, faded out or dropped, and a motion patch keeps its stretches, so a <code>seek</code> or <code>project</code> back to before it left finds both (built 2026-10-07). Untested: a read back to a moment between the subject leaving and a motion's <code>to</code> bringing it back, which may read it as never having left. Found 2026-10-02 while building subject fades.</li>
   <li><b>Layered subjects.</b> A lamp that is part of a cell and also reached on its own, as a sparkle on one bulb of a chase, is its own subject and folds every voice of the cell again. Starting its fold from the cell's pose and adding only the voices that reach the lamp would save that, and only the mix knows which voices reach what. Unbuilt until a host needs it; the saving matters at thousands of subjects (<code>named N=10000 V=1</code> is 1.592&nbsp;ms a frame on teitou, 2026-10-21). Raised 2026-10-22.</li>
-  <li><b>The stock band's width.</b> Whether <code>gate</code>'s default band is symmetric around <code>at</code> and how wide it is. It has to clear the frame noise in a real signal, so it is a measurement from klieg's <code>near</code> and <code>dwell</code>, not a guess.</li>
 </ul>
 </main>
 </div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",