@msb235/blits 0.15.1 → 0.16.0

package/dist/motions.js

@@ -1,5 +1,6 @@
 import { applied, change, commit, cut, dueTo, insert, peek, queue, rewind } from './changes.js';
-import { closed } from './closed.js';
+import { BOUND, closed } from './closed.js';
+import { closedLch } from './lch.js';
 import { made, pack, prune, reclaim, release, restretch, runAt, runThen, unpack, unrelease, } from './lives.js';
 import { absent, Numbers } from './numbers.js';
 import { reading } from './reading.js';
@@ -16,6 +17,7 @@ const PENDING = 2 /* RunFlag.PENDING */;
 const OLDER = 4 /* RunFlag.OLDER */;
 const LANDED = 8 /* RunFlag.LANDED */;
 const wrongKind = (channel, holdsNumber) => new Error(`blits: channel ${channel} holds ${holdsNumber ? 'a number' : 'an array'}, and this motion patch gives a subject ${holdsNumber ? 'an array' : 'a number'}`);
+const notOklab = (channel) => new Error(`blits: channel ${channel} goes round the hue, and a motion on it moves oklab() values, four numbers each`);
 /**
  * A motion patch's subjects: the stretch each is playing, in one flat array by a number the patch
  * gives it, with earlier stretches a read back may reach and changes not yet applied beside them.
@@ -68,11 +70,18 @@ export class Motions {
     /** Whether the channel it was cued on holds a number; undefined until it is cued. */
     holdsNumber = undefined;
     channel = '';
+    /** Whether the channel it was cued on travels round the hue, as `ink` does, and its stretches too. */
+    round = false;
     /**
      * Records what the channel the patch is cued on holds, refusing a value of the other kind: at once
      * where every subject's value is one kind, else on the first sample of a subject whose value is not.
+     * `round` for a channel that travels round the hue, as `ink` does.
      */
-    cuedOn(channel, holdsNumber) {
+    cuedOn(channel, holdsNumber, round = false) {
+        if (round && this.shape.law[0] === BOUND)
+            throw new Error(`blits: channel ${channel} goes round the hue, and a glide's bounds are a box on its OKLab axes; glide it without bounds`);
+        if (round && this.n >= 0 && this.n !== 4)
+            throw notOklab(channel);
         const every = this.shape.scalarEvery();
         if (every !== undefined && every !== holdsNumber)
             throw wrongKind(channel, holdsNumber);
@@ -82,6 +91,7 @@ export class Motions {
                 throw wrongKind(channel, holdsNumber);
         this.holdsNumber = holdsNumber;
         this.channel = channel;
+        this.round = round;
     }
     frame(subject) {
         return this.owner === null ? Number.NaN : this.owner.frame(this.ownerId, subject);
@@ -127,6 +137,8 @@ export class Motions {
     }
     /** Sets the axes every subject moves on, at the first. */
     size(n) {
+        if (this.round && n !== 4)
+            throw notOklab(this.channel);
         this.n = n;
         this.stride = 3 + 3 * n;
         if (shared.xs.length < n)
@@ -426,6 +438,8 @@ export class Motions {
         this.evaluate(seg.at, seg.ms, seg.x0, 0, seg.v0, 0, seg.to, 0, t, xo, vo);
     }
     evaluate(at, ms, x0, x, v0, v, to, g, t, xo, vo) {
+        if (this.round)
+            return closedLch(this.runs, this.shape.ease, at, ms, x0, x, v0, v, to, g, t, xo, vo);
         return closed(this.runs, this.shape.ease, this.n, at, ms, x0, x, v0, v, to, g, t, xo, vo);
     }
 }

package/dist/move.js

@@ -2,16 +2,15 @@ import { settleArcs } from './arcs.js';
 import { changed } from './chain.js';
 import { elapsedWith } from './clock.js';
 import { byId, popDue, schedule } from './due.js';
-import { detour, outgrow } from './everyone.js';
-import { beginFade, part, retire } from './fade.js';
+import { beginFade, part, retire, rouse, stay } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
 import { begin } from './held.js';
 import { noted } from './history.js';
 import { leave as leaveClock } from './origin.js';
-import { ownerReading } from './owner.js';
+import { ownerReading, plays } from './owner.js';
 import { mixAt, place, repin, startAt, startOf } from './place.js';
 import { pageVoice } from './revive.js';
-import { delist } from './roster.js';
+import { delist, detour } from './roster.js';
 import { scoredLeft, scoredRemove } from './scored.js';
 import { lapse } from './spans.js';
 import { unplay } from './strays.js';
@@ -80,6 +79,8 @@ function moveTo(mix, now) {
         if (voice.state !== 'pending') {
             if (voice.turns)
                 turn(mix, voice, now);
+            if (voice.state === 'live' && voice.out !== null && !voice.quietAt(now))
+                rouse(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);
@@ -87,7 +88,7 @@ function moveTo(mix, 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 holds = voice.holding !== null && plays(voice, now);
             const over = back
                 ? atStart && !holds
                 : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
@@ -95,11 +96,11 @@ function moveTo(mix, now) {
                 voice.play(true, now, mix.transport.seq);
                 // 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.state === 'live' && voice.out === null) {
                     if (back ? voice.freezesBefore : voice.freezesAfter)
                         voice.state = 'frozen';
                     else
-                        beginFade(mix, voice, { back }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
+                        beginFade(mix, voice, { back, stays: voice.owner !== null && mix.opts.history !== undefined }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
                 }
             }
             else if (voice.state === 'frozen' && !(atStart && way === 0))
@@ -126,8 +127,12 @@ function moveTo(mix, now) {
                 else if (settled)
                     retire(mix, voice);
             }
-            else if (spent >= over)
-                retire(mix, voice, at + over);
+            else if (spent >= over) {
+                if (voice.out.stays)
+                    stay(mix, voice, at + over);
+                else
+                    retire(mix, voice, at + over);
+            }
         }
         if (!mix.projecting)
             schedule(mix, voice);
@@ -137,7 +142,7 @@ function moveTo(mix, now) {
         settleArcs(mix, now);
     }
     if (mix.sharers.length > 0 && !mix.projecting)
-        outgrow(mix);
+        mix.share?.outgrow(mix);
     mix.stirred = false;
     mix.asleep = false;
     if (mix.retired.length > 0)

package/dist/owner.d.ts

@@ -36,8 +36,13 @@ export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
 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. */
-export declare function orphan<I, O>(child: Voice<I, O>): Voice<I, O> | null;
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export declare function orphan<I, O>(child: Voice<I, O>, now: number): Voice<I, O> | null;
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export declare function plays<I, O>(owner: Voice<I, O>, now: number): boolean;
 /** A child finished its passes: its owner has played once every child it held has. */
 export declare function childPlayed<I, O>(owner: Voice<I, O>, at: number, seq: number): void;
 /** Every voice an owner holds, its children's children included. */

package/dist/owner.js

@@ -76,14 +76,24 @@ export function adopt(owner, child) {
     h.children.push(child);
     h.kids++;
 }
-/** A child left: its owner, where that was its last child and it should leave too. */
-export function orphan(child) {
+/**
+ * A child left at mix time `now`: its owner, where that was its last child still playing and it
+ * should leave too.
+ */
+export function orphan(child, now) {
     const owner = child.owner;
     const h = owner.holding;
     const i = h.children.indexOf(child);
     if (i >= 0)
         h.children.splice(i, 1);
-    return h.children.length === 0 && owner.state !== 'done' ? owner : null;
+    return !plays(owner, now) && owner.state !== 'done' ? owner : null;
+}
+/** Whether an owner holds a child at mix time `now` that is not kept quiet past its passes. */
+export function plays(owner, now) {
+    for (const child of owner.holding.children)
+        if (!child.quietAt(now))
+            return true;
+    return false;
 }
 /** A child finished its passes: its owner has played once every child it held has. */
 export function childPlayed(owner, at, seq) {

package/dist/project.js

@@ -7,7 +7,7 @@ import { fadesAt } from './fade.js';
 import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
 import { Mixer } from './mixer.js';
-import { heldByInput, ownerReading, relink } from './owner.js';
+import { heldByInput, relink } from './owner.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
@@ -72,6 +72,7 @@ export function projectAll(transport, at) {
         }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
+        copy.share = mix.share;
         copy.places = mix.places;
         copies.set(mix, copy);
         if (ahead)
@@ -183,13 +184,7 @@ function copyBack(mix, c, t, cut) {
 /** Sets each copied voice's state to what its clock and fade make it at `t`. */
 export function stateAt(c, t) {
     for (const copy of c.cued)
-        copy.state = copy.out
-            ? 'fading'
-            : (copy.owner === null ? t : ownerReading(copy.owner, t)) < copy.start
-                ? 'pending'
-                : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                    ? 'frozen'
-                    : 'live';
+        copy.state = copy.stateAt(t);
 }
 /**
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its

package/dist/pull.d.ts

@@ -1,5 +1,16 @@
 import type { Mixer } from './mixer.js';
 import type { Columns } from './types.js';
+/** One channel `pull` writes: where in the kit, how many numbers a subject, and its rest. */
+export interface Column {
+    key: string;
+    slot: number;
+    axes: number;
+    out: Float64Array;
+    /** The rest, clamped, or NaN for a channel with none. */
+    rest: Float64Array;
+    bounds: readonly [number, number] | undefined;
+}
+export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export declare function keep<I, O>(this: Mixer<I, O>, subject: I, pose: O, out: O | undefined): void;
 export declare function pull<I, O>(mix: Mixer<I, O>, subjects: Iterable<I>, into: Columns<O>): void;

package/dist/pull.js

@@ -1,9 +1,13 @@
 import { axesOf } from './channels.js';
 import { copy } from './clone.js';
-import { clampRun, flush, pullRun, writeLater } from './columns.js';
-import { renumber } from './renumber.js';
 /** What `pull` remembers at a position it has read no subject at. */
 const UNREAD = Symbol('unread');
+export function clampRun(out, at, n, [lo, hi]) {
+    for (let i = at; i < at + n; i++) {
+        const x = out[i];
+        out[i] = x < lo ? lo : x > hi ? hi : x;
+    }
+}
 /** Writes a folded pose's value into subject `n`'s places in a column. */
 function writeValue(c, v, n) {
     const at = n * c.axes;
@@ -112,7 +116,7 @@ export function pull(mix, subjects, into) {
     }
     finally {
         if (lanes !== null)
-            flush(lanes);
+            lanes.pulls.flush(lanes);
     }
     // Every head is current only if nothing relinked or changed version while they were read.
     const unchanged = live && mix.version === version && mix.relinks === relinks;
@@ -136,7 +140,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
     const runs = live && whole;
     for (let n = 0; n < list.length; n++) {
         if (runs) {
-            n = pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
+            n = lanes.pulls.pullRun(lanes, slots, list, was, since, n, columns, now, mix.version);
             if (n === list.length)
                 break;
         }
@@ -156,7 +160,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
                 // Numbered out of the list's order, as swap-remove leaves a subject: renumbered into it.
                 const to = n === 0 ? 0 : slots[n - 1] + 1;
                 if (runs && slot >= 0 && slot !== to && to >= 0) {
-                    if (renumber(mix, subject, head, to)) {
+                    if (lanes.pulls.renumber(mix, subject, head, to)) {
                         for (let j = was.indexOf(subject); j >= 0; j = was.indexOf(subject, j + 1))
                             slots[j] = to;
                         slot = to;
@@ -167,7 +171,7 @@ function readAll(mix, list, columns, live, current, since, whole) {
         }
         const laned = live && lanes?.prepare(slot, subject, mix.version, heads[n] ?? null) === true;
         if (laned && whole && lanes.whole && !lanes.owes(slot)) {
-            writeLater(lanes, slot, columns, n, slots);
+            lanes.pulls.writeLater(lanes, slot, columns, n, slots);
             continue;
         }
         const head = live ? heads[n] : null;

package/dist/qualify.js

@@ -1,9 +1,9 @@
 import { numericOf } from './channels.js';
 import { flush } from './columns.js';
-import { crowdable } from './crowd.js';
 import { byId } from './due.js';
 import { weighAt } from './everyone.js';
 import { wake } from './fill.js';
+import { crowdable } from './hosts.js';
 import { Lane } from './lane.js';
 import { reach } from './meet.js';
 import { bury, compactSparse, join, regroup, retouchRow, sameCrowds } from './rows.js';

package/dist/roles.js

@@ -1,9 +1,7 @@
 import { first } from './clone.js';
-import { open as openRecord } from './everyone.js';
 import { merged, unband } from './fold.js';
 import { roleScratch } from './role.js';
 // V8 reads a local const as a constant, where it reads an import from its module on every call.
-const open = openRecord;
 /**
  * Whether a fold's next voice is its chain's next record, `held`, and not the next voice sharing
  * one record, `sharers[q]`: the two lists are each in voice order, and a fold takes them as one.
@@ -54,7 +52,7 @@ export function foldRoles(subject, pose, head, laned, dry, except, owed) {
                 continue;
             const held = rec;
             if (!mine)
-                open(voice, held, head.slot);
+                this.share.open(voice, held, head.slot);
             const delta = this.read(voice, subject, now, dry, held);
             if (owed >= 0 && voice.laned)
                 this.lanes.paid(voice.id, owed, held.weight);

package/dist/roster.d.ts

@@ -1,5 +1,11 @@
 import type { Mixer } from './mixer.js';
 import type { Voice } from './voice.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export declare function detour<I, O>(mix: Mixer<I, O>): void;
 /** Counts a voice just put in the list into everything a sync and a fold skip work by. */
 export declare function enlist<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
 /**

package/dist/roster.js

@@ -1,6 +1,13 @@
 import { index, unindex } from './chain.js';
-import { detour } from './everyone.js';
 import { Store } from './store.js';
+/**
+ * Counts what makes a mix's fold more than a walk of each chain: a role, a voice sharing one
+ * record, a voice that stopped sharing this frame. Called wherever one of the three changes, so
+ * `foldWith` asks one number.
+ */
+export function detour(mix) {
+    mix.detours = mix.roleVoices + mix.sharers.length + (mix.unshared ? 1 : 0);
+}
 function tally(mix, voice, by) {
     if (voice.spec.role !== undefined)
         mix.roleVoices += by;

package/dist/sample.js

@@ -43,7 +43,8 @@ export function runMotion(lanes, lane, run) {
     }
     const samples = lane.samples;
     const xs = run.xs;
-    const ease = run.ease;
+    // A tween round the hue is no straight line between its ends: `sampleBare` reads it round the hue.
+    const ease = run.round ? undefined : run.ease;
     // A tween whose stretches tell the lane before they change keeps no sample: see `unbareLane`.
     if (run.watcher === null) {
         run.watcher = lanes;

package/dist/seek.js

@@ -6,7 +6,6 @@ import { apart, copyHeld, copyHeldInto, lastIndex, lastWithin, unread } from './
 import { laneHost } from './hosts.js';
 import { Leavings } from './leavings.js';
 import { move, nextFrame } from './move.js';
-import { ownerReading } from './owner.js';
 import { place } from './place.js';
 import { unpull } from './pull.js';
 import { isRested } from './record.js';
@@ -209,17 +208,6 @@ function restoreVoice(mix, voice, t, seq) {
     }
     records.back(t, cut, future);
 }
-/** Each voice's state at mix time `t`, once every clock above it is back where it was. */
-function stateAt(voice, t) {
-    // A fade begins at once, even one whose ramp starts later, at the voice's start.
-    if (voice.out !== null)
-        return 'fading';
-    if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
-        return 'pending';
-    if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
-        return 'frozen';
-    return 'live';
-}
 /**
  * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
  * the end of the frame numbered `to.frame`.
@@ -334,7 +322,7 @@ function back(mix, t, seq, on) {
     for (const voice of kept)
         restoreVoice(mix, voice, t, seq);
     for (const voice of kept)
-        voice.state = stateAt(voice, t);
+        voice.state = voice.stateAt(t);
     mix.cued = kept;
     mix.gone = gone;
     mix.retired = [];

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.15.1";
+export declare const release = "0.16.0";
 /**
  * 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.15.1';
+export const release = '0.16.0';
 /**
  * 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

@@ -29,7 +29,10 @@ export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?:
 export declare function refloor<I, O>(mix: Mixer<I, O>): 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. */
+/**
+ * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
+ * ran out.
+ */
 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;

package/dist/spans.js

@@ -6,7 +6,7 @@ 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 {
@@ -222,13 +222,16 @@ 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.
+ */
 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)
+        if (plays(span, now))
             continue;
         if (ownerReading(span, now) >= f.budget)
             retire(mix, span, span.timeAt(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/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/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

@@ -46,6 +46,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
@@ -326,6 +331,20 @@ 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.
+     */
+    stateAt(t: number): 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

@@ -472,9 +472,43 @@ 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.
+     */
+    stateAt(t) {
+        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)
+            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) {
+        if (this.state !== 'live' || this.out?.stays !== true)
+            return false;
+        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.