@msb235/blits 0.10.0 → 0.12.0

package/dist/mixer.js

@@ -1,13 +1,14 @@
+import { cueArc } from './arcs.js';
 import { blended, blendOf, laneRead, shareKept } from './blend.js';
-import { aims, chain, linkable, relink } from './chain.js';
-import { lerpInto } from './channels.js';
+import { aims, chain, headOf, linkable, relink, unlink } from './chain.js';
+import { lerpInto, scalarOp } from './channels.js';
 import { cue } from './cue.js';
 import { DepartedIndex } from './departed.js';
-import { beginFade, leftWith, parting } from './fade.js';
+import { beginFade, leaveVoice, parting } from './fade.js';
 import { apply, baseFor, clamp, contribution, fold, foldDetour, folded, foldLoci, foldSharers, foldWith, isRest, keyed, linked, near, owedBy, passes, read, shared, 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 { releasing } from './history.js';
 import { book, laneHost } from './hosts.js';
 import { Lanes } from './lanes.js';
 import { foldLocus } from './locus.js';
@@ -22,11 +23,12 @@ 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';
-import { record } from './tape.js';
+import { Masked, Store } from './store.js';
+import { record, unplayable } from './tape.js';
 import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.js';
+import { gave, historyFor, register } from './watch.js';
 import { base, capped, fadeOf, horizonFor, ownedBy, ownerBase, prime, weigh, weighOwned, } from './weigh.js';
 /**
  * What a mix takes where its options say nothing. Not exported from the package: the suite turns
@@ -37,6 +39,7 @@ export const defaults = { lanes: true };
 export class Mixer {
     kit;
     opts;
+    lanesOf;
     cued = [];
     /** Under `history`, voices that have left but that a read back may still reach. */
     gone = [];
@@ -87,10 +90,15 @@ export class Mixer {
     /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     pulled = [];
     pulledHeads = [];
-    /** Each remembered head's lane slot, and the `version` and `relinks` they were all current at. */
+    /**
+     * Each remembered head's lane slot, -1 at a position with none, and the `version` and `relinks`
+     * they were all current at.
+     */
     pulledSlots = new Int32Array(0);
     pulledVersion = Number.NaN;
     pulledRelinks = -1;
+    /** What `pull` knows of each channel it has written, by name; none until the first pull. */
+    pullColumns = null;
     /** Counts chains made stale one subject at a time, which `version` does not. */
     relinks = 0;
     /** Read once a sync, so a `reduce` function is not called per voice per subject. */
@@ -136,6 +144,8 @@ export class Mixer {
      */
     chains = new Store();
     version = 0;
+    /** What `prime` reads its clock, voice time and pass from: see `Primed`. */
+    primed = new Float64Array(3 /* Primed.SIZE */);
     steps = new Steps();
     /** Per subject, the voices whose `subjects` name it, in voice order. */
     named = new Store();
@@ -199,6 +209,8 @@ export class Mixer {
     bounded;
     /** By slot, a stock array channel's in-place `lerp`. */
     lerpsInto;
+    /** By slot, a stock scalar channel's arithmetic, which a fold applies without calling the channel. */
+    scalars;
     /** What a fold with a locus in play gathers into, one per depth of folds under way. */
     locusScratch = [];
     locusDepth = 0;
@@ -209,23 +221,32 @@ export class Mixer {
     bookers = null;
     /** The fit a span being cued takes, which `cue` hands its voice. */
     fitting = null;
+    /** What an arc being cued keeps, which `cue` hands its voice. */
+    arcing = null;
     /** Every owner still in the mix, null until one is cued. */
     owners = null;
     /** With a history store, the key each subject is paged under; null without one. */
     keys = null;
     /** With a history store, the voices it paged out whose handles are still held; null without one. */
     outs = null;
-    constructor(kit, opts) {
+    constructor(kit, opts, 
+    /** The lanes an entry was built with; null in one that leaves them out. */
+    lanesOf) {
         this.kit = kit;
         this.opts = opts;
+        this.lanesOf = lanesOf;
         this.names = Object.keys(kit);
         this.channels = this.names.map((k) => kit[k]);
         this.bounded = this.channels.flatMap((c, i) => (c.bounds ? [i] : []));
         this.lerpsInto = this.channels.map((c) => lerpInto(c));
+        this.scalars = this.channels.map((c) => scalarOp(c));
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = (opts.lanes ?? defaults.lanes) ? new Lanes(laneHost(this)) : null;
+        if (lanesOf === null && opts.lanes === true)
+            throw new Error("blits: '@msb235/blits/lean' has no lanes; take mix from '@msb235/blits'");
+        this.lanes =
+            lanesOf !== null && (opts.lanes ?? defaults.lanes) ? new lanesOf(laneHost(this)) : null;
         this.name = opts.name;
         const shared = opts.transport;
         if (shared !== undefined) {
@@ -290,6 +311,9 @@ export class Mixer {
     get timestamp() {
         return this.transport.last;
     }
+    get seq() {
+        return this.transport.seq;
+    }
     get last() {
         return this.transport.last;
     }
@@ -308,16 +332,31 @@ export class Mixer {
     }
     cue(spec) {
         this.attached();
-        const engine = this.opts.engine ?? mixer;
-        if (!engine.runs.has(spec.patch.form))
+        const engine = this.opts.engine;
+        if (engine !== undefined && !engine.runs.has(spec.patch.form))
             throw new Error(`blits: engine ${engine.name} does not run ${spec.patch.form} patches`);
         return cue(this, spec);
     }
-    blend(patches, by, spec = {}) {
+    blend(members, by, spec = {}) {
         const locus = `blend:${this.nextId}`;
-        const of = blendOf(by, patches.length - 1);
-        return patches.map((patch, i) => {
-            const handle = this.cue({ ...spec, patch, weight: by, locus });
+        const of = blendOf(by, members.length - 1);
+        return members.map((member, i) => {
+            const own = {
+                ...spec,
+                patch: member,
+                weight: by,
+                locus,
+            };
+            if ('patch' in member) {
+                own.patch = member.patch;
+                if (member.name !== undefined)
+                    own.name = member.name;
+                if (member.tags !== undefined)
+                    own.tags = member.tags;
+                if (member.hits !== undefined)
+                    own.hits = member.hits;
+            }
+            const handle = this.cue(own);
             const voice = this.cued[this.cued.length - 1];
             voice.blend = { of, i };
             of.members.push(voice);
@@ -330,6 +369,8 @@ export class Mixer {
         return this.cue({ ...spec, patch: ownerPatch });
     }
     span(spec) {
+        if ((spec.rate ?? 1) < 0)
+            throw new Error('blits: a span lays out its children forward from its start, so it is not cued backward');
         this.fitting = new Fitting(spec);
         try {
             const handle = this.owns(spec);
@@ -340,6 +381,9 @@ export class Mixer {
             this.fitting = null;
         }
     }
+    arc(spec) {
+        return cueArc(this, spec);
+    }
     sync(timestamp) {
         this.own('sync').sync(timestamp);
     }
@@ -359,16 +403,16 @@ export class Mixer {
         this.looked = true;
         pull(this, subjects, into);
     }
-    seek(time) {
+    seek(to) {
         if (this.projecting)
             throw new Error('blits: a projection does not seek');
-        seek(this.own('seek'), time);
+        seek(this.own('seek'), to);
     }
     prepare(time) {
         return this.own('prepare').prepare(time);
     }
-    project(time) {
-        return projectAll(this.transport, time).of(this);
+    project(at) {
+        return projectAll(this.transport, at).of(this);
     }
     announce(name, opts = {}) {
         this.attached();
@@ -469,18 +513,21 @@ export class Mixer {
             voice.written = true;
             beginFade(this, voice, { over: opts?.over });
         }
-        record(this, 'mute', () => this.mute(opts));
+        record(this, 'mute', (stage) => stage.mix(this)?.mute(opts));
     }
     drop(subject) {
         this.frame = nextFrame();
-        const head = this.chains.get(subject);
+        const head = headOf(this, subject);
         // Nothing that kept this head, such as `pull`'s remembered list, may take it as current again.
-        if (head !== undefined) {
-            head.version = Number.NaN;
-            this.relinks++;
-        }
-        if (head !== undefined && head.slot >= 0 && this.lanes !== null)
-            this.lanes.release(head.slot);
+        if (head !== undefined)
+            unlink(this, head);
+        // A number a seek carried over is released even where its chain is not linked since.
+        const slot = this.chains.get(subject)?.slot ?? -1;
+        if (slot >= 0 && this.lanes !== null)
+            this.lanes.release(slot);
+        // A read ahead's copy reads the live mix's poses, and so hides one where the mix deletes it.
+        if (this.projecting && !(this.pose instanceof Masked))
+            this.pose = new Masked(this.pose);
         this.pose.delete(subject);
         this.restStamps?.delete(subject);
         this.chains.delete(subject);
@@ -488,32 +535,24 @@ export class Mixer {
         // A record of it is only in a voice over every subject, one naming it, or one gone; a ramp out
         // of a voice that does not name it is in `parters`, and a patch's own state in `motions`.
         const kept = releasing(this);
-        const forget = (voice) => {
-            leave(this, voice, subject, leftWith(this, voice, subject));
-            voice.subjects.delete(subject);
-            voice.motion?.release(subject, ...kept);
-            voice.parts?.delete(subject);
-            voice.parted?.delete(subject);
-            voice.blend?.of.reads.delete(subject);
-        };
         for (const voice of this.general)
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
         const named = this.named.get(subject);
         if (named !== undefined)
             for (const voice of [...named])
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         const gone = goneIndex(this);
         for (const voice of gone.general)
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
         const goneNaming = gone.named.get(subject);
         if (goneNaming !== undefined)
             for (const voice of goneNaming)
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         if (this.owners !== null)
             for (const voice of this.owners)
-                forget(voice);
+                this.forgetIn(voice, subject, kept);
         for (const voice of this.parters) {
-            forget(voice);
+            this.forgetIn(voice, subject, kept);
             if (voice.parts?.size === 0)
                 voice.parts = null;
             if (voice.parted?.size === 0)
@@ -524,11 +563,31 @@ export class Mixer {
         const strays = this.strays.get(subject);
         if (strays !== undefined)
             for (const motion of strays)
-                motion.release(subject, ...kept);
+                this.releaseIn(motion, subject, kept);
         this.strays.delete(subject);
         for (const motion of this.strayAll)
-            motion.release(subject, ...kept);
-        record(this, 'drop', () => this.drop(subject));
+            this.releaseIn(motion, subject, kept);
+        this.recordDrop(subject);
+    }
+    /** Lets `voice` go of a dropped subject. Methods rather than closures, so a drop makes neither. */
+    forgetIn(voice, subject, kept) {
+        leaveVoice(this, voice, subject);
+        voice.subjects.delete(subject);
+        if (voice.motion !== undefined)
+            this.releaseIn(voice.motion, subject, kept);
+        voice.parts?.delete(subject);
+        voice.parted?.delete(subject);
+        voice.blend?.of.reads.delete(subject);
+    }
+    // A motion patch's state is the live mix's alone: a read ahead cannot start a subject afresh in it.
+    releaseIn(motion, subject, kept) {
+        if (!this.projecting)
+            motion.release(subject, kept[0], kept[1], kept[2]);
+        else if (motion.holds(subject))
+            unplayable('a drop of a subject a motion patch holds');
+    }
+    recordDrop(subject) {
+        record(this, 'drop', (stage) => stage.mix(this)?.drop(subject));
     }
     touch(subject) {
         this.attached();
@@ -639,6 +698,15 @@ function named(transport, name) {
     if (taken.some((m) => m.name === name))
         throw new Error(`blits: a mix named ${name} is already on this transport, or a seek could bring it back`);
 }
+/** Makes a mix the host asked for, with the registry's history where it names none, and lists it there. */
+export function made(kit, opts, lanes) {
+    const { history, added } = historyFor(opts);
+    const m = new Mixer(kit, added ? { ...opts, history } : opts, lanes);
+    if (added)
+        gave(m.transport);
+    register(m);
+    return m;
+}
 /**
  * The one that ships: every form on the CPU, probed per subject on demand.
  *
@@ -648,7 +716,7 @@ export const mixer = {
     name: 'mixer',
     runs: new Set(['fn', 'keys', 'motion']),
     create(kit, opts) {
-        return new Mixer(kit, opts);
+        return made(kit, opts, Lanes);
     },
 };
 /**

package/dist/motion.d.ts

@@ -45,7 +45,10 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      */
     push(subject: I, velocity: V, at?: number): void;
 };
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export declare function motionOf<I>(p: object): Motions<I> | undefined;
 interface Common<I, V extends Value> {
     /** Units per second each subject starts moving at. Default 0. */

package/dist/motion.js

@@ -1,11 +1,17 @@
 import { COAST, CRITICAL, EASED, OVER, UNDER } from './closed.js';
 import { curve } from './easing.js';
 import { Motions } from './motions.js';
+import { release } from './shared.js';
 const axes = (v) => (typeof v === 'number' ? [v] : [...v]);
 /** Zero on every axis `x` has: a motion's velocity where its options give none. */
 const still = (x) => new Array(x.length).fill(0);
 const per = (p, subject) => typeof p === 'function' ? p(subject) : p;
 const scalarOf = (p) => typeof p === 'function' ? undefined : typeof p === 'number';
+/**
+ * What marks a motion patch to every copy of blits of this release loaded in one realm, so a
+ * spring another copy made runs on this copy's lanes; it gives the patch's state.
+ */
+const MOTIONS = Symbol.for(`@msb235/blits/motions@${release}`);
 /** One `writes` array per channel, shared by every motion patch that writes it. */
 const writesOf = new Map();
 /**
@@ -29,6 +35,9 @@ class MotionPatch {
     get motion() {
         return this.motions.spec();
     }
+    get [MOTIONS]() {
+        return this.motions;
+    }
     at(_phase, subject, setting) {
         const state = this.motions;
         const s = state.slot(subject);
@@ -58,9 +67,14 @@ class GlidePatch extends MotionPatch {
         this.motions.change(subject, { at, v: axes(velocity) });
     }
 }
-/** The state behind a `'motion'` patch, for an engine that reads it directly. */
+/**
+ * The state behind a `'motion'` patch, for an engine that reads it directly; a patch another copy
+ * of the same release made counts.
+ */
 export function motionOf(p) {
-    return p instanceof MotionPatch ? p.motions : undefined;
+    return p instanceof MotionPatch
+        ? p.motions
+        : p[MOTIONS];
 }
 /**
  * The shapes of the stock motions, each one object over the options it reads, copied out of them so

package/dist/motions.d.ts

@@ -167,6 +167,8 @@ export declare class Motions<I> {
     private unrelease;
     /** Subject `s`'s run as it stands. */
     private runAt;
+    /** Whether the patch holds a run for `subject`. */
+    holds(subject: I): boolean;
     /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
     pack(subject: I): Run | undefined;
     /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
@@ -244,6 +246,8 @@ export declare class Motions<I> {
     private queue;
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     private peek;
+    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+    private dueTo;
     private check;
     private flag;
     forget(s: number): void;

package/dist/motions.js

@@ -28,6 +28,17 @@ function ahead(segs, list) {
 let shared = { xs: new Float64Array(4), vs: new Float64Array(4) };
 /** What a patch's `xs` and `vs` are before its first subject sets its axes. */
 const unsized = new Float64Array(0);
+/** Where `applied` reads a stretch at the time a change lands; copied out before it returns. */
+let landing = { x: new Float64Array(4), v: new Float64Array(4) };
+/** Where `numbers` gathers what it copies, kept an array of doubles so every copy is one too. */
+const gathered = [0.5];
+/** `n` numbers of `from` from `at`, as an array of their own. */
+function numbers(from, at, n) {
+    // `Array.from` walks a typed array by its iterator: about 500 B a call for three axes.
+    for (let i = 0; i < n; i++)
+        gathered[i] = from[at + i];
+    return gathered.slice(0, n);
+}
 /**
  * A subject's flags: its value is a number; it has changes pending; it has older stretches; the
  * stretch it is playing was found landed, which holds until another replaces it.
@@ -211,6 +222,10 @@ export class Motions {
             pending: pending === undefined ? undefined : [...pending],
         };
     }
+    /** Whether the patch holds a run for `subject`. */
+    holds(subject) {
+        return this.known(subject) !== undefined;
+    }
     /** A subject's run as plain data, for a voice leaving memory; undefined where it has none. */
     pack(subject) {
         const s = this.known(subject);
@@ -496,7 +511,7 @@ export class Motions {
     /** Every change due by `t` applied to a copy of the stretch playing then, committing nothing. */
     peek(s, t, xo, vo) {
         let seg = this.playing(s, t);
-        const list = this.pending?.[s];
+        const list = this.dueTo(s);
         if (list !== undefined)
             for (const change of list) {
                 const a = change.at;
@@ -507,6 +522,21 @@ export class Motions {
             }
         this.evaluateSegment(seg, t, xo, vo);
     }
+    /** Subject `s`'s changes waiting, with those a read ahead's tape made filed among them by time. */
+    dueTo(s) {
+        const own = this.pending?.[s];
+        const ahead = reading.ahead?.get(this);
+        if (ahead === undefined)
+            return own;
+        const subject = this.numbers.subject(s);
+        const made = subject === absent ? undefined : ahead.get(subject);
+        if (made === undefined)
+            return own;
+        if (own === undefined)
+            return made;
+        // The patch's own were made first, and a stable sort keeps them first at one time.
+        return [...own.filter((c) => c.at !== undefined), ...made].sort((a, b) => a.at - b.at);
+    }
     check(a, n) {
         if (a !== undefined && a.length !== n)
             throw new Error('blits: a motion patch moves every subject on the same number of axes');
@@ -611,9 +641,9 @@ export class Motions {
         return {
             at: this.runs[this.base(s)],
             ms: this.runs[this.base(s) + 2],
-            x0: Array.from(this.runs.subarray(x, x + n)),
-            v0: Array.from(this.runs.subarray(x + n, x + 2 * n)),
-            to: Array.from(this.runs.subarray(x + 2 * n, x + 3 * n)),
+            x0: numbers(this.runs, x, n),
+            v0: numbers(this.runs, x + n, n),
+            to: numbers(this.runs, x + 2 * n, n),
             change: this.causes?.[s],
         };
     }
@@ -636,11 +666,13 @@ export class Motions {
         return list[lo];
     }
     applied(s, seg, change, at) {
-        const x = new Float64Array(this.n);
-        const v = new Float64Array(this.n);
+        const n = this.n;
+        if (landing.x.length < n)
+            landing = { x: new Float64Array(n), v: new Float64Array(n) };
+        const { x, v } = landing;
         this.evaluateSegment(seg, at, x, v);
-        const xs = Array.from(x);
-        const vs = change.v ?? Array.from(v);
+        const xs = numbers(x, 0, n);
+        const vs = change.v ?? numbers(v, 0, n);
         const subject = this.numbers.subject(s);
         const known = subject === absent ? undefined : subject;
         const to = this.shape.aim(xs, vs, change.to ?? seg.to, known);
@@ -695,8 +727,7 @@ export class Motions {
      * The mix time and frame a stretch was in force by, which a store keys it under: when the change
      * that ended it was made, which falls in the same life of the subject.
      */
-    made(next) {
-        const c = next.change;
+    made(c) {
         const made = c?.made;
         if (made === undefined || Number.isNaN(made))
             return { at: this.owner?.now() ?? Number.NaN, seq: this.owner?.seq() ?? Number.NaN };
@@ -717,7 +748,10 @@ export class Motions {
         const out = list.splice(0, n);
         const subject = this.numbers.subject(s);
         if (this.owner !== null && subject !== absent)
-            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({ ...this.made(out[i + 1] ?? list[0] ?? this.latest(s)), data: seg })));
+            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => {
+                const next = out[i + 1] ?? list[0];
+                return { ...this.made(next === undefined ? this.causes?.[s] : next.change), data: seg };
+            }));
         if (list.length === 0) {
             this.older[s] = undefined;
             this.flag(s, OLDER, false);

package/dist/move.js

@@ -1,7 +1,8 @@
+import { settleArcs } from './arcs.js';
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
-import { popDue, schedule } from './due.js';
-import { detour } from './everyone.js';
+import { byId, popDue, schedule } from './due.js';
+import { detour, outgrow } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
 import { begin } from './held.js';
@@ -66,7 +67,13 @@ function moveTo(mix, now) {
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start)
             begin(mix, voice, now);
         // After it starts, so a fade due by now on a voice that started since the last frame begins.
-        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
+        // Not one set for after its passes run out, where a move across both would begin it first.
+        if ((voice.state === 'live' || voice.state === 'frozen') &&
+            voice.outAt <= now &&
+            !(voice.state === 'live' &&
+                !voice.freezesAfter &&
+                !voice.freezesBefore &&
+                voice.endsAt() < voice.outAt))
             beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state !== 'pending') {
             if (voice.turns)
@@ -123,8 +130,12 @@ function moveTo(mix, now) {
         if (!mix.projecting)
             schedule(mix, voice);
     }
-    if (mix.owners !== null)
+    if (mix.owners !== null) {
         lapse(mix, now);
+        settleArcs(mix, now);
+    }
+    if (mix.sharers.length > 0 && !mix.projecting)
+        outgrow(mix);
     mix.stirred = false;
     if (mix.retired.length > 0)
         prune(mix);
@@ -155,11 +166,16 @@ function turn(mix, voice, now) {
     voice.anchorNow = at;
     noted(mix, voice);
 }
-/** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
+/**
+ * Past this many voices retiring in one frame, and more than one in `SPARSE` of the list, one pass
+ * over the list beats a search for each.
+ */
 const SEARCHED = 8;
+const SPARSE = 32;
 /**
- * Takes the voices retired since the last prune out of the list, in list order. A few are found by
- * their id, which the list is in order of, so the voices still in it are not read.
+ * 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
+ * in it are not read.
  */
 function prune(mix) {
     const retired = mix.retired;
@@ -167,9 +183,8 @@ function prune(mix) {
     const voices = mix.cued;
     let at = null;
     // A projection's list holds copies of voices gone before it, which only a pass takes out.
-    if (retired.length <= SEARCHED && !mix.projecting) {
-        if (retired.length > 1)
-            retired.sort((a, b) => a.id - b.id);
+    if ((retired.length <= SEARCHED || retired.length * SPARSE <= voices.length) && !mix.projecting) {
+        byId(retired);
         at = [];
         for (let k = 0; k < retired.length; k++) {
             const voice = retired[k];
@@ -185,8 +200,16 @@ function prune(mix) {
     if (at !== null) {
         for (const voice of retired)
             pruned = leave(mix, voice) || pruned;
-        for (let k = at.length - 1; k >= 0; k--)
-            voices.splice(at[k], 1);
+        // 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];
+        }
+        voices.length = kept;
     }
     else {
         let kept = 0;

package/dist/numbers.d.ts

@@ -6,7 +6,7 @@ export declare const absent: unique symbol;
  * them, so numbering one never keeps it alive.
  */
 export declare class Numbers<I> {
-    private readonly owner;
+    private owner;
     private next;
     /** Numbers released for reuse; null until one is, as most patches never release one. */
     private free;
@@ -26,6 +26,10 @@ export declare class Numbers<I> {
     constructor(owner: {
         forget(slot: number): void;
     });
+    /** Hands the numbers to a new owner, which hears of every release from now on. */
+    adopt(owner: {
+        forget(slot: number): void;
+    }): void;
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size(): number;
     take(subject: I): number;

package/dist/numbers.js

@@ -29,6 +29,10 @@ export class Numbers {
     constructor(owner) {
         this.owner = owner;
     }
+    /** Hands the numbers to a new owner, which hears of every release from now on. */
+    adopt(owner) {
+        this.owner = owner;
+    }
     /** One past the highest number handed out, so a loop over 0..size meets every live one. */
     get size() {
         return this.next;

package/dist/owner.d.ts

@@ -9,6 +9,19 @@ export declare class Holding<V> {
     /** How many it has held, and how many of those finished their passes. */
     kids: number;
     played: number;
+    /**
+     * When the children that left coast, as pairs of the frame one left in and the latest coast so
+     * far, mix time: a pair only where the latest grew, so a seek back cuts it to a prefix.
+     */
+    coasts: number[];
+    /** The frame the first child to leave before its passes ended left in; Infinity for none. */
+    cutSeq: number;
+    /** The latest coast of a child that left; -Infinity for none. */
+    get coast(): number;
+    /** A child left in frame `seq`, coasting at `coast`, or before its passes ended for undefined. */
+    left(coast: number | undefined, seq: number): void;
+    /** Forgets the children that left after frame `seq`, for a seek or read back to it. */
+    back(seq: number): void;
 }
 /**
  * What an owner's clock reads at mix time `now`, through every owner above it: -Infinity before it
@@ -41,5 +54,8 @@ export declare function heldByInput<I, O>(voice: Voice<I, O>): boolean;
 export declare function ownWeight<I, O>(owner: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
 /** What every owner above a voice multiplies into its weight. */
 export declare function ownersWeight<I, O>(voice: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
-/** Points a projection's copies at each other's owners, each owner holding only copies. */
-export declare function relink<I, O>(copies: readonly Voice<I, O>[]): void;
+/**
+ * Points a projection's copies at each other's owners, each owner holding only copies; for a read
+ * back to frame `seq`, as its children that had left by then left it.
+ */
+export declare function relink<I, O>(copies: readonly Voice<I, O>[], seq?: number): void;