@msb235/blits 0.15.1 → 0.16.1

package/dist/spans.js

@@ -1,12 +1,12 @@
 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';
 import { nextFrame } from './move.js';
 import { leave } from './origin.js';
-import { ownerReading } from './owner.js';
+import { ownerReading, plays } from './owner.js';
 import { resolve } from './place.js';
 /** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
 export class Fitting {
@@ -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) {
@@ -222,22 +314,23 @@ export function lingers(span, at) {
     const f = span.fitting;
     return f !== null && Number.isFinite(f.budget) && ownerReading(span, at) < f.budget;
 }
-/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+/**
+ * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
+ * 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 ((span.holding?.children.length ?? 0) > 0)
-            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/touch.js

@@ -1,5 +1,4 @@
 import { headOf } from './chain.js';
-import { restamp } from './everyone.js';
 import { nextFrame } from './move.js';
 /**
  * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
@@ -22,7 +21,7 @@ export function touch(mix, subject) {
             held.seeks = -1;
         const slot = headOf(mix, subject)?.slot ?? -1;
         for (const voice of mix.sharers)
-            restamp(voice, slot);
+            mix.share?.restamp(voice, slot);
     }
     mix.lanes?.refill();
     mix.stir();

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/turns.js

@@ -51,7 +51,8 @@ export function turnToward(ch, values, base, value, taken, u) {
     }
     const axes = ch.axes;
     let out = value;
-    if (taken !== 0) {
+    // A first value of other axes than the lane's, as an ink contribution is, widens through the lerp.
+    if (taken !== 0 || out.length !== axes) {
         held = lift(values, base, axes, held);
         out = ch.channel.lerp(held, value, u);
     }

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;

package/dist/types/voice.d.ts

@@ -249,8 +249,9 @@ export interface OwnerSpec<I, H = unknown> extends SpanHints {
     /**
      * Its clock's rate, multiplied into every child's own. Default 1. Below 0 its clock runs back,
      * and so does every child's: a child plays backward to its start and leaves there, as a voice cued
-     * backward does, and the owner leaves with its last child. A span is not cued backward, since it
-     * lays out its children forward from its start; its handle's `rate` turns it once it plays.
+     * backward does, and the owner leaves with its last child. Under `history` a child that already
+     * left runs back too: a child leaves only when its owner does. A span is not cued backward, since
+     * it lays out its children forward from its start; its handle's `rate` turns it once it plays.
      */
     rate?: number;
     /**

package/dist/voice.d.ts

@@ -2,6 +2,7 @@ import type { Arc } from './arcs.js';
 import type { Blend } from './blend.js';
 import type { Bound } from './bound.js';
 import { type Clock } from './clock.js';
+import { type Cut } from './cut.js';
 import { type Curve } from './easing.js';
 import type { Leavings } from './leavings.js';
 import type { Motions } from './motions.js';
@@ -11,10 +12,10 @@ import { Holding } from './owner.js';
 import { type Built, intosOf, type Scratch } from './patch.js';
 import type { Seat } from './seat.js';
 import { VoiceSetting } from './setting.js';
-import type { Fitting } from './spans.js';
+import { type Fitting } from './spans.js';
 import { Store } from './store.js';
 import type { Parted, Parting, Snap, Subject } from './subject.js';
-import type { Anchor, Channel, FadeSpec, Handle, Patch, VoiceSpec } from './types.js';
+import type { Anchor, Channel, FadeSpec, FitResult, Handle, Patch, VoiceSpec } from './types.js';
 export declare const none: readonly string[];
 /** A voice's clock, weight and fade from one mix time on, kept under `history`. */
 export interface Controls extends Clock {
@@ -24,6 +25,8 @@ export interface Controls extends Clock {
     weight: number;
     out: Ramp | null;
     back: Rise | null;
+    /** Absent from a store written before a voice kept them. */
+    stalls?: readonly number[] | null;
     /** Where its anchors had placed it then: start, and the start of an anchored fade out. */
     start: number;
     outAt: number;
@@ -35,9 +38,27 @@ export interface Controls extends Clock {
     hold: number;
     /** How many of the voice's past clocks it had then. */
     past: number;
+    /** The clocks a fit replaced; absent from a store written before a voice kept them. */
+    earlier?: Earlier | null;
+    /** The clocks its owner ran back before; absent from a store written before a voice kept them. */
+    later?: Earlier | null;
+    /** A span's end and how its fit came out; absent for any other voice. */
+    fitted?: {
+        end: number;
+        report: FitResult;
+    } | null;
     /** Shows in its own frame: made by a sync, or before anything read the mix that frame. */
     sync: boolean;
 }
+/**
+ * A clock a fit replaced, which its voice runs on again where its owner's clock runs back to
+ * before the one that replaced it, with whether the fit had skipped it; `prev` is the one before.
+ * In `later`, one its owner ran back before, taken again where the owner's clock reaches it.
+ */
+export interface Earlier extends Clock {
+    readonly skipped: boolean;
+    readonly prev: Earlier | null;
+}
 export interface Ramp {
     from: number;
     at: number;
@@ -46,6 +67,11 @@ export interface Ramp {
     deadline?: number;
     /** Begun where the voice ran back to its start, whose first frame it holds through the fade. */
     back?: boolean;
+    /**
+     * Begun where the passes of a voice an owner holds under history ran out: faded, it stays live
+     * and quiet with its owner, which brings it back by taking its clock back into its passes.
+     */
+    stays?: boolean;
 }
 /**
  * A climb back from a fade out that was turned around: from `from`, the place along the fade's
@@ -82,6 +108,11 @@ export declare class Voice<I, O> {
     out: Ramp | null;
     /** A fade out turned around, still climbing back; null once back in, or never turned. */
     back: Rise | null;
+    /**
+     * Where its fade in stood still under a fade out later turned around, as pairs of mix times,
+     * from and to; null where it never did. Replaced, never changed, so a noted copy stays good.
+     */
+    stalls: readonly number[] | null;
     subjects: Store<I, Subject<unknown>>;
     /** The subjects its spec names, or null where it names none. */
     readonly named: Named<I> | null;
@@ -165,6 +196,10 @@ export declare class Voice<I, O> {
     early: Subject<unknown>[] | null;
     /** The clocks it ran on before its current one, where a subject's origin may lie; null for none. */
     clocks: Past[] | null;
+    /** The clocks a fit replaced, latest first; null for none. */
+    earlier: Earlier | null;
+    /** The clocks its owner's clock ran back before, which it takes again going forward, soonest first. */
+    later: Earlier | null;
     /** Reused for every call this voice makes, so it is valid only during the call. */
     readonly setting: VoiceSetting<I, O>;
     /** Every subject this voice has been asked about, so a handover knows when it is finished. */
@@ -180,6 +215,11 @@ export declare class Voice<I, O> {
     cuedAt: number;
     /** The frame it was cued in. */
     cuedSeq: number;
+    /**
+     * The frame it last went live in, Infinity while pending: a seek of an owner back before its
+     * start leaves it live, which a read back by its clock alone would take for still to start.
+     */
+    begunSeq: number;
     /** The mix time it left at, which a fade or seek given a time already passed puts behind now. */
     doneAt: number;
     /** The frame its leaving was decided in, which a seek or read back partitions by. */
@@ -200,6 +240,8 @@ export declare class Voice<I, O> {
     outSet: boolean;
     /** The host time a pinned start was given at, NaN for none: a seek back pins it again. */
     pinned: number;
+    /** The mix's offset when it was cued: a timestamp in its anchor converts at this one. */
+    offset: number;
     /** Cued with no start while its mix slept, so the next sync sets its start. */
     waking: boolean;
     /** Whether its start is still to be fixed by an anchor, so it waits pending. */
@@ -326,6 +368,21 @@ export declare class Voice<I, O> {
      * turn it around.
      */
     endsAt(): number;
+    /** The mix time its clock reads `elapsed`, by its controls now, through every owner above it. */
+    reaches(elapsed: number): number;
+    /**
+     * Its state at mix time `t`, from its clock and fade, once every clock above it is back where it
+     * was: a fade begins at once, even one whose ramp starts later, at the voice's start, and one
+     * from where an owner under history keeps it ends with it quiet and live. With `cut`, one that
+     * had started by then is live, though an owner's seek has put its clock back before its start.
+     */
+    stateAt(t: number, cut?: Cut): Voice<I, O>['state'];
+    /**
+     * Whether it is kept quiet past its passes at mix time `now`: its passes ran out while an owner
+     * held it under history, and its clock has not come back into them. At their very edge it is
+     * quiet unless its clock runs into them.
+     */
+    quietAt(now: number): boolean;
     /**
      * The mix time its clock ran back to `elapsed` by `now`, by its controls now: where a subject
      * `elapsed` into it reached its start. NaN where it has not, and for a voice an owner holds.

package/dist/voice.js

@@ -1,10 +1,12 @@
 import { backWith, elapsedWith, frozenTime, passesOf, rateWith, rebaseWith, timeWith, } from './clock.js';
+import { within } from './cut.js';
 import { curve } from './easing.js';
 import { motionOf } from './motion.js';
 import { Named } from './named.js';
-import { childPlayed, Holding, mixTime, ownedElapsed, ownerPatch, ownerReading, turnedBack, } from './owner.js';
+import { childPlayed, Holding, mixTime, ownedElapsed, ownerPatch, ownerReading, plays, turnedBack, } from './owner.js';
 import { builtOf, intosOf } from './patch.js';
 import { keeping, VoiceSetting } from './setting.js';
+import { lingers } from './spans.js';
 import { Filled, Store } from './store.js';
 import { warnOnce } from './warn.js';
 export const none = Object.freeze([]);
@@ -52,6 +54,11 @@ export class Voice {
     out = null;
     /** A fade out turned around, still climbing back; null once back in, or never turned. */
     back = null;
+    /**
+     * Where its fade in stood still under a fade out later turned around, as pairs of mix times,
+     * from and to; null where it never did. Replaced, never changed, so a noted copy stays good.
+     */
+    stalls = null;
     subjects = new Store();
     /** The subjects its spec names, or null where it names none. */
     named;
@@ -137,6 +144,10 @@ export class Voice {
     early = null;
     /** The clocks it ran on before its current one, where a subject's origin may lie; null for none. */
     clocks = null;
+    /** The clocks a fit replaced, latest first; null for none. */
+    earlier = null;
+    /** The clocks its owner's clock ran back before, which it takes again going forward, soonest first. */
+    later = null;
     /** Reused for every call this voice makes, so it is valid only during the call. */
     setting;
     /** Every subject this voice has been asked about, so a handover knows when it is finished. */
@@ -152,6 +163,11 @@ export class Voice {
     cuedAt = Number.NEGATIVE_INFINITY;
     /** The frame it was cued in. */
     cuedSeq = Number.NEGATIVE_INFINITY;
+    /**
+     * The frame it last went live in, Infinity while pending: a seek of an owner back before its
+     * start leaves it live, which a read back by its clock alone would take for still to start.
+     */
+    begunSeq = Number.POSITIVE_INFINITY;
     /** The mix time it left at, which a fade or seek given a time already passed puts behind now. */
     doneAt = Number.POSITIVE_INFINITY;
     /** The frame its leaving was decided in, which a seek or read back partitions by. */
@@ -174,6 +190,8 @@ export class Voice {
     outSet = false;
     /** The host time a pinned start was given at, NaN for none: a seek back pins it again. */
     pinned = Number.NaN;
+    /** The mix's offset when it was cued: a timestamp in its anchor converts at this one. */
+    offset = 0;
     /** Cued with no start while its mix slept, so the next sync sets its start. */
     waking = false;
     /** Whether its start is still to be fixed by an anchor, so it waits pending. */
@@ -327,12 +345,20 @@ export class Voice {
         this.weight = c.weight;
         this.out = c.out;
         this.back = c.back;
+        this.stalls = c.stalls ?? null;
         this.start = c.start;
         this.outAt = c.outAt;
         this.outOver = c.outOver;
         this.outSet = c.outSet;
         this.rebuilds = c.rebuilds;
         this.hold = c.hold;
+        this.earlier = c.earlier ?? null;
+        this.later = c.later ?? null;
+        const fitted = c.fitted;
+        if (fitted && this.fitting !== null) {
+            this.fitting.end = fitted.end;
+            this.fitting.report = fitted.report;
+        }
         const clocks = this.clocks;
         if (clocks !== null && clocks.length !== c.past)
             this.clocks = c.past === 0 ? null : clocks.slice(0, c.past);
@@ -365,6 +391,7 @@ export class Voice {
         this.restedCount = 0;
         this.cuedAt = Number.NEGATIVE_INFINITY;
         this.cuedSeq = Number.NEGATIVE_INFINITY;
+        this.begunSeq = Number.POSITIVE_INFINITY;
         this.doneAt = Number.POSITIVE_INFINITY;
         this.doneSeq = Number.POSITIVE_INFINITY;
         this.placing = false;
@@ -472,9 +499,52 @@ export class Voice {
                 return Number.POSITIVE_INFINITY;
             to = this.span + this.latest;
         }
-        const t = backs ? backWith(this, to) : timeWith(this, to);
+        return this.reaches(to);
+    }
+    /** The mix time its clock reads `elapsed`, by its controls now, through every owner above it. */
+    reaches(elapsed) {
+        const t = this.backs ? backWith(this, elapsed) : timeWith(this, elapsed);
         return this.owner === null ? t : mixTime(this.owner, t);
     }
+    /**
+     * Its state at mix time `t`, from its clock and fade, once every clock above it is back where it
+     * was: a fade begins at once, even one whose ramp starts later, at the voice's start, and one
+     * from where an owner under history keeps it ends with it quiet and live. With `cut`, one that
+     * had started by then is live, though an owner's seek has put its clock back before its start.
+     */
+    stateAt(t, cut) {
+        const out = this.out;
+        if (out !== null)
+            return out.stays && t >= out.at + out.over ? 'live' : 'fading';
+        if ((this.owner === null ? t : ownerReading(this.owner, t)) < this.start &&
+            !(cut !== undefined && within(cut, this.begunSeq, true)))
+            return 'pending';
+        if (this.freezesAfter && this.elapsedAt(t) >= this.span + this.latest)
+            return 'frozen';
+        return 'live';
+    }
+    /**
+     * Whether it is kept quiet past its passes at mix time `now`: its passes ran out while an owner
+     * held it under history, and its clock has not come back into them. At their very edge it is
+     * quiet unless its clock runs into them.
+     */
+    quietAt(now) {
+        const out = this.out;
+        if (this.state !== 'live' || out?.stays !== true)
+            return false;
+        // An owner kept quiet while its children were, rather than run back to its start.
+        if (this.holding !== null && out.back !== true)
+            return !plays(this, now) && !lingers(this, now);
+        // A fit that skipped it put it at its end at its start, so before its start it plays nothing.
+        if (this.skipped && ownerReading(this.owner, now) < this.start)
+            return true;
+        const at = this.elapsedAt(now);
+        const end = this.span + this.latest;
+        const back = this.backs !== (this.owner !== null && turnedBack(this));
+        if (at > end || (at === end && !back))
+            return true;
+        return !this.beginless && (at < this.soonest || (at === this.soonest && back));
+    }
     /**
      * The mix time its clock ran back to `elapsed` by `now`, by its controls now: where a subject
      * `elapsed` into it reached its start. NaN where it has not, and for a voice an owner holds.
@@ -545,6 +615,7 @@ export class Voice {
             weight: this.weight,
             out: this.out,
             back: this.back,
+            stalls: this.stalls,
             start: this.start,
             outAt: this.outAt,
             outOver: this.outOver,
@@ -552,6 +623,9 @@ export class Voice {
             rebuilds: this.rebuilds,
             hold: this.hold,
             past: this.clocks?.length ?? 0,
+            earlier: this.earlier,
+            later: this.later,
+            fitted: this.fitting === null ? null : { end: this.fitting.end, report: this.fitting.report },
         });
     }
     /**

package/dist/weigh.js

@@ -60,7 +60,7 @@ export function horizonFor(voice, delay, now) {
 }
 /** The ramp a voice's own fade envelope applies this frame, 0..1. */
 export function fadeOf(voice, now, since) {
-    return envelope(voice.fade.in ?? 0, voice.out, voice.ease, this.reducedNow, now, since, voice.back);
+    return envelope(voice.fade.in ?? 0, voice.out, voice.ease, this.reducedNow, now, since, voice.back, voice.stalls);
 }
 /** What every owner above a voice multiplies into its weight for a subject this frame. */
 export function ownedBy(voice, subject) {