@msb235/blits 0.10.0 → 0.12.0

package/dist/chain.d.ts

@@ -8,16 +8,32 @@ import type { Subject, Voice } from './voice.js';
  */
 export declare function chain<I, O>(this: Mixer<I, O>, subject: I): Subject<unknown>;
 export declare function relink<I, O>(this: Mixer<I, O>, subject: I, was: Subject<unknown> | undefined): Subject<unknown>;
+/**
+ * The subject's chain as last linked; undefined where it has none, as for a chain a seek kept only
+ * for its number and not linked since, whose records are those from before the seek.
+ */
+export declare function headOf<I, O>(mix: Mixer<I, O>, subject: I): Subject<unknown> | undefined;
 /** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
-export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number): Subject<unknown> | null;
+export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, slot: number, guess?: Subject<unknown> | null): Subject<unknown> | null;
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
 export declare function aims<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): boolean;
+/**
+ * The record a voice has of a subject now, as a seek or a read back to mix time `now` and frame
+ * `seq` takes it: none where it says only that the voice does not reach a subject it reached
+ * then, before the subject faded out of it. The subject had no record then, and is met afresh.
+ */
+export declare function heldAt<I, O>(voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined, now: number, seq: number): Subject<unknown> | undefined;
 /**
  * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
  * are relinked, every subject's for a voice over all of them and only its own for one naming
  * its subjects, and lanes take it on or off.
  */
 export declare function changed<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Makes one subject's chain stale, to be linked again at its next read, and counts it in `relinks`,
+ * which its number is stamped with for `pull`.
+ */
+export declare function unlink<I, O>(mix: Mixer<I, O>, head: Subject<unknown>): void;
 /** Files a voice under each subject it names, or among the voices that name none. */
 export declare function index<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
 export declare function unindex<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;

package/dist/chain.js

@@ -16,30 +16,46 @@ export function chain(subject) {
 }
 // Apart from `chain`, which stays small enough for V8 to inline where a probe links.
 export function relink(subject, was) {
-    const slot = was !== undefined ? was.slot : this.lanes !== null ? this.lanes.number(subject) : -1;
+    const lanes = this.lanes;
+    const slot = was !== undefined ? was.slot : lanes !== null ? lanes.number(subject) : -1;
+    // A chain a seek kept for its number alone links afresh, as a subject first seen does.
+    const sought = was !== undefined && slot >= 0 && lanes?.renew(slot) === true;
     // Where only voices over every subject changed since, those alone are taken off or put on.
-    let first = was === undefined
+    let first = was === undefined || sought
         ? undefined
         : this.steps.patch(was.voice === null ? null : was, was.version, this, subject, slot);
     if (first === undefined)
-        first = linkAll(this, subject, slot);
+        first = linkAll(this, subject, slot, was ?? null);
     const head = first ?? stub();
     head.version = this.version;
     if (was !== undefined && was !== head) {
-        head.loci = was.loci;
+        if (!sought)
+            head.loci = was.loci;
         was.loci = null;
-        head.slot = was.slot;
         was.slot = -1;
     }
-    else if (was === undefined)
-        head.slot = slot;
+    head.slot = slot;
     if (was !== head)
         this.chains.set(subject, head);
     return head;
 }
-/** A subject's chain linked afresh through every voice that reaches it, in voice order. */
-function linkAll(mix, subject, slot) {
+/**
+ * The subject's chain as last linked; undefined where it has none, as for a chain a seek kept only
+ * for its number and not linked since, whose records are those from before the seek.
+ */
+export function headOf(mix, subject) {
+    const head = mix.chains.get(subject);
+    return head !== undefined && head.slot >= 0 && mix.lanes?.sought(head.slot) === true
+        ? undefined
+        : head;
+}
+/**
+ * A subject's chain linked afresh through every voice that reaches it, in voice order; `was` is its
+ * chain as last linked, whose records each voice's store is asked whether it still holds.
+ */
+function linkAll(mix, subject, slot, was) {
     let first = null;
+    let old = was;
     let prev = null;
     const named = mix.naming === 0 ? undefined : mix.named.get(subject);
     let j = 0;
@@ -54,7 +70,11 @@ function linkAll(mix, subject, slot) {
                 break;
             if (next === mine)
                 j++;
-            const held = mix.linkable(next, subject, slot);
+            // Taken before linking, which writes over `next`.
+            const guess = old !== null && old.voice === next ? old : null;
+            if (guess !== null)
+                old = guess.next;
+            const held = mix.linkable(next, subject, slot, guess);
             if (held !== null) {
                 held.voice = next;
                 held.next = null;
@@ -71,7 +91,7 @@ function linkAll(mix, subject, slot) {
     return first;
 }
 /** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
-export function linkable(voice, subject, slot) {
+export function linkable(voice, subject, slot, guess = null) {
     const state = voice.state;
     if (state === 'done' || (state === 'pending' && !voice.freezesBefore))
         return null;
@@ -82,19 +102,31 @@ export function linkable(voice, subject, slot) {
             sight(voice, slot, this.lanes.cap);
         return null;
     }
-    const held = this.held(voice, subject, slot);
+    const held = this.held(voice, subject, slot, guess);
     return held.reaches ? held : null;
 }
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
 export function aims(voice, subject) {
+    return aimsAt(voice, subject, this.now);
+}
+/** As `aims` at mix time `now`, counting a subject as faded out only by frame `seq`. */
+function aimsAt(voice, subject, now, seq = Number.POSITIVE_INFINITY) {
     // A read back to before a subject left still finds it reached.
     const left = voice.parted?.get(subject);
-    if (left !== undefined && !(this.now < left.at))
+    if (left !== undefined && !(now < left.at) && left.seq <= seq)
         return false;
     if (voice.named !== null)
         return voice.named.has(subject);
     return voice.spec.target ? voice.spec.target(subject) : true;
 }
+/**
+ * The record a voice has of a subject now, as a seek or a read back to mix time `now` and frame
+ * `seq` takes it: none where it says only that the voice does not reach a subject it reached
+ * then, before the subject faded out of it. The subject had no record then, and is met afresh.
+ */
+export function heldAt(voice, subject, held, now, seq) {
+    return held !== undefined && !held.reaches && aimsAt(voice, subject, now, seq) ? undefined : held;
+}
 /**
  * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
  * are relinked, every subject's for a voice over all of them and only its own for one naming
@@ -112,12 +144,22 @@ export function changed(mix, voice) {
         return;
     }
     for (const subject of voice.named) {
-        const head = mix.chains.get(subject);
+        const head = headOf(mix, subject);
         if (head !== undefined)
-            head.version = Number.NaN;
+            unlink(mix, head);
     }
     mix.relinks++;
 }
+/**
+ * Makes one subject's chain stale, to be linked again at its next read, and counts it in `relinks`,
+ * which its number is stamped with for `pull`.
+ */
+export function unlink(mix, head) {
+    head.version = Number.NaN;
+    const at = ++mix.relinks;
+    if (head.slot >= 0 && mix.lanes !== null)
+        mix.lanes.unlinked[head.slot] = at;
+}
 /** Files a voice under each subject it names, or among the voices that name none. */
 export function index(mix, voice) {
     if (voice.holding !== null)

package/dist/channels.d.ts

@@ -38,6 +38,8 @@ export declare function axesOf(channel: Channel<unknown>): number;
  * `'own'` channel, and an angle's `v` is taken the short way round first.
  */
 export declare function foldNumber(op: Numeric['op'], acc: number, v: number, w: number): number;
+/** The arithmetic `foldNumber` can apply for a channel in place of its `scale` and `merge`, if any. */
+export declare function scalarOp(channel: Channel<unknown>): 'sum' | 'mul' | 'max' | undefined;
 /**
  * What a stock numeric channel takes.
  *

package/dist/channels.js

@@ -49,7 +49,18 @@ export function foldNumber(op, acc, v, w) {
         return product(acc, toward(v, w));
     if (op === 'max')
         return larger(acc, times(v, w));
-    return v;
+    // A double on every branch: where `v` arrives untyped, a branch returning it as it came makes V8
+    // box each other branch's result to merge them, 16 bytes a fold (bench/allocs.mjs, 2026-10-20).
+    return +v;
+}
+/** The arithmetic `foldNumber` can apply for a channel in place of its `scale` and `merge`, if any. */
+export function scalarOp(channel) {
+    const n = numericOf(channel);
+    if (n === undefined || n.axes !== 1 || n.turn !== undefined || channel.fold !== undefined)
+        return undefined;
+    if (typeof channel.rest !== 'number')
+        return undefined;
+    return n.op === 'sum' || n.op === 'mul' || n.op === 'max' ? n.op : undefined;
 }
 /** Bounds change how a value folds at its edges, so they are part of the kind. */
 const kindOf = (name, bounds) => bounds === undefined ? name : `${name}[${bounds[0]}, ${bounds[1]}]`;

package/dist/clock.d.ts

@@ -88,3 +88,17 @@ export declare function rebaseWith(c: Clock, now: number): void;
  * has then, so what it reads stays continuous and so does its speed.
  */
 export declare function retime(c: Clock, now: number, rate: number, over: number): void;
+/**
+ * The fixed interval a voice's `step` runs at: its own `stepMs`, else the mix's. Undefined where
+ * it steps once a frame by the frame's gap, as every voice does under reduced motion.
+ */
+export declare function stepOf(mix: {
+    readonly opts: {
+        readonly stepMs?: number;
+    };
+    readonly reducedNow: boolean;
+}, voice: {
+    readonly spec: {
+        readonly stepMs?: number;
+    };
+}): number | undefined;

package/dist/clock.js

@@ -1,6 +1,6 @@
 /** How many passes a voice's `loop` plays. */
 export function passesOf(loop) {
-    const l = loop ?? true;
+    const l = loop ?? false;
     return l === true ? Number.POSITIVE_INFINITY : l === false ? 1 : l;
 }
 /** Whether `elapsed` voice ms is past the last of `passes` passes of a patch of `duration` ms. */
@@ -177,3 +177,11 @@ export function retime(c, now, rate, over) {
     c.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
     c.rate = rate;
 }
+/**
+ * The fixed interval a voice's `step` runs at: its own `stepMs`, else the mix's. Undefined where
+ * it steps once a frame by the frame's gap, as every voice does under reduced motion.
+ */
+export function stepOf(mix, voice) {
+    const tick = voice.spec.stepMs ?? mix.opts.stepMs;
+    return tick !== undefined && tick > 0 && !mix.reducedNow ? tick : undefined;
+}

package/dist/clone.js

@@ -6,19 +6,31 @@ const slow = Symbol('slow');
  */
 export function clone(v) {
     const quick = copied(v, 2);
-    met.length = 0;
+    for (let i = 0; i < metCount; i++)
+        met[i] = undefined;
+    metCount = 0;
     return quick === slow ? structuredClone(v) : quick;
 }
-/** The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. */
+/**
+ * The objects one `clone` has met: one met twice is shared, which `structuredClone` keeps. Cleared
+ * by hand, as `length = 0` frees the array's storage and the next push allocates it again.
+ */
 const met = [];
+let metCount = 0;
+function hasMet(v) {
+    for (let i = 0; i < metCount; i++)
+        if (met[i] === v)
+            return true;
+    return false;
+}
 function copied(v, depth) {
     if (typeof v === 'symbol' || typeof v === 'function')
         return slow;
     if (typeof v !== 'object' || v === null)
         return v;
-    if (depth === 0 || met.includes(v))
+    if (depth === 0 || hasMet(v))
         return slow;
-    met.push(v);
+    met[metCount++] = v;
     if (Array.isArray(v)) {
         if (Object.getPrototypeOf(v) !== Array.prototype)
             return slow;

package/dist/columns.d.ts

@@ -12,13 +12,12 @@ export interface Column {
 export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
- * `heads` holds each position's remembered chain head unless all are known current: what
+ * each position's remembered chain head was current when the mix's `relinks` read `since`: what
  * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
- * from the lanes; returns the first position that does not, or the list's length.
+ * from the lanes and its head has not been made stale since; returns the first position that does
+ * not, or the list's length.
  */
-export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, list: readonly I[], was: readonly I[], heads: readonly ({
-    version: number;
-} | undefined)[] | null, from: number, columns: readonly Column[], now: number, version: number): number;
+export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, list: readonly I[], was: readonly I[], since: number, from: number, columns: readonly Column[], now: number, version: number): number;
 /**
  * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
  * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A

package/dist/columns.js

@@ -6,11 +6,12 @@ export function clampRun(out, at, n, [lo, hi]) {
 }
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
- * `heads` holds each position's remembered chain head unless all are known current: what
+ * each position's remembered chain head was current when the mix's `relinks` read `since`: what
  * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
- * from the lanes; returns the first position that does not, or the list's length.
+ * from the lanes and its head has not been made stale since; returns the first position that does
+ * not, or the list's length.
  */
-export function pullRun(lanes, slots, list, was, heads, from, columns, now, version) {
+export function pullRun(lanes, slots, list, was, since, from, columns, now, version) {
     const ready = lanes.filled(now, version) ? 1 /* Begin.READY */ : lanes.begin(now, version);
     if (ready !== 1 /* Begin.READY */ || !lanes.whole)
         return from;
@@ -20,6 +21,8 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
     const wide = lanes.wide;
     const frame = lanes.frameProbes;
     const subjects = lanes.subjects;
+    const unlinked = lanes.unlinked;
+    const current = since === Number.POSITIVE_INFINITY;
     if (columns !== lanes.queuedFor) {
         flush(lanes);
         lanes.queuedFor = columns;
@@ -35,11 +38,12 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
     let start = from;
     for (; n < list.length; n++) {
         const subject = list[n];
-        if (was[n] !== subject || (heads !== null && heads[n]?.version !== version))
+        if (was[n] !== subject)
             break;
         const slot = slots[n];
         const o = slot * 6 /* Per.SLOT */;
         if (slot < 0 ||
+            (!current && !(unlinked[slot] <= since)) ||
             per[o + 0 /* Per.FILLED */] >= busy ||
             per[o + 2 /* Per.IDLE */] !== 0 ||
             per[o + 1 /* Per.SEEN */] < wide ||
@@ -163,6 +167,8 @@ function rests(lanes, c, runs) {
                 out[i + a] = c.rest[a];
     }
 }
+/** The longest run of values `copies` copies itself: `set` takes a view, an object a run. */
+const VIEWED = 256;
 /** Copies a laned channel's values for every queued run into its rows. */
 function copies(lanes, c, values, runs) {
     const slots = lanes.queueSlots;
@@ -174,7 +180,7 @@ function copies(lanes, c, values, runs) {
         const at = rows[r] * axes;
         const base = slots[r] * axes;
         const span = counts[r] * axes;
-        if (span > 64)
+        if (span > VIEWED)
             out.set(values.subarray(base, base + span), at);
         else
             for (let i = 0; i < span; i++)

package/dist/crowd.d.ts

@@ -47,7 +47,7 @@ export declare const enum Flag {
     VOICE = 64,
     /** The row's voice is a motion voice; otherwise its patch is keys or a stateless fn. */
     MOTION = 128,
-    /** The voice freezes before or after, so its clock is read from the voice. */
+    /** The voice freezes, or may run back past its end, so its clock is read from the voice. */
     FREEZES = 256,
     /** A keys row whose stops `keys` holds, at `Hot.AT`, with its duration at `Hot.X0` and passes at `Hot.MS`. */
     FLAT = 512,

package/dist/crowd.js

@@ -317,7 +317,10 @@ function copyVoice(c, p) {
     let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.FREEZES */);
     if (v.state === 'live' || v.state === 'frozen' || v.state === 'fading')
         f |= 1 /* Flag.PLAYING */;
-    if (v.freezesBefore || v.freezesAfter)
+    // A keys or fn voice an owner holds can turn back with the owner, which copies it no more.
+    if (v.freezesBefore ||
+        v.freezesAfter ||
+        (v.motion === undefined && (v.owner !== null || v.hidesPast)))
         f |= 256 /* Flag.FREEZES */;
     if (v.ramp === null &&
         v.owner === null &&

package/dist/cue.js

@@ -1,3 +1,4 @@
+import { blendOf } from './blend.js';
 import { checkHits } from './book.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
@@ -6,14 +7,15 @@ import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
+import { checkMarks } from './marks.js';
 import { motionOf } from './motion.js';
-import { adopt, ownerPatch, ownerReading } from './owner.js';
+import { adopt, Holding, ownerPatch, ownerReading } from './owner.js';
 import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
 import { enlist } from './roster.js';
 import { scoredAdd } from './scored.js';
 import { checkChild, refit } from './spans.js';
-import { motionOwner } from './strays.js';
-import { record } from './tape.js';
+import { cuedById, motionOwner } from './strays.js';
+import { record, unplayable } from './tape.js';
 import { Voice } from './voice.js';
 export function cue(mix, spec) {
     const patch = spec.patch;
@@ -28,6 +30,8 @@ export function cue(mix, spec) {
         checkPlacement(mix, spec, anchor, owner);
     if (spec.hits !== undefined)
         checkHits(spec.hits, patch.duration);
+    if (spec.marks !== undefined)
+        checkMarks(spec.marks, patch.duration);
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
     // A voice an owner holds is placed on the owner's clock: ms from when it starts.
     const local = owner === null ? mix.now : ownerReading(owner, mix.now);
@@ -40,9 +44,13 @@ export function cue(mix, spec) {
                 : Number.isNaN(mix.now)
                     ? 0
                     : mix.now;
-    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? {}, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
+    const voice = new Voice(mix.nextId++, spec, patch, spec.fade ?? noFade, local, start, mix.slotOf, mix.channels, mix.opts.host, mix.send, owner);
     if (patch === ownerPatch && mix.fitting !== null)
         voice.fitting = mix.fitting;
+    if (patch === ownerPatch && mix.arcing !== null) {
+        voice.arc = mix.arcing;
+        voice.hold = mix.arcing.hold;
+    }
     if (owner?.fitting)
         checkChild(spec, voice);
     if (mix.pace !== null && owner === null && spec.start !== undefined && voice.state === 'pending')
@@ -50,10 +58,22 @@ export function cue(mix, spec) {
     enter(mix, voice);
     const h = handle(mix, voice);
     voice.handle = h;
-    // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
-    record(mix, 'cue', () => recue(mix, VoiceHandle.voiceOf(h) ?? lost(h)));
+    recordCue(mix, h);
     return h;
 }
+const noFade = Object.freeze({});
+// Apart from `cue`, whose body would otherwise make this closure's context on every call.
+function recordCue(mix, h) {
+    // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
+    record(mix, 'cue', (stage) => {
+        const parked = VoiceHandle.voiceOf(h) ?? lost(h);
+        const to = stage.mix(mix);
+        if (to === mix)
+            recue(mix, parked);
+        else if (to !== undefined)
+            recue(to, aheadOf(to, parked));
+    });
+}
 /** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
 export function fitsKit(patch, kit) {
     for (const channel of patch.writes) {
@@ -78,6 +98,10 @@ export function playable(mix, spec) {
         finiteRate(spec.rate);
     if (spec.seek !== undefined && !Number.isFinite(spec.seek))
         throw new RangeError(`blits: a voice's seek is a finite number of ms, not ${spec.seek}`);
+    if (spec.stepMs !== undefined && !(spec.stepMs >= 0 && spec.stepMs < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: a voice's stepMs is a finite number of ms, 0 or more, not ${spec.stepMs}`);
+    if (spec.catchUp !== undefined && spec.catchUp !== 'exact' && spec.catchUp !== 'fresh')
+        throw new RangeError(`blits: catchUp takes 'exact' or 'fresh', not ${String(spec.catchUp)}`);
     if (typeof spec.weight === 'number')
         plainWeight(spec.weight);
     fitsKit(patch, mix.kit);
@@ -110,6 +134,36 @@ function recue(mix, voice) {
         voice.state = 'live';
     enter(mix, voice);
 }
+/** Each read ahead's own blends, by the live blend its copies' members were cued in. */
+const blends = new WeakMap();
+/** A read ahead's copy of a voice a seek parked, as its cue left it, for the copy `to` to cue. */
+function aheadOf(to, parked) {
+    const copy = parked.copy(() => undefined);
+    if (parked.owner !== null) {
+        const owner = cuedById(to, parked.owner.id);
+        if (owner === undefined || owner.holding === null)
+            unplayable('a cue under an owner that has left');
+        copy.owner = owner;
+    }
+    if (copy.holding !== null)
+        copy.holding = new Holding();
+    if (copy.blend !== null) {
+        let own = blends.get(to);
+        if (own === undefined) {
+            own = new Map();
+            blends.set(to, own);
+        }
+        const live = copy.blend.of;
+        let of = own.get(live);
+        if (of === undefined) {
+            of = blendOf(copy.blend.of.by, copy.blend.of.stops);
+            own.set(live, of);
+        }
+        copy.blend = { of, i: copy.blend.i };
+        of.members.push(copy);
+    }
+    return copy;
+}
 function lost(h) {
     throw new Error(`blits: voice ${h.id} is paged out, and the seek that plays its cue again did not load it`);
 }
@@ -120,6 +174,7 @@ function enter(mix, voice) {
     const anchor = spec.anchor;
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
     const motion = voice.motion;
+    voice.parked = false;
     if (owner !== null)
         adopt(owner, voice);
     if (!Number.isNaN(mix.now)) {
@@ -131,7 +186,8 @@ function enter(mix, voice) {
     // A start the host gave by its own clock, where the mix's rate puts it.
     if (!Number.isNaN(voice.pinned) && voice.state === 'pending')
         pin(mix, voice, voice.pinned);
-    if (motion !== undefined) {
+    // A read ahead's copy leaves the patch asking the live mix for its time.
+    if (motion !== undefined && !mix.projecting) {
         mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
         mix.owner ??= motionOwner(new WeakRef(mix));
         motion.owner = mix.owner;

package/dist/departed.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Mark, Query } from './types.js';
+import type { MarkName, Query } from './types.js';
 import { type Voice } from './voice.js';
 /**
  * What a mix keeps of a voice it has forgotten, on leaving without history or past history's reach:
@@ -14,7 +14,8 @@ export interface Departed {
     readonly name: string | undefined;
     readonly tags: readonly string[];
     readonly writes: readonly unknown[];
-    readonly marks: Readonly<Record<Mark, number | undefined>>;
+    /** Its five, and those it placed inside itself. */
+    readonly marks: Readonly<Partial<Record<MarkName, number>>>;
     /** How many of the index's ends hold it. */
     held: number;
 }
@@ -23,11 +24,15 @@ export interface Departed {
  * owner, the first and the last to leave. It grows with those, never with how many voices left.
  */
 export declare class DepartedIndex {
-    private readonly ends;
+    private readonly scopes;
     readonly all: Set<Departed>;
     add<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
     /** Lets go of the voices an owner that has left held: nothing can be cued beside them again. */
     dropOwner(owner: number): void;
+    private scopeOf;
+    private keep;
+    private hold;
+    private forget;
     private release;
 }
 /** Whether a departed voice answers `q`, asked by a voice of `owner` (-1 for none) on `score`. */