@msb235/blits 0.16.0 → 0.16.1

package/dist/project.d.ts

@@ -12,8 +12,11 @@ import type { Voice } from './voice.js';
 export declare function projectAll(transport: Transport, at: number | {
     readonly frame: number;
 }): TransportProjection;
-/** Sets each copied voice's state to what its clock and fade make it at `t`. */
-export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
+/**
+ * Sets each copied voice's state to what its clock and fade make it at `t`; with `cut`, the frames
+ * up to which history says which had started.
+ */
+export declare function stateAt<I, O>(c: Mixer<I, O>, t: number, cut?: Cut): 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.

package/dist/project.js

@@ -178,13 +178,16 @@ function copyBack(mix, c, t, cut) {
     ownBlends(c.cued);
     if (mix.owners !== null)
         relink(c.cued, cut.seq);
-    stateAt(c, t);
+    stateAt(c, t, cut);
     recount(c);
 }
-/** Sets each copied voice's state to what its clock and fade make it at `t`. */
-export function stateAt(c, t) {
+/**
+ * Sets each copied voice's state to what its clock and fade make it at `t`; with `cut`, the frames
+ * up to which history says which had started.
+ */
+export function stateAt(c, t, cut) {
     for (const copy of c.cued)
-        copy.state = copy.stateAt(t);
+        copy.state = copy.stateAt(t, cut);
 }
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its

package/dist/qualify.js

@@ -96,7 +96,11 @@ export function requalify(lanes, version) {
             crowded++;
             continue;
         }
-        const lane = lanes.byId.get(v.id) ?? new Lane(v);
+        let lane = lanes.byId.get(v.id);
+        if (lane === undefined) {
+            lane = new Lane(v);
+            lane.made = lanes.probes;
+        }
         v.laned = true;
         if (lane.epoch === 0 && v.state !== 'pending')
             opened(lanes, lane);
@@ -395,6 +399,7 @@ function placeAll(lanes, lane) {
  */
 function enlane(lanes, v) {
     const lane = new Lane(v);
+    lane.made = lanes.probes;
     v.laned = true;
     if (v.state !== 'pending')
         opened(lanes, lane);

package/dist/rests.js

@@ -56,7 +56,15 @@ export function still(voice, now) {
     if (voice.state === 'frozen' || voice.holding !== null)
         return true;
     const motion = voice.motion;
-    return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();
+    if (motion === undefined || !(voice.elapsedAt(now) >= voice.latest))
+        return false;
+    // A subject met inside its stagger and not read since has no run yet, and moves once it is.
+    const early = voice.early;
+    if (early !== null)
+        for (const h of early)
+            if (h.since <= now && !(h.probed >= h.since))
+                return false;
+    return motion.landed();
 }
 export function restsLaned() {
     return this.lanes.whole && this.bounded.length === 0;

package/dist/revive.d.ts

@@ -5,7 +5,7 @@ import { type Key } from './paging.js';
 import type { Run } from './stretch.js';
 import type { Parted, Parting } from './subject.js';
 import type { Described } from './types.js';
-import { type Controls, type Ramp, type Rise, Voice } from './voice.js';
+import { type Controls, type Earlier, type Ramp, type Rise, Voice } from './voice.js';
 /** A voice that has left, as plain data: the descriptor it was cued with, its controls and its records. */
 interface PackedVoice {
     as: Described;
@@ -21,6 +21,8 @@ interface PackedVoice {
     weight: number;
     out: Ramp | null;
     back: Rise | null;
+    /** Absent from a store written before a voice kept them. */
+    stalls?: readonly number[] | null;
     outAt: number;
     outOver: number;
     outSet: boolean;
@@ -28,12 +30,20 @@ interface PackedVoice {
     hold: number;
     past: number;
     clocks: Past[] | null;
+    /** Absent from a store written before a voice kept it. */
+    earlier?: Earlier | null;
+    /** Absent from a store written before a voice kept it. */
+    later?: Earlier | null;
     cuedAt: number;
     cuedSeq: number;
+    /** Absent from a store written before a voice kept it. */
+    begunSeq?: number;
     doneAt: number;
     doneSeq: number;
     opened: number;
     pinned: number;
+    /** Absent from a store written before a voice kept it. */
+    offset?: number;
     latest: number;
     /** Absent from a store written before a voice kept it. */
     soonest?: number;

package/dist/revive.js

@@ -79,19 +79,24 @@ function packVoice(voice, keys) {
         weight: voice.weight,
         out: voice.out,
         back: voice.back,
+        stalls: voice.stalls,
         outAt: voice.outAt,
         outOver: voice.outOver,
         outSet: voice.outSet,
         rebuilds: voice.rebuilds,
         hold: voice.hold,
         past: voice.clocks?.length ?? 0,
+        earlier: voice.earlier,
+        later: voice.later,
         clocks: voice.clocks,
         cuedAt: voice.cuedAt,
         cuedSeq: voice.cuedSeq,
+        begunSeq: voice.begunSeq,
         doneAt: voice.doneAt,
         doneSeq: voice.doneSeq,
         opened: voice.opened,
         pinned: voice.pinned,
+        offset: voice.offset,
         latest: voice.latest,
         soonest: voice.soonest,
         keeping: voice.keeping,
@@ -127,10 +132,12 @@ export function reviveVoice(mix, id, d) {
     voice.take(d);
     voice.cuedAt = d.cuedAt;
     voice.cuedSeq = d.cuedSeq;
+    voice.begunSeq = d.begunSeq ?? Number.POSITIVE_INFINITY;
     voice.doneAt = d.doneAt;
     voice.doneSeq = d.doneSeq;
     voice.opened = d.opened;
     voice.pinned = d.pinned;
+    voice.offset = d.offset ?? 0;
     voice.latest = d.latest;
     voice.soonest = d.soonest ?? 0;
     voice.keeping = d.keeping;

package/dist/roles.js

@@ -58,9 +58,12 @@ export function foldRoles(subject, pose, head, laned, dry, except, owed) {
                 this.lanes.paid(voice.id, owed, held.weight);
             if (!mine)
                 q = this.shared(voice, head.slot, held, q);
-            if (delta === null)
-                continue;
             const role = voice.spec.role;
+            if (delta === null) {
+                if (role === undefined && !(held.weight > 0))
+                    unband(held);
+                continue;
+            }
             let group = -1;
             if (role !== undefined) {
                 group = k.names.indexOf(role);

package/dist/rows.js

@@ -106,7 +106,7 @@ export function join(lanes, v, from, at, old) {
         newRow(lanes, c, p, v);
     if (c.hot[p * c.stride + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
         c.hot[p * c.stride + 6 /* Hot.EPOCH */] = open(lanes, v);
-    const seat = new Seat(lanes, c, p);
+    const seat = new Seat(lanes, c, p, from === undefined ? lanes.probes : 0);
     lanes.seats.set(v.id, seat);
     v.seat = seat;
     v.laned = true;
@@ -298,5 +298,8 @@ export function reportedRow(lanes, c, p, slot) {
         return undefined;
     if (c.list[p] !== slot)
         return undefined;
+    const made = seatOf(lanes, c.voices[p])?.made ?? 0;
+    if (!(lanes.per[o + 3 /* Per.LANE_PROBE */] > made))
+        return undefined;
     return c.data[p * 8 /* Row.STRIDE */ + (lanes.per[o + 5 /* Per.LANE_FILL */] === lanes.fills ? 2 /* Row.WEIGHT */ : 3 /* Row.PROBED */)];
 }

package/dist/seat.d.ts

@@ -9,7 +9,11 @@ export declare class Seat<I, O> {
     lanes: object | null;
     readonly crowd: Crowd<I, O>;
     row: number;
-    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number);
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    readonly made: number;
+    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number, 
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    made?: number);
 }
 /** `voice`'s seat in `lanes`, null where it has none there. */
 export declare function seatOf<I, O>(lanes: object, voice: Voice<I, O>): Seat<I, O> | null;

package/dist/seat.js

@@ -7,10 +7,14 @@ export class Seat {
     lanes;
     crowd;
     row;
-    constructor(lanes, crowd, row) {
+    made;
+    constructor(lanes, crowd, row, 
+    /** The lanes' probe count when its row was made new, 0 for a row copied from another crowd. */
+    made = 0) {
         this.lanes = lanes;
         this.crowd = crowd;
         this.row = row;
+        this.made = made;
     }
 }
 /** `voice`'s seat in `lanes`, null where it has none there. */

package/dist/seek.js

@@ -11,7 +11,6 @@ import { unpull } from './pull.js';
 import { isRested } from './record.js';
 import { Restored } from './restored.js';
 import { recount } from './roster.js';
-import { refitAll } from './spans.js';
 import { Store } from './store.js';
 import { hostAhead, hostAt, replay } from './tape.js';
 import { cover, coverFrame, cut } from './unpage.js';
@@ -321,8 +320,12 @@ function back(mix, t, seq, on) {
             kept.push(voice);
     for (const voice of kept)
         restoreVoice(mix, voice, t, seq);
-    for (const voice of kept)
-        voice.state = voice.stateAt(t);
+    const cut = { seq, strict: false };
+    for (const voice of kept) {
+        voice.state = voice.stateAt(t, cut);
+        if (voice.begunSeq > seq)
+            voice.begunSeq = Number.POSITIVE_INFINITY;
+    }
     mix.cued = kept;
     mix.gone = gone;
     mix.retired = [];
@@ -388,7 +391,6 @@ function back(mix, t, seq, on) {
             mix.pins ??= new Map();
             mix.pins.set(voice, voice.pinned);
         }
-    refitAll(mix);
     mix.due.clear();
     for (const voice of kept)
         schedule(mix, voice);

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.16.0";
+export declare const release = "0.16.1";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.16.0';
+export const release = '0.16.1';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/spans.d.ts

@@ -15,11 +15,17 @@ 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;
+/**
+ * Puts a child whose owner's clock ran back to before a fit changed its rate, or skipped it, back
+ * on the clock it ran on before, so it reads, run back over, what it read going forward; and once
+ * the owner's clock reaches that change again, takes the change again, as the layout stands.
+ */
+export declare function unfit<I, O>(mix: Mixer<I, O>, child: Voice<I, O>, now: number): void;
 /**
  * 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.
+ * after. A span its clock ran back over keeps the layout it made going forward.
  */
 export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?: number): void;
 /**
@@ -31,8 +37,8 @@ export declare function refloor<I, O>(mix: Mixer<I, O>): void;
 export declare function lingers<I, O>(span: Voice<I, O>, at: number): boolean;
 /**
  * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
- * ran out.
+ * ran out, or, under history, stay quiet with an owner holding them.
  */
 export declare function lapse<I, O>(mix: Mixer<I, O>, now: number): void;
-/** Fits every span again, as after a seek put its children back. */
-export declare function refitAll<I, O>(mix: Mixer<I, O>): void;
+/** Whether a span's budget is out by `now` with no child of it still playing. */
+export declare function lapses<I, O>(span: Voice<I, O>, now: number): boolean;

package/dist/spans.js

@@ -1,6 +1,6 @@
 import { arcEnd } from './arcs.js';
 import { elapsedWith, retime } from './clock.js';
-import { retire } from './fade.js';
+import { release } from './fade.js';
 import { defaultFit, layout, settle } from './fit.js';
 import { reorigin } from './held.js';
 import { noted } from './history.js';
@@ -52,40 +52,115 @@ export function checkChild(spec, child) {
     else if (!Number.isFinite(child.span))
         throw new Error('blits: a span cannot fit a voice that never ends');
 }
+/**
+ * Whether a span's clock went back over a child at span ms `local`: it holds one kept quiet that
+ * ran back to its start, or that starts after `local`, which only a clock gone back leaves quiet.
+ * Its layout up to there was made going forward, and stands until the clock passes it again.
+ */
+function ranBackOver(span, local) {
+    for (const child of span.holding.children)
+        if (child.out?.stays === true && (child.out.back === true || child.start > local))
+            return true;
+    return false;
+}
+/**
+ * Puts a child whose owner's clock ran back to before a fit changed its rate, or skipped it, back
+ * on the clock it ran on before, so it reads, run back over, what it read going forward; and once
+ * the owner's clock reaches that change again, takes the change again, as the layout stands.
+ */
+export function unfit(mix, child, now) {
+    const t = ownerReading(child.owner, now);
+    let moved = false;
+    for (let e = child.earlier; e !== null && t < child.anchorNow; e = child.earlier) {
+        child.later = { ...standing(child), prev: child.later };
+        take(child, e);
+        child.earlier = e.prev;
+        moved = true;
+    }
+    for (let e = child.later; e !== null && t >= e.anchorNow; e = child.later) {
+        child.earlier = { ...standing(child), prev: child.earlier };
+        take(child, e);
+        child.later = e.prev;
+        moved = true;
+    }
+    if (!moved)
+        return;
+    mix.frame = nextFrame();
+    reorigin(mix, child, now);
+    noted(mix, child);
+    mix.lanes?.refill();
+}
+/** A child's clock as it stands, and whether a fit skipped it. */
+function standing(c) {
+    const { anchorNow, anchorElapsed, rate, ramp, skipped } = c;
+    return { anchorNow, anchorElapsed, rate, ramp, skipped };
+}
+/** Puts a child on a clock it had, which jumps where a fit skipped it on one and not the other. */
+function take(c, e) {
+    c.anchorNow = e.anchorNow;
+    c.anchorElapsed = e.anchorElapsed;
+    c.rate = e.rate;
+    c.ramp = e.ramp;
+    if (c.skipped !== e.skipped)
+        c.seeks++;
+    c.skipped = e.skipped;
+}
 /** 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, at);
+    const t = readingAt(span, at);
     return Number.isFinite(t) ? Math.max(0, t) : 0;
 }
+/**
+ * What a voice's clock reads at mix time `at` through its owners' clocks as they stand, inverting
+ * `mixTime`: -Infinity where one yet to start has not reached its start. Unlike `ownerReading`, an
+ * owner that has started reads on its clock before its start, where a seek of the owner put a time
+ * its children left at.
+ */
+function readingAt(voice, at) {
+    const t = voice.owner === null ? at : readingAt(voice.owner, at);
+    if (t === Number.NEGATIVE_INFINITY || (voice.state === 'pending' && !(t >= voice.start)))
+        return Number.NEGATIVE_INFINITY;
+    return elapsedWith(voice, t);
+}
+/**
+ * Whether a child has started, or would have by span ms `by` had a frame come between: a fit from a
+ * moment between frames keeps a child whose start that moment had passed where it is.
+ */
+function begun(child, by) {
+    return child.state !== 'pending' || child.start < by;
+}
 /** What a child's own clock reads at its span's `local`, 0 while it waits. */
-function elapsedIn(child, local) {
-    return child.state === 'pending' ? 0 : Math.max(0, elapsedWith(child, local));
+function elapsedIn(child, local, by) {
+    return begun(child, by) ? Math.max(0, elapsedWith(child, local)) : 0;
 }
 /** How much of a child is left, voice ms at its own clock: what its span still has to fit. */
-function leftOf(child, local) {
+function leftOf(child, local, by) {
     const length = child.fitting !== null ? child.fitting.end : child.arc !== null ? arcEnd(child) : child.span;
-    return Math.max(0, length - elapsedIn(child, local));
+    return Math.max(0, length - elapsedIn(child, local, by));
 }
 /**
  * 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.
+ * after. A span its clock ran back over keeps the layout it made going forward.
  */
 export function refit(mix, span, from = mix.now) {
     const fitting = span.fitting;
     if (mix.projecting || span.state === 'done')
         return;
     const local = clockOf(span, from);
-    const { kids, floors, waiting } = lineUp(mix, span, local);
+    if (ranBackOver(span, local))
+        return;
+    const by = from < mix.now ? local : Number.NEGATIVE_INFINITY;
+    const { kids, floors, waiting } = lineUp(mix, span, local, by);
     const claims = kids.map((c, i) => {
         const s = c.spec;
         return {
             floor: floors[i],
-            natural: leftOf(c, local) / (s.rate ?? 1),
-            state: c.state === 'pending' ? 'pending' : 'playing',
+            natural: leftOf(c, local, by) / (s.rate ?? 1),
+            state: begun(c, by) ? 'playing' : 'pending',
             faster: Math.max(1, s.faster ?? 1),
             slower: Math.max(1, s.slower ?? 1),
             overlap: s.overlap === true,
@@ -99,9 +174,10 @@ export function refit(mix, span, from = mix.now) {
     kids.forEach((c, i) => {
         const rate = (c.spec.rate ?? 1) * plan.rate[i];
         const skipped = plan.skip[i] && c.holding === null;
+        const wasSkipped = c.skipped;
         c.skipped = skipped;
         let moved = false;
-        if (c.state === 'pending') {
+        if (!begun(c, by)) {
             const start = local + at[i];
             const elapsed = skipped ? c.span : 0;
             if (c.start !== start || c.rate !== rate || c.anchorElapsed !== elapsed || c.ramp !== null) {
@@ -111,10 +187,16 @@ export function refit(mix, span, from = mix.now) {
                 c.rate = rate;
                 c.ramp = null;
                 c.clocks = null;
+                c.earlier = null;
+                c.later = null;
                 moved = true;
             }
         }
         else {
+            if (skipped || c.rate !== rate || c.ramp !== null) {
+                c.earlier = { ...standing(c), skipped: wasSkipped, prev: c.earlier };
+                c.later = null;
+            }
             if (skipped) {
                 leave(c, local);
                 c.rebase(local);
@@ -141,6 +223,8 @@ export function refit(mix, span, from = mix.now) {
         c.anchorNow = Number.POSITIVE_INFINITY;
         c.anchorElapsed = 0;
         c.clocks = null;
+        c.earlier = null;
+        c.later = null;
         mix.frame = nextFrame();
         reorigin(mix, c, mix.now);
         noted(mix, c);
@@ -151,19 +235,26 @@ export function refit(mix, span, from = mix.now) {
     const over = Number.isFinite(fitting.budget) ? Math.max(0, reach - fitting.budget) : 0;
     const within = over < 1e-6;
     const end = !Number.isFinite(fitting.budget) ? reach : within ? fitting.budget : reach;
-    fitting.report = {
+    const was = fitting.report;
+    const report = {
         budget: fitting.budget,
         length: reach,
         over: within ? 0 : over,
         skipped: plan.skip.filter((s, i) => s && kids[i]?.holding === null).length,
         fell,
     };
+    fitting.report = report;
     if (end !== fitting.end) {
         fitting.end = end;
         noted(mix, span);
         if (span.owner?.fitting)
             refit(mix, span.owner, from);
     }
+    else if (report.length !== was.length ||
+        report.over !== was.over ||
+        report.skipped !== was.skipped ||
+        report.fell !== was.fell)
+        noted(mix, span);
 }
 /**
  * A span's children still to fit, in the order it lays them out: those playing first, as cued, then
@@ -171,13 +262,14 @@ export function refit(mix, span, from = mix.now) {
  * from `local`, and before `local` only in the frame it was cued. One whose anchor has no answer yet waits unplaced, and under `queue` or `stagger`
  * so does every child after it, since each is laid out from the one before.
  */
-function lineUp(mix, span, local) {
-    const live = (span.holding?.children ?? []).filter((c) => c.state !== 'done' && c.state !== 'frozen' && c.state !== 'fading' && leftOf(c, local) > 0);
-    const kids = live.filter((c) => c.state !== 'pending');
+function lineUp(mix, span, local, by) {
+    // A child fading, or kept quiet past its passes, has nothing left to fit.
+    const live = (span.holding?.children ?? []).filter((c) => c.state !== 'done' && c.state !== 'frozen' && c.out === null && leftOf(c, local, by) > 0);
+    const kids = live.filter((c) => begun(c, by));
     const floors = kids.map(() => undefined);
     const waiting = [];
     const pending = live
-        .filter((c) => c.state === 'pending')
+        .filter((c) => !begun(c, by))
         .sort((a, b) => (a.spec.rank ?? 0) - (b.spec.rank ?? 0));
     const chained = span.fitting.claim.order !== 'together';
     for (const c of pending) {
@@ -224,23 +316,21 @@ export function lingers(span, at) {
 }
 /**
  * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
- * ran out.
+ * ran out, or, under history, stay quiet with an owner holding them.
  */
 export function lapse(mix, now) {
-    for (const span of mix.owners ?? []) {
-        const f = span.fitting;
-        if (f === null || span.state === 'done' || !Number.isFinite(f.budget))
-            continue;
-        if (plays(span, now))
-            continue;
-        if (ownerReading(span, now) >= f.budget)
-            retire(mix, span, span.timeAt(f.budget));
+    const owners = mix.owners ?? [];
+    // Those held first, cued after what holds them, so a span whose last span lapses goes with it.
+    for (let i = owners.length - 1; i >= 0; i--) {
+        const span = owners[i];
+        if (span.out?.stays !== true && lapses(span, now))
+            release(mix, span, span.timeAt(span.fitting.budget));
     }
 }
-/** Fits every span again, as after a seek put its children back. */
-export function refitAll(mix) {
-    const spans = (mix.owners ?? []).filter((v) => v.fitting !== null);
-    // Later cued first, so a span held by a span is fitted before the one holding it.
-    for (let i = spans.length - 1; i >= 0; i--)
-        refit(mix, spans[i]);
+/** Whether a span's budget is out by `now` with no child of it still playing. */
+export function lapses(span, now) {
+    const f = span.fitting;
+    if (f === null || span.state === 'done' || !Number.isFinite(f.budget))
+        return false;
+    return !plays(span, now) && ownerReading(span, now) >= f.budget;
 }

package/dist/trace.js

@@ -151,6 +151,8 @@ function shapeOf(mix, voice, subject, from, to, plan) {
         return false;
     if (voice.ramp !== null || !(voice.rate > 0) || voice.out !== null || voice.back !== null)
         return false;
+    if (voice.stalls !== null)
+        return false;
     if (voice.parts !== null || voice.parted !== null || voice.left !== null)
         return false;
     if (Number.isFinite(voice.outAt) || voice.state === 'fading')
@@ -190,9 +192,12 @@ function shapeOf(mix, voice, subject, from, to, plan) {
     at(ends);
     if (!voice.freezesAfter && Number.isFinite(ends)) {
         const over = reduced ? 0 : Number.isNaN(voice.outOver) ? (voice.fade.out ?? 0) : voice.outOver;
+        // Ended before its start, as a seek past its end leaves it, it fades from its start.
+        const fades = Math.max(voice.start, ends);
+        at(fades);
         if (over > 0) {
-            bent.push([ends, ends + over]);
-            at(ends + over);
+            bent.push([fades, fades + over]);
+            at(fades + over);
         }
         // It leaves when its latest subject ends, which a subject first met later can move.
         if (spec.stagger !== undefined)

package/dist/types/transport.d.ts

@@ -45,7 +45,8 @@ export interface Transport {
     /**
      * Loads from the history `store` what a seek or projection to `time` will need. That is, what
      * `seek(time)` and `project(time)` need where it reaches past memory. Without a store, or within
-     * memory, it loads nothing.
+     * memory, it loads nothing. What it loads is kept until a seek or read takes it, or until
+     * `history.ms` of mix time passes, after which the time needs `prepare` again.
      */
     prepare(time: number): Promise<void>;
     readonly now: number;