@msb235/blits 0.7.1 → 0.8.1

package/dist/mixer.js

@@ -2,8 +2,9 @@ import { blended, blendOf, laneRead, shareKept } from './blend.js';
 import { aims, chain, linkable, relink } from './chain.js';
 import { lerpInto } from './channels.js';
 import { cue } from './cue.js';
-import { beginFade, parting } from './fade.js';
-import { apply, baseFor, clamp, contribution, fold, folded, foldLoci, foldWith, isRest, keyed, linked, near, owedBy, passes, read, slopeFor, tick, } from './fold.js';
+import { DepartedIndex } from './departed.js';
+import { beginFade, leftWith, 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';
@@ -23,9 +24,15 @@ import { seek } from './seek.js';
 import { Fitting, refit } from './spans.js';
 import { Store } from './store.js';
 import { record } from './tape.js';
+import { touch } from './touch.js';
 import { announce, Transport } from './transport.js';
 import { none } from './voice.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
+ * `lanes` off to run every test on the general path, which is what makes each one an equivalence check.
+ */
+export const defaults = { lanes: true };
 // biome-ignore lint/suspicious/noUnsafeDeclarationMerging: every member of `Methods` is installed below
 export class Mixer {
     kit;
@@ -41,6 +48,11 @@ export class Mixer {
     backward = false;
     /** True during a sync, so a control change it makes is recorded as showing in that frame. */
     moving = false;
+    /**
+     * Whether a probe or pull has read the mix since its clock last moved. A control change made
+     * before that shows in this frame live, so it is recorded as showing in it.
+     */
+    looked = false;
     /**
      * Under `history` with `inputs`, the host fields patches read, copied each frame they changed. In
      * a projection reading back, the copy in force then.
@@ -56,20 +68,23 @@ export class Mixer {
     /** Taken off its transport, so it takes no more calls until a seek puts it back. */
     dropped = false;
     name;
-    /** This mix's frame among every mix's: moved by a sync, and by a control change or drop within one. */
+    /**
+     * This mix's frame among every mix's: moved by a sync or seek, and by a control change, drop,
+     * or touch within one.
+     */
     frame = nextFrame();
     /** Pending voices whose start the host gave, by its host time, kept where the rate puts it. */
     pins = null;
     wantsPose = false;
     /** The pose `pull` folds a subject into where it cannot read straight from the lanes. */
     scratch;
-    /** The last array `pull` read, by position, with each subject's chain head, to skip the lookup. */
     /** Live voices by the earliest mix time `moveTo` would change each, a binary heap. */
     due = [];
     /** Voices retired since `moveTo` last pruned them, in the order they retired. */
     retired = [];
     /** Visit every voice each sync, as before the due queue; for tests that compare the two. */
     walkAll = false;
+    /** 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. */
@@ -89,6 +104,9 @@ export class Mixer {
     /** Records a change to the mix's voices or controls. */
     stir() {
         this.stirs++;
+        // A change a sync makes follows from the clock; one a host makes does not.
+        if (!this.moving)
+            this.transport.settle();
         if (this.stirred)
             return;
         this.stirred = true;
@@ -113,8 +131,8 @@ export class Mixer {
     }
     /**
      * Per subject, the first record of the chain through every live voice that reaches it, or a stub
-     * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
-     * state changes.
+     * where none does. Relinked when `version` moves, or when a voice naming the subject marks its
+     * head stale: see `changed` in `chain.ts`.
      */
     chains = new Store();
     version = 0;
@@ -123,6 +141,8 @@ export class Mixer {
     named = new Store();
     /** Voices a subject has been faded out of, which `drop` looks in besides those that reach it. */
     parters = new Set();
+    /** What an anchor can still find of voices that left without history, or past its reach. */
+    departed = new DepartedIndex();
     /**
      * Motion patches that may hold state for a subject no voice still reaching it plays, which `drop`
      * frees besides those voices' own: per subject, a patch a voice naming it left while another
@@ -136,6 +156,15 @@ export class Mixer {
     naming = 0;
     /** The voices in the list that name no subjects, in voice order. */
     general = [];
+    /** Those of `general` that keep one record for every subject, in voice order: see `everyone.ts`. */
+    sharers = [];
+    /**
+     * Whether a voice stopped sharing this frame: a probe or pull under way then holds chains linked
+     * before it joined them, and takes each again.
+     */
+    unshared = false;
+    /** 0 where a fold is a walk of the chain: see `detour` in `everyone.ts`. */
+    detours = 0;
     /** How many voices in the list carry a locus; with none, a fold allocates nothing. */
     loci = 0;
     /** What every motion patch it plays asks for its voice's time, holding this mix weakly. */
@@ -196,7 +225,7 @@ export class Mixer {
         this.names.forEach((k, i) => {
             this.slotOf.set(k, i);
         });
-        this.lanes = opts.lanes === false ? null : new Lanes(laneHost(this));
+        this.lanes = (opts.lanes ?? defaults.lanes) ? new Lanes(laneHost(this)) : null;
         this.name = opts.name;
         const shared = opts.transport;
         if (shared !== undefined) {
@@ -315,6 +344,7 @@ export class Mixer {
         return book(this, opts);
     }
     probe(subject, out) {
+        this.looked = true;
         const pose = this.fold(subject, out);
         this.keep(subject, pose, out);
         // Where the lanes answer `atRest` from their own values, there is nothing to keep.
@@ -323,6 +353,7 @@ export class Mixer {
         return pose;
     }
     pull(subjects, into) {
+        this.looked = true;
         pull(this, subjects, into);
     }
     seek(time) {
@@ -431,8 +462,10 @@ export class Mixer {
         return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
     }
     mute(opts) {
-        for (const voice of this.cued)
+        for (const voice of this.cued) {
+            voice.written = true;
             beginFade(this, voice, { over: opts?.over });
+        }
         record(this, 'mute', () => this.mute(opts));
     }
     drop(subject) {
@@ -453,7 +486,7 @@ export class Mixer {
         // 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, voice.subjects.get(subject));
+            leave(this, voice, subject, leftWith(this, voice, subject));
             voice.subjects.delete(subject);
             voice.motion?.release(subject, ...kept);
             voice.parts?.delete(subject);
@@ -494,6 +527,10 @@ export class Mixer {
             motion.release(subject, ...kept);
         record(this, 'drop', () => this.drop(subject));
     }
+    touch(subject) {
+        this.attached();
+        touch(this, subject);
+    }
     drain(tag) {
         const all = this.sent;
         if (all.length === 0)
@@ -518,7 +555,7 @@ export class Mixer {
      * is first asked, when probes start writing it.
      */
     restStamps = null;
-    /** What a probe's record of rest is good for: moved by a new frame, version or relink. */
+    /** What a probe's record of rest is good for: moved by a new frame, version, relink, or stir. */
     restsEpoch = 0;
     restsFrame = Number.NaN;
     restsVersion = Number.NaN;
@@ -552,6 +589,9 @@ const methods = {
     foldWith,
     owedBy,
     foldLoci,
+    foldDetour,
+    foldSharers,
+    shared,
     read,
     contribution,
     keyed,

package/dist/motion.d.ts

@@ -33,6 +33,8 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
      * Where `subject` is and how fast it moves at voice time `at`, default the mix's latest frame,
      * counting every change due by then. With no time given, undefined until a frame of its voice
      * has met the subject, while the subject is still inside its stagger, and once that voice is gone.
+     * At any time, undefined for a subject the patch has never met or changed, or that the mix
+     * dropped.
      */
     read(subject: I, at?: number): Motion<V> | undefined;
     /**

package/dist/motion.js

@@ -26,7 +26,6 @@ class MotionPatch {
     }
     form = 'motion';
     duration = 0;
-    period = 0;
     get motion() {
         return this.motions.spec();
     }
@@ -191,6 +190,8 @@ export function spring(writes, opts) {
     const k = opts.stiffness ?? 170;
     const c = opts.damping ?? 26;
     const m = opts.mass ?? 1;
+    if (!(k > 0) || !(m > 0) || !(c >= 0))
+        throw new RangeError('blits: a spring takes a positive stiffness and mass, and damping of 0 or more');
     const settle = opts.settle ?? 1e-4;
     const w0 = Math.sqrt(k / m);
     const zeta = c / (2 * Math.sqrt(k * m));
@@ -215,6 +216,8 @@ export function spring(writes, opts) {
  */
 export function glide(writes, opts) {
     const ms = opts.ms ?? 325;
+    if (!(ms > 0))
+        throw new RangeError('blits: a glide takes a positive ms');
     const tau = ms / 1000;
     const settle = opts.settle ?? 1e-4;
     const shape = new GlideShape([COAST, settle, tau, 0, 0], { kind: 'glide', ms, settle }, opts, tau);

package/dist/motions.d.ts

@@ -23,6 +23,8 @@ export interface Change {
     v?: number[];
     /** The mix clock when it was made, NaN where no mix was playing the patch. */
     made?: number;
+    /** The frame it was made in, which a rewind partitions by; NaN where no mix was playing the patch. */
+    seq?: number;
 }
 /**
  * The mix playing a patch, asked with its voice's id: an owner and an id, where a pair of closures
@@ -35,6 +37,8 @@ export interface MotionOwner {
     revive(id: number, subject: unknown): void;
     /** The mix clock at its latest frame; NaN before the first. */
     now(): number;
+    /** The number of the frame the mix is playing. */
+    seq(): number;
     /**
      * The host made a change, already given its time, which a seek makes again on the patch its
      * voice plays then: a voice a history store paged out comes back with a patch of its own.
@@ -43,9 +47,10 @@ export interface MotionOwner {
     /** History leaving memory for a subject, which a mix with a history store pages out. */
     page(id: number, stream: 'released' | 'stretch', subject: unknown, out: Paging[]): void;
 }
-/** A record of a motion patch's history leaving memory, at a mix time. */
+/** A record of a motion patch's history leaving memory, at a mix time and frame. */
 export interface Paging {
     at: number;
+    seq: number;
     data: unknown;
 }
 /** A subject's run as plain data: its flags, its stretches oldest first, and changes still to apply. */
@@ -75,7 +80,7 @@ export interface Shape<I> {
     scalarEvery(): boolean | undefined;
     /** A tween's easing, which its law cannot hold; undefined, but present, on every other shape. */
     ease: Curve | undefined;
-    /** A tween's seconds for a stretch the subject starts now; undefined, but present, on the rest. */
+    /** A tween's ms for a stretch the subject starts now; undefined, but present, on the rest. */
     ms: ((subject: I) => number) | undefined;
     /** The patch's kind and constants, as `Patch.motion` reports them. */
     spec(): MotionSpec;
@@ -86,7 +91,7 @@ export interface Shape<I> {
  * The one copy, read by `at` and by a mix's lane alike.
  *
  * After the law, each subject's run of `stride` numbers is its release time, its flags, a tween's
- * seconds for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
+ * ms for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
@@ -95,6 +100,8 @@ export declare class Motions<I> {
     private readonly numbers;
     /** Numbers by subject once a second is numbered: till then the one subject is found by `numbers`. */
     private readonly slots;
+    /** How many numbers have been given up, so a number kept elsewhere can tell it is stale. */
+    freed: number;
     /** Axes per subject; -1 until the first subject sets it. */
     n: number;
     private cap;
@@ -149,11 +156,11 @@ export declare class Motions<I> {
      */
     private released;
     /**
-     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at`, under
-     * history, its run is kept for a rewind before then, until `reach` passes it.
+     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+     * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
      */
-    release(subject: I, at?: number, reach?: number): void;
-    /** Puts back each subject released after mix time `t`, as it stood when released. */
+    release(subject: I, at?: number, reach?: number, seq?: number): void;
+    /** Puts back each subject released after frame `seq`, as it stood when released. */
     private unrelease;
     /** Subject `s`'s run as it stands. */
     private runAt;
@@ -162,9 +169,9 @@ export declare class Motions<I> {
     /** Puts a subject's run back as `pack` or a release left it, replacing any it has now. */
     unpack(subject: I, run: Run): void;
     /** A released run a history store gave back, for a rewind to before its release. */
-    reclaim(subject: I, at: number, run: Run): void;
+    reclaim(subject: I, at: number, seq: number, run: Run): void;
     /**
-     * Stretches a history store gave back, each by the mix time it was in force by: each life of the
+     * Stretches a history store gave back, each by the frame it was in force by: each life of the
      * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
      */
     restretch(subject: I, back: readonly Paging[]): void;
@@ -184,7 +191,7 @@ export declare class Motions<I> {
     /** Whether `law` holds this patch's law, number for number, as `Object.is` compares them. */
     hasLaw(law: Float64Array): boolean;
     /**
-     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its seconds, then
+     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its ms, then
      * `x0`, `v0` and `to` per axis; false, copying nothing, while it has a change pending or an
      * earlier stretch kept, which only `sample` handles.
      */
@@ -200,7 +207,7 @@ export declare class Motions<I> {
      */
     sample(s: number, t: number, xo: Float64Array, vo: Float64Array): void;
     /**
-     * Where subject `s`'s run starts in `runs` (its release time, then flags, seconds, `x0`, `v0`
+     * Where subject `s`'s run starts in `runs` (its release time, then flags, ms, `x0`, `v0`
      * and `to`) while it has nothing pending and no earlier stretch kept; -1 for any other.
      */
     bareAt(s: number): number;
@@ -238,10 +245,10 @@ export declare class Motions<I> {
     private flag;
     forget(s: number): void;
     /**
-     * Takes back every change made after mix time `t`: each subject plays from its earliest stretch
+     * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
      * kept, with the changes made by then queued to be applied again.
      */
-    rewind(t: number): void;
+    rewind(seq: number): void;
     private cut;
     /** Where subject `s`'s run starts in `runs`. */
     base(s: number): number;
@@ -255,8 +262,8 @@ export declare class Motions<I> {
     private commit;
     private insert;
     /**
-     * The mix time 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.
+     * 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.
      */
     private made;
     /** Lets go of stretches older than the one in force at `reading.horizon`. */

package/dist/motions.js

@@ -43,7 +43,7 @@ const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel}
  * The one copy, read by `at` and by a mix's lane alike.
  *
  * After the law, each subject's run of `stride` numbers is its release time, its flags, a tween's
- * seconds for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
+ * ms for the stretch, then `x0`, `v0` and `to` per axis. A live sample reads this one buffer and nothing else the patch owns: at
  * 10k springs of one subject each, a buffer per field, a map lookup per sample and the law in an
  * object of its own took a call from 130 ns to 490.
  */
@@ -52,6 +52,8 @@ export class Motions {
     numbers = new Numbers(this);
     /** Numbers by subject once a second is numbered: till then the one subject is found by `numbers`. */
     slots = new Store();
+    /** How many numbers have been given up, so a number kept elsewhere can tell it is stale. */
+    freed = 0;
     /** Axes per subject; -1 until the first subject sets it. */
     n = -1;
     cap = 0;
@@ -163,10 +165,10 @@ export class Motions {
      */
     released = [];
     /**
-     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at`, under
-     * history, its run is kept for a rewind before then, until `reach` passes it.
+     * Forgets a subject, so a later ask starts it afresh from `from`. Given the mix time `at` and frame
+     * `seq`, under history, its run is kept for a rewind before then, until `reach` passes it.
      */
-    release(subject, at, reach = Number.NEGATIVE_INFINITY) {
+    release(subject, at, reach = Number.NEGATIVE_INFINITY, seq = Number.NaN) {
         const s = this.known(subject);
         if (s === undefined)
             return;
@@ -176,19 +178,21 @@ export class Motions {
                 if (e.at >= reach)
                     kept.push(e);
                 else
-                    this.owner?.page(this.ownerId, 'released', e.subject, [{ at: e.at, data: runOf(e) }]);
+                    this.owner?.page(this.ownerId, 'released', e.subject, [
+                        { at: e.at, seq: e.seq, data: runOf(e) },
+                    ]);
             this.released = kept;
-            this.released.push({ subject, at, ...this.runAt(s) });
+            this.released.push({ subject, at, seq, ...this.runAt(s) });
         }
         this.slots.delete(subject);
         this.numbers.release(s);
     }
-    /** Puts back each subject released after mix time `t`, as it stood when released. */
-    unrelease(t) {
-        const back = this.released.filter((e) => e.at > t).sort((a, b) => a.at - b.at);
+    /** Puts back each subject released after frame `seq`, as it stood when released. */
+    unrelease(seq) {
+        const back = this.released.filter((e) => e.seq > seq).sort((a, b) => a.seq - b.seq);
         if (back.length === 0)
             return;
-        this.released = this.released.filter((e) => e.at <= t);
+        this.released = this.released.filter((e) => e.seq <= seq);
         const done = new Set();
         for (const e of back) {
             if (done.has(e.subject))
@@ -239,24 +243,24 @@ export class Motions {
         }
     }
     /** A released run a history store gave back, for a rewind to before its release. */
-    reclaim(subject, at, run) {
-        if (this.released.some((e) => e.at === at && Object.is(e.subject, subject)))
+    reclaim(subject, at, seq, run) {
+        if (this.released.some((e) => e.seq === seq && Object.is(e.subject, subject)))
             return;
-        this.released.push({ subject, at, ...run });
+        this.released.push({ subject, at, seq, ...run });
     }
     /**
-     * Stretches a history store gave back, each by the mix time it was in force by: each life of the
+     * Stretches a history store gave back, each by the frame it was in force by: each life of the
      * subject, ended by a release, takes those from its own, ahead of the earliest it still keeps.
      */
     restretch(subject, back) {
         const lives = this.released
             .filter((e) => Object.is(e.subject, subject))
-            .sort((x, y) => x.at - y.at);
+            .sort((x, y) => x.seq - y.seq);
         let from = Number.NEGATIVE_INFINITY;
-        const within = (to) => back.filter((r) => r.at > from && r.at <= to).map((r) => r.data);
+        const within = (to) => back.filter((r) => r.seq > from && r.seq <= to).map((r) => r.data);
         for (const e of lives) {
-            e.stretches = ahead(within(e.at), e.stretches);
-            from = e.at;
+            e.stretches = ahead(within(e.seq), e.stretches);
+            from = e.seq;
         }
         const s = this.known(subject);
         if (s === undefined)
@@ -298,7 +302,7 @@ export class Motions {
         return true;
     }
     /**
-     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its seconds, then
+     * Copies subject `s`'s current stretch into `out` from `o` as its release time, its ms, then
      * `x0`, `v0` and `to` per axis; false, copying nothing, while it has a change pending or an
      * earlier stretch kept, which only `sample` handles.
      */
@@ -354,7 +358,7 @@ export class Motions {
         this.peek(s, t, xo, vo);
     }
     /**
-     * Where subject `s`'s run starts in `runs` (its release time, then flags, seconds, `x0`, `v0`
+     * Where subject `s`'s run starts in `runs` (its release time, then flags, ms, `x0`, `v0`
      * and `to`) while it has nothing pending and no earlier stretch kept; -1 for any other.
      */
     bareAt(s) {
@@ -455,6 +459,7 @@ export class Motions {
         this.check(c.to, this.n);
         this.check(c.v, this.n);
         c.made = this.owner === null ? Number.NaN : this.owner.now();
+        c.seq = this.owner === null ? Number.NaN : this.owner.seq();
         if (c.at === undefined) {
             const at = this.frame(subject);
             if (!Number.isNaN(at))
@@ -511,6 +516,7 @@ export class Motions {
         this.runs[i] = on ? flags | bit : flags & ~bit;
     }
     forget(s) {
+        this.freed++;
         if (this.pending !== null)
             this.pending[s] = undefined;
         if (this.older !== null)
@@ -519,16 +525,16 @@ export class Motions {
             this.causes[s] = undefined;
     }
     /**
-     * Takes back every change made after mix time `t`: each subject plays from its earliest stretch
+     * Takes back every change made after frame `seq`: each subject plays from its earliest stretch
      * kept, with the changes made by then queued to be applied again.
      */
-    rewind(t) {
-        this.unrelease(t);
+    rewind(seq) {
+        this.unrelease(seq);
         for (let s = 0; s < this.numbers.size; s++)
             if (this.numbers.subject(s) !== absent)
-                this.cut(s, t);
+                this.cut(s, seq);
     }
-    cut(s, t) {
+    cut(s, seq) {
         const older = this.older?.[s];
         const pending = this.pending?.[s];
         const current = this.latest(s);
@@ -536,7 +542,7 @@ export class Motions {
         const kept = [];
         let cut = false;
         for (const c of [...stretches.slice(1).map((seg) => seg.change), ...(pending ?? [])])
-            if (c === undefined || c.made === undefined || !(c.made > t)) {
+            if (c === undefined || c.seq === undefined || !(c.seq > seq)) {
                 if (c !== undefined)
                     kept.push(c);
             }
@@ -684,12 +690,15 @@ export class Motions {
         list.splice(i, 0, seg);
     }
     /**
-     * The mix time 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.
+     * 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 made = next.change?.made;
-        return made === undefined || Number.isNaN(made) ? (this.owner?.now() ?? Number.NaN) : made;
+        const c = next.change;
+        const made = c?.made;
+        if (made === undefined || Number.isNaN(made))
+            return { at: this.owner?.now() ?? Number.NaN, seq: this.owner?.seq() ?? Number.NaN };
+        return { at: made, seq: c?.seq ?? Number.NaN };
     }
     /** Lets go of stretches older than the one in force at `reading.horizon`. */
     prune(s) {
@@ -706,10 +715,7 @@ 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) => ({
-                at: this.made(out[i + 1] ?? list[0] ?? this.latest(s)),
-                data: seg,
-            })));
+            this.owner.page(this.ownerId, 'stretch', subject, out.map((seg, i) => ({ ...this.made(out[i + 1] ?? list[0] ?? this.latest(s)), data: seg })));
         if (list.length === 0) {
             this.older[s] = undefined;
             this.flag(s, OLDER, false);

package/dist/move.js

@@ -1,11 +1,13 @@
-import { changed, unindex } from './chain.js';
+import { changed } from './chain.js';
 import { popDue, schedule } from './due.js';
+import { detour } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
-import { started } from './held.js';
+import { reorigin } from './held.js';
 import { ownerReading } from './owner.js';
 import { mixAt, place, repin, startOf } from './place.js';
 import { pageVoice } from './revive.js';
+import { delist } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
 import { lapse } from './spans.js';
 import { unplay } from './strays.js';
@@ -31,6 +33,11 @@ export function move(mix, now) {
 }
 function moveTo(mix, now) {
     mix.now = now;
+    mix.looked = false;
+    if (mix.unshared) {
+        mix.unshared = false;
+        detour(mix);
+    }
     mix.frame = nextFrame();
     mix.reducedNow = mix.reduced;
     for (const a of mix.announced)
@@ -52,18 +59,19 @@ function moveTo(mix, now) {
             continue;
         if (Number.isNaN(voice.opened))
             voice.opened = now;
-        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
-            beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state === 'pending' &&
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
             voice.state = 'live';
-            started(mix, voice);
+            reorigin(mix, voice, now);
             changed(mix, voice);
         }
+        // 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)
+            beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
         if (voice.state !== 'pending' && Number.isFinite(voice.span)) {
             const end = voice.span + voice.latest;
             if (voice.elapsedAt(now) >= end) {
-                voice.play(true, now);
+                voice.play(true, now, mix.transport.seq);
                 // The fade starts when the last pass ended, not at the frame that noticed, so it plays
                 // the same at any frame rate and a read at another time can find it.
                 if (voice.state === 'live') {
@@ -154,8 +162,12 @@ function prune(mix) {
         }
         voices.length = kept;
     }
-    if (pruned)
+    if (pruned) {
         mix.general = mix.general.filter((v) => v.state !== 'done');
+        if (mix.sharers.length > 0)
+            mix.sharers = mix.sharers.filter((v) => v.state !== 'done');
+        detour(mix);
+    }
 }
 /** The voice's place in a list in id order, or -1 where it is not there. */
 function indexOf(voices, voice) {
@@ -180,18 +192,13 @@ function leave(mix, voice) {
         mix.gone.push(voice);
         scoredLeft(mix, voice);
     }
-    else
+    else {
         mix.parters.delete(voice);
+        mix.departed.add(mix, voice);
+    }
     unplay(mix, voice);
     changed(mix, voice);
-    if (voice.named !== null)
-        unindex(mix, voice);
-    if (voice.holding !== null && mix.owners !== null)
-        mix.owners = mix.owners.filter((v) => v !== voice);
-    if (voice.spec.locus !== undefined)
-        mix.loci--;
-    if (voice.spec.anchor !== undefined)
-        mix.anchored--;
+    delist(mix, voice);
     return voice.named === null;
 }
 /** Lets go of the voices that have left and that history no longer reaches. */

package/dist/moved.d.ts

@@ -0,0 +1,11 @@
+import type { Motions } from './motions.js';
+import type { Subject } from './voice.js';
+/**
+ * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
+ * into the record's last delta and the array that holds, where `at` makes an object and an array a
+ * call, and the patch's number for the subject kept on the record, where `at` looks it up a call.
+ * `setting` has the voice time to sample at.
+ */
+export declare function moved<I>(run: Motions<I>, key: string, subject: I, setting: {
+    readonly elapsed: number;
+}, rec: Subject<unknown>): Record<string, unknown>;

package/dist/moved.js

@@ -0,0 +1,29 @@
+import { doubles } from './channels.js';
+/**
+ * A motion voice's delta for a subject on the general path: what its patch's `at` gives, written
+ * into the record's last delta and the array that holds, where `at` makes an object and an array a
+ * call, and the patch's number for the subject kept on the record, where `at` looks it up a call.
+ * `setting` has the voice time to sample at.
+ */
+export function moved(run, key, subject, setting, rec) {
+    let s = rec.run;
+    if (rec.freed !== run.freed) {
+        s = run.slot(subject);
+        rec.run = s;
+        rec.freed = run.freed;
+    }
+    const xs = run.xs;
+    run.sample(s, setting.elapsed, xs, run.vs);
+    const delta = rec.delta ?? {};
+    if (run.scalar(s)) {
+        delta[key] = xs[0];
+        return delta;
+    }
+    const n = run.n;
+    const held = delta[key];
+    const out = Array.isArray(held) && held.length === n ? held : doubles(n, 0);
+    for (let i = 0; i < n; i++)
+        out[i] = xs[i];
+    delta[key] = out;
+    return delta;
+}