@msb235/blits 0.8.1 → 0.9.0

package/dist/keyfill.js

@@ -1,5 +1,6 @@
 import { foldNumber } from './channels.js';
 import { clampWeight, frozenTime, phaseAt, same, weighed } from './clock.js';
+import { unband } from './fold.js';
 import { shortWay } from './turns.js';
 /**
  * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
@@ -44,6 +45,7 @@ export function runKeys(lanes, lane) {
         const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
+            unband(records[p]);
             continue;
         }
         if (!flat) {
@@ -63,8 +65,10 @@ export function runKeys(lanes, lane) {
             lanes.gather(lane, lane.delta);
             flatten(chans, read, nums, kinds);
         }
-        if (!(w > 0))
+        if (!(w > 0)) {
+            unband(records[p]);
             continue;
+        }
         let k = 0;
         for (let i = 0; i < n; i++) {
             const ch = chans[i];

package/dist/locus.d.ts

@@ -21,6 +21,8 @@ export interface LocusScratch<I, O> {
     mGroups: number[];
     values: unknown[];
     taken: Float64Array;
+    /** Per slot of a stock `last` channel, the weight of the member its value came from. */
+    heaviest: Float64Array;
     met: Uint8Array;
     touched: number[];
     owned: (number[] | undefined)[];
@@ -34,7 +36,8 @@ export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: nu
 /**
  * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
- * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
+ * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
 export declare function foldLocus<I, O>(this: Mixer<I, O>, k: LocusScratch<I, O>, group: number): number;

package/dist/locus.js

@@ -15,6 +15,7 @@ export function locusScratch(channels) {
         mGroups: [],
         values: new Array(channels).fill(undefined),
         taken: new Float64Array(channels),
+        heaviest: new Float64Array(channels),
         met: new Uint8Array(channels),
         touched: [],
         owned: new Array(channels).fill(undefined),
@@ -37,7 +38,8 @@ export function own(k, slot, value, rest) {
 /**
  * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
- * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
+ * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
 export function foldLocus(k, group) {
@@ -67,6 +69,7 @@ export function foldLocus(k, group) {
                 k.met[slot] = 1;
                 k.touched.push(slot);
                 taken[slot] = weight;
+                k.heaviest[slot] = weight;
                 k.values[slot] =
                     this.lerpsInto[slot] !== undefined && channel.scale && Array.isArray(value)
                         ? own(k, slot, value, channel.rest)
@@ -74,13 +77,20 @@ export function foldLocus(k, group) {
                 continue;
             }
             const total = taken[slot] + weight;
+            taken[slot] = total;
+            if (channel.kind === 'last') {
+                if (weight >= k.heaviest[slot]) {
+                    k.heaviest[slot] = weight;
+                    k.values[slot] = first(value);
+                }
+                continue;
+            }
             const was = k.values[slot];
             const lerp = this.lerpsInto[slot];
             k.values[slot] =
                 lerp !== undefined && was === k.owned[slot]
                     ? lerp(was, was, value, weight / total)
                     : channel.lerp(was, value, weight / total);
-            taken[slot] = total;
         }
     }
     for (let t = 0; t < k.touched.length; t++)

package/dist/marks.js

@@ -99,8 +99,8 @@ export function markOf(mix, voice, mark) {
         if (Number.isFinite(t))
             outAt = Math.max(start, t);
     }
-    else if (!voice.freezesAfter && Number.isFinite(voice.span)) {
-        const t = voice.timeAt(voice.span + voice.latest);
+    else if (!(voice.backs ? voice.freezesBefore : voice.freezesAfter)) {
+        const t = voice.endsAt();
         if (Number.isFinite(t))
             outAt = Math.max(start, t);
     }
@@ -138,8 +138,8 @@ function coastOf(mix, voice, start) {
             t = Math.max(t, c);
         }
     }
-    else if (Number.isFinite(voice.span))
-        t = voice.timeAt(voice.span + voice.latest);
+    else
+        t = voice.endsAt();
     if (t === undefined || !Number.isFinite(t))
         return undefined;
     t = Math.max(start, t);

package/dist/motion.d.ts

@@ -40,7 +40,8 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
     /**
      * Sets `subject` moving at `velocity`, units per second, from voice time `at`, default the mix's
      * latest frame; for a subject no frame of its voice has met yet, or still inside its stagger, its
-     * first read, after any change with a time due by then.
+     * first read, after any change with a time due by then. A subject faded out of the voice comes
+     * back at the latest frame too, however long it is before it is next read.
      */
     push(subject: I, velocity: V, at?: number): void;
 };
@@ -76,7 +77,8 @@ export declare function spring<I, O, V extends Value = number>(writes: keyof O,
     /**
      * Heads `subject` for `target` from voice time `at`, keeping its velocity: by default the mix's
      * latest frame, or for a subject no frame of its voice has met yet, or still inside its stagger,
-     * its first read, after any change with a time due by then.
+     * its first read, after any change with a time due by then. A subject faded out of the voice
+     * comes back at the latest frame too, however long it is before it is next read.
      */
     to(subject: I, target: V, at?: number): void;
 };
@@ -115,7 +117,8 @@ export declare function tween<I, O, V extends Value = number>(writes: keyof O, o
     /**
      * Heads `subject` for `target` from voice time `at`, over a full `ms` from where it is: by default
      * the mix's latest frame, or for a subject no frame of its voice has met yet, or still inside its
-     * stagger, its first read, after any change with a time due by then.
+     * stagger, its first read, after any change with a time due by then. A subject faded out of the
+     * voice comes back at the latest frame too, however long it is before it is next read.
      */
     to(subject: I, target: V, at?: number): void;
 };

package/dist/motions.d.ts

@@ -33,8 +33,11 @@ export interface Change {
 export interface MotionOwner {
     /** The subject's voice time at the mix's latest frame; NaN where no frame of the voice met it. */
     frame(id: number, subject: unknown): number;
-    /** Brings a subject the voice faded out back to it, so a change is not made for nothing. */
-    revive(id: number, subject: unknown): void;
+    /**
+     * Brings a subject the voice faded out back to it, so a change is not made for nothing: its
+     * voice time now, which a change bringing it back is made at; NaN for any other subject.
+     */
+    revive(id: number, subject: unknown): number;
     /** The mix clock at its latest frame; NaN before the first. */
     now(): number;
     /** The number of the frame the mix is playing. */

package/dist/motions.js

@@ -454,7 +454,7 @@ export class Motions {
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject, c) {
-        this.owner?.revive(this.ownerId, subject);
+        const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
         this.check(c.v, this.n);
@@ -464,6 +464,8 @@ export class Motions {
             const at = this.frame(subject);
             if (!Number.isNaN(at))
                 c.at = at;
+            else if (!Number.isNaN(back))
+                c.at = back;
         }
         const list = this.pending?.[s];
         if (list === undefined) {

package/dist/move.js

@@ -1,9 +1,12 @@
 import { changed } from './chain.js';
+import { elapsedWith } from './clock.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 { reorigin } from './held.js';
+import { begin } from './held.js';
+import { noted } from './history.js';
+import { leave as leaveClock } from './origin.js';
 import { ownerReading } from './owner.js';
 import { mixAt, place, repin, startOf } from './place.js';
 import { pageVoice } from './revive.js';
@@ -60,28 +63,37 @@ function moveTo(mix, now) {
         if (Number.isNaN(voice.opened))
             voice.opened = now;
         if (voice.state === 'pending' &&
-            (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
-            voice.state = 'live';
-            reorigin(mix, voice, now);
-            changed(mix, voice);
-        }
+            (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)
             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) {
+        if (voice.state !== 'pending') {
+            if (voice.turns)
+                turn(mix, voice, now);
+            // Its passes run out at its end running forward, and at its start running back. A clock
+            // standing still at or before its start is where it was: waiting, or frozen there.
+            const way = heading(voice, now);
+            const at = voice.elapsedAt(now);
+            const back = way < 0;
+            const atStart = !voice.beginless && at <= voice.soonest;
+            // An owner run back to its start stays for what it holds, and leaves with its last child.
+            const holds = voice.holding !== null && voice.holding.children.length > 0;
+            const over = back
+                ? atStart && !holds
+                : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
+            if (over) {
                 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 fade starts when its passes ran out, 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') {
-                    if (voice.freezesAfter)
+                    if (back ? voice.freezesBefore : voice.freezesAfter)
                         voice.state = 'frozen';
                     else
-                        beginFade(mix, voice, {}, Math.max(startOf(voice), Math.min(now, voice.timeAt(end))));
+                        beginFade(mix, voice, { back }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
                 }
             }
-            else if (voice.state === 'frozen')
+            else if (voice.state === 'frozen' && !(atStart && way === 0))
                 voice.state = 'live';
         }
         // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
@@ -118,6 +130,31 @@ function moveTo(mix, now) {
         prune(mix);
     forget(mix);
 }
+/**
+ * Which way a voice's clock is running at mix time `now`, through every owner above it: above 0
+ * forward, below 0 back, 0 standing still.
+ */
+function heading(voice, now) {
+    let way = 1;
+    for (let v = voice; v !== null; v = v.owner)
+        way *= Math.sign(v.rateAt(v.owner === null ? now : ownerReading(v.owner, now)));
+    return way;
+}
+/**
+ * A ramp through 0 has turned a voice's clock around by `now`: the clock is anchored again where
+ * it turned, so it runs one way from there and the time it reads any position is one time.
+ */
+function turn(mix, voice, now) {
+    const r = voice.ramp;
+    const at = voice.anchorNow + (r.over * r.from) / (r.from - r.to);
+    if ((voice.owner === null ? now : ownerReading(voice.owner, now)) < at)
+        return;
+    leaveClock(voice, at);
+    voice.anchorElapsed = elapsedWith(voice, at);
+    voice.ramp = { from: 0, to: r.to, over: voice.anchorNow + r.over - at };
+    voice.anchorNow = at;
+    noted(mix, voice);
+}
 /** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
 const SEARCHED = 8;
 /**
@@ -208,7 +245,7 @@ export function forget(mix) {
         // With a store a voice that has left pages out where it can, and stays where it cannot.
         if (mix.transport.pager !== null) {
             const reach = mix.now - history.ms;
-            keepGone(mix, (v) => v.doneAt >= reach || !pageVoice(mix, v, reach));
+            keepGone(mix, (v) => v.reachedTo >= reach || !pageVoice(mix, v, reach));
         }
         else {
             expireGone(mix, mix.transport.keepsFrom());

package/dist/origin.js

@@ -48,8 +48,9 @@ function fresh(voice) {
  */
 export function originOf(voice, elapsed, rebuilt) {
     const past = voice.clocks;
-    let t = Number.NaN;
-    if (past !== null) {
+    // 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 p = past[i];
             const at = timeWith(p, elapsed);

package/dist/owner.d.ts

@@ -19,6 +19,8 @@ export declare function ownerReading<I, O>(owner: Voice<I, O>, now: number): num
 export declare function ownedElapsed<I, O>(voice: Voice<I, O>, owner: Voice<I, O>, now: number): number;
 /** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
 export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
+/** Whether an odd number of the owners above a voice run back, which turns its clock around. */
+export declare function turnedBack<I, O>(voice: Voice<I, O>): boolean;
 /** Takes a child into its owner. */
 export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): void;
 /** A child left: its owner, where that was its last child and it should leave too. */

package/dist/owner.js

@@ -1,4 +1,4 @@
-import { clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
+import { backWith, clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
 /** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
 export const ownerPatch = Object.freeze({
     form: 'fn',
@@ -29,9 +29,17 @@ export function ownedElapsed(voice, owner, now) {
 }
 /** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
 export function mixTime(owner, t) {
-    const up = timeWith(owner, t);
+    const up = owner.backs ? backWith(owner, t) : timeWith(owner, t);
     return owner.owner === null ? up : mixTime(owner.owner, up);
 }
+/** Whether an odd number of the owners above a voice run back, which turns its clock around. */
+export function turnedBack(voice) {
+    let back = false;
+    for (let o = voice.owner; o !== null; o = o.owner)
+        if (o.backs)
+            back = !back;
+    return back;
+}
 /** Takes a child into its owner. */
 export function adopt(owner, child) {
     const h = owner.holding;

package/dist/place.js

@@ -1,3 +1,4 @@
+import { same } from './clock.js';
 import { departedMatches } from './departed.js';
 import { reorigin } from './held.js';
 import { noted } from './history.js';
@@ -5,6 +6,7 @@ import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
 import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
 import { none } from './voice.js';
+import { warnOnce } from './warn.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
 export function localNow(mix, voice) {
     return voice.owner === null ? mix.now : ownerReading(voice.owner, mix.now);
@@ -38,7 +40,6 @@ function startAt(mix, voice, start) {
         return false;
     voice.start = start;
     voice.anchorNow = start;
-    voice.anchorElapsed = 0;
     voice.clocks = null;
     // A clock moved outright, as a seek moves it: what a record computed at this mix time is stale.
     voice.seeks++;
@@ -121,9 +122,22 @@ export function place(mix) {
                 const t = by === undefined ? undefined : resolve(mix, by, voice);
                 if (t !== undefined) {
                     const m = voice.owner === null ? t : mixTime(voice.owner, t);
-                    const at = anchor.out !== undefined ? m : m - (voice.fade.out ?? 0);
-                    if (at !== voice.outAt) {
+                    const start = startOf(voice);
+                    let at = anchor.out !== undefined ? m : m - (voice.fade.out ?? 0);
+                    let over = Number.NaN;
+                    // A fade out begins no earlier than its voice starts, and one that has to end by `m`
+                    // is shortened to; an end before the start leaves the voice an instant at its start.
+                    if (at < start && Number.isFinite(start)) {
+                        at = start;
+                        if (anchor.end !== undefined) {
+                            over = m > start ? m - start : 0;
+                            if (m < start && !mix.projecting)
+                                warnOnce(voice, `${voice.spec.name ?? `voice ${voice.id}`}'s placement ends before it starts, so it plays as an instant`);
+                        }
+                    }
+                    if (at !== voice.outAt || !same(over, voice.outOver)) {
                         voice.outAt = at;
+                        voice.outOver = over;
                         noted(mix, voice);
                         moved = true;
                     }

package/dist/project.d.ts

@@ -15,4 +15,4 @@ export declare function mirror<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
-export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut): Subject<unknown> | undefined;
+export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut, c?: Mixer<I, O>, copy?: Voice<I, O>): Subject<unknown> | undefined;

package/dist/project.js

@@ -68,7 +68,9 @@ export function projectAll(transport, t) {
         else
             copyStanding(mix, copy, t, cut);
     }
-    if (ahead)
+    // A read at the mix's own time lands nothing, as a probe does not: what the host has done since
+    // the last sync shows at the next one.
+    if (ahead && t !== transport.now)
         for (const copy of copies.values())
             move(copy, t);
     const read = (f) => {
@@ -131,7 +133,7 @@ function copyBack(mix, c, t, cut) {
         .sort((a, b) => a.id - b.id)
         .map((v) => {
         const log = v.log;
-        const copy = v.copy((subject) => recall(mix, v, subject, t, cut), lastWithin(log, cut) ?? log[0]);
+        const copy = v.copy((subject) => recall(mix, v, subject, t, cut, c, copy), lastWithin(log, cut) ?? log[0]);
         if (then !== undefined)
             copy.setting.host = then;
         return copy;
@@ -199,7 +201,7 @@ function carry(mix, voice, subject, c, copy) {
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
-export function recall(mix, voice, subject, t, cut) {
+export function recall(mix, voice, subject, t, cut, c, copy) {
     const live = voice.left?.at(subject, cut) ?? recordOf(mix, voice, subject);
     if (live === undefined)
         return undefined;
@@ -210,13 +212,16 @@ export function recall(mix, voice, subject, t, cut) {
         h.replay = live.inputs;
         return h;
     }
-    const stepped = live.since < t ? live.since : t;
+    // Its origin by the controls the voice had then: a seek or an anchor has moved a waiting
+    // voice's since.
+    const since = c === undefined || copy === undefined ? live.since : c.sinceOf(copy, live.delay);
+    const stepped = since < t ? since : t;
     const h = record(voice, live.reaches, live.reaches && voice.patch.state
         ? voice.patch.state(subject)
         : undefined);
     h.delay = live.delay;
-    h.since = live.since;
-    h.shown = live.shown;
+    h.since = since;
+    h.shown = c === undefined || copy === undefined ? live.shown : c.shownOf(copy, since);
     h.stepped = stepped;
     h.rebuilt = voice.rebuilds;
     h.from = stepped;

package/dist/record.js

@@ -15,7 +15,8 @@ export function record(voice, reaches, state) {
         rested: false,
         bands: null,
         state,
-        stepped: 0,
+        // -0, not 0: a field first given a small integer is boxed on every later write of a double.
+        stepped: -0,
         ticks: 0,
         probed: Number.NaN,
         delta: null,

package/dist/revive.d.ts

@@ -33,6 +33,8 @@ interface PackedVoice {
     opened: number;
     pinned: number;
     latest: number;
+    /** Absent from a store written before a voice kept it. */
+    soonest?: number;
     keeping: boolean;
     first: Controls | null;
     log: Controls[] | null;

package/dist/revive.js

@@ -92,6 +92,7 @@ function packVoice(voice, keys) {
         opened: voice.opened,
         pinned: voice.pinned,
         latest: voice.latest,
+        soonest: voice.soonest,
         keeping: voice.keeping,
         first: voice.first,
         log: voice.log,
@@ -128,6 +129,7 @@ export function reviveVoice(mix, id, d) {
     voice.opened = d.opened;
     voice.pinned = d.pinned;
     voice.latest = d.latest;
+    voice.soonest = d.soonest ?? 0;
     voice.keeping = d.keeping;
     voice.first = d.first;
     voice.log = d.log;

package/dist/seek.js

@@ -143,7 +143,7 @@ export function seek(transport, t) {
         throw new RangeError('blits: a mix seeks to a finite time');
     if (!(t >= transport.born))
         throw new Error(`blits: ${t} is older than this mix's history reaches`);
-    const unpaged = cover(transport, t);
+    cover(transport, t);
     if (t >= transport.now) {
         // 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);
@@ -176,7 +176,7 @@ export function seek(transport, t) {
         transport.now = t;
         for (const m of transport.members)
             back(m, t, seq, frame.at < t);
-        cut(transport, seq, unpaged);
+        cut(transport, seq);
     }
     transport.tick(t);
     // The host's clock reads on from here: its next sync reads `t` plus its time since its last.

package/dist/spans.d.ts

@@ -16,11 +16,12 @@ export declare class Fitting {
 /** Refuses a voice a span cannot fit: one it would not own the timing of, or one with no end. */
 export declare function checkChild<I, O>(spec: VoiceSpec<I, O>, child: Voice<I, O>): void;
 /**
- * Lays out a span's children and fits them into what is left of its budget, from its clock now.
- * Only what is still to come moves: a playing child keeps its place and may change rate, a
- * pending one is placed. A span held by a span is fitted again by its own span after.
+ * Lays out a span's children and fits them into what is left of its budget, from its clock at mix
+ * time `from`, default now. Only what is still to come moves: a playing child keeps its place and
+ * may change rate, a pending one is placed. A span held by a span is fitted again by its own span
+ * after.
  */
-export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>): void;
+export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?: number): void;
 /** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */
 export declare function lingers<I, O>(span: Voice<I, O>, at: number): boolean;
 /** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */

package/dist/spans.js

@@ -46,11 +46,11 @@ export function checkChild(spec, child) {
     else if (!Number.isFinite(child.span))
         throw new Error('blits: a span cannot fit a voice that never ends');
 }
-/** A span's own clock at the mix's now, from 0 while it has not started. */
-function clockOf(mix, span) {
-    if (Number.isNaN(mix.now))
+/** A span's own clock at mix time `at`, from 0 while it has not started. */
+function clockOf(span, at) {
+    if (Number.isNaN(at))
         return 0;
-    const t = ownerReading(span, mix.now);
+    const t = ownerReading(span, at);
     return Number.isFinite(t) ? Math.max(0, t) : 0;
 }
 /** What a child's own clock reads at its span's `local`, 0 while it waits. */
@@ -63,15 +63,16 @@ function leftOf(child, local) {
     return Math.max(0, length - elapsedIn(child, local));
 }
 /**
- * Lays out a span's children and fits them into what is left of its budget, from its clock now.
- * Only what is still to come moves: a playing child keeps its place and may change rate, a
- * pending one is placed. A span held by a span is fitted again by its own span after.
+ * Lays out a span's children and fits them into what is left of its budget, from its clock at mix
+ * time `from`, default now. Only what is still to come moves: a playing child keeps its place and
+ * may change rate, a pending one is placed. A span held by a span is fitted again by its own span
+ * after.
  */
-export function refit(mix, span) {
+export function refit(mix, span, from = mix.now) {
     const fitting = span.fitting;
     if (mix.projecting || span.state === 'done')
         return;
-    const local = clockOf(mix, span);
+    const local = clockOf(span, from);
     const kids = (span.holding?.children ?? []).filter((c) => c.state !== 'done' && c.state !== 'frozen' && c.state !== 'fading' && leftOf(c, local) > 0);
     const claims = kids.map((c) => {
         const s = c.spec;
@@ -143,7 +144,7 @@ export function refit(mix, span) {
         fitting.end = end;
         noted(mix, span);
         if (span.owner?.fitting)
-            refit(mix, span.owner);
+            refit(mix, span.owner, from);
     }
 }
 /** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */

package/dist/strays.js

@@ -64,14 +64,18 @@ export function motionOwner(mix) {
         revive(id, subject) {
             const m = mix.deref();
             if (m === undefined)
-                return;
+                return Number.NaN;
             m.stir();
             const v = cuedById(m, id);
             if (v === undefined)
-                return;
+                return Number.NaN;
             if (v.motion !== undefined && v.named !== null && !v.named.has(subject))
                 stray(m, v.motion, subject);
+            if (v.parted?.has(subject) !== true)
+                return Number.NaN;
             unpart(m, v, subject);
+            // Its record is gone until it is next read, so its stagger is asked here as it will be there.
+            return timeIn(m, v, v.spec.stagger ? v.spec.stagger(subject) : 0);
         },
     };
 }
@@ -98,11 +102,15 @@ export function cuedById(mix, id) {
  * subject's own time is still short of its stagger. A retired voice's patch no longer asks.
  */
 export function frameOf(mix, voice, subject) {
-    if (Number.isNaN(mix.now) || voice.state === 'pending')
-        return Number.NaN;
     const held = voice.subjects.get(subject);
     if (held === undefined || !held.reaches)
         return Number.NaN;
-    const t = voice.elapsedAt(mix.now) - held.delay;
+    return timeIn(mix, voice, held.delay);
+}
+/** The voice time at the latest frame of a subject staggered by `delay`; NaN before it has any. */
+function timeIn(mix, voice, delay) {
+    if (Number.isNaN(mix.now) || voice.state === 'pending')
+        return Number.NaN;
+    const t = voice.elapsedAt(mix.now) - delay;
     return t < 0 ? Number.NaN : t;
 }

package/dist/transport.js

@@ -7,7 +7,7 @@ import { pin } from './place.js';
 import { projectAll } from './project.js';
 import { scoredDrop, scoredJoin } from './scored.js';
 import { seek } from './seek.js';
-import { record, replay, tapeOf } from './tape.js';
+import { hostAt, record, replay, tapeOf } from './tape.js';
 /** How far the tape's reach moves before it is pruned again, ms of mix time. */
 const TAPE_STEP_MS = 1000;
 /** Whether a change made in frame `seq` falls inside `cut`; `early` for one made before the frame was read. */
@@ -216,7 +216,9 @@ export class Transport {
         // In steps: the tape shifts every entry it keeps to let go of the oldest, and one a second
         // behind reach is never played again.
         if (this.tape !== undefined && history !== undefined && !(reach - this.taped < TAPE_STEP_MS)) {
-            this.tape.prune(reach);
+            const from = hostAt(this, reach);
+            if (from < Number.POSITIVE_INFINITY)
+                this.tape.prune(from);
             this.taped = reach;
         }
         if (history !== undefined && this.dropped.length > 0)

package/dist/types/mix.d.ts

@@ -192,8 +192,9 @@ export interface Mix<I, O, H = unknown> {
      */
     pull(subjects: Iterable<I>, into: Columns<O>): void;
     /**
-     * Reads the mix at another mix time, without moving it. Ahead of the mix it plays what is cued
-     * forward, and throws for a time past a call the tape will play again after a `seek` back, which
+     * Reads the mix at another mix time, without moving it. At the mix's own time it reads what
+     * `probe` does: what the host has done since the last sync lands at the next. Ahead of the mix
+     * it plays what is cued forward, and throws for a time past a call the tape will play again after a `seek` back, which
      * only a seek there makes; behind it, with `history`, it reads the last frame at or before `time`
      * as that frame showed, and throws for a time older than the history reaches. On a transport it
      * reads every mix on it together, so anchors across them answer.