@msb235/blits 0.16.0 → 0.16.1

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;
@@ -87,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;
@@ -170,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. */
@@ -185,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. */
@@ -205,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. */
@@ -336,9 +373,10 @@ export declare class Voice<I, O> {
     /**
      * 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.
+     * 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): Voice<I, O>['state'];
+    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

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;
@@ -482,13 +509,15 @@ export class Voice {
     /**
      * 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.
+     * 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) {
+    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)
+        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';
@@ -500,8 +529,15 @@ export class Voice {
      * quiet unless its clock runs into them.
      */
     quietAt(now) {
-        if (this.state !== 'live' || this.out?.stays !== true)
+        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));
@@ -579,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,
@@ -586,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) {

package/docs/schema.html

@@ -898,7 +898,7 @@ phase.result;   <span class="cm">// { budget, length, over, skipped, fell }</spa
     <tr><td><code>pipe(...fits)</code></td><td>Tries each in turn, handing the plan on, until the children fit.</td></tr>
     <tr><td><code>lax({ cap })</code></td><td><code>pipe(condense(), shed(), overrun({ cap }))</code>: every way of giving way, running long only once the rest are spent.</td></tr>
   </table></div>
-  A strategy of the host's own takes the same arguments; <code>layout</code> says where a plan puts each child and how long they take, and <code>plain</code> is the plan before any fit. A child's start and rate are the span's: it takes no <code>start</code> or anchored start, only an <code>earliest</code>, a rate the host writes on its handle lasts until the next fit, and a voice that loops for good or a plain owner is refused. The span fits again when a child joins and when one leaves, and after a seek. Only what is still to come moves: a playing child keeps its place and changes rate without a jump, as a handle's <code>rate</code> write does, and a pending one is placed. A fit sees only the children that have arrived, so late ones are squeezed into what is left. A skipped child lands on its final state at that moment and its <code>end</code> mark is there, but the events its patch would have sent on the way are not sent. A span with a budget stays until the budget has passed, though its children finish sooner, so a late child can still join, and its <code>end</code> mark is wherever its children end or its budget does, whichever is later. A span held by a span is fitted through its own rate. A <code>seek</code> on its spec starts it that far into its budget. <code>span</code> refuses a rate below 0, since a fit lays the children out forward from the span's clock; a span turned back by its handle runs its children back as an owner does. A fit is made on the live mix and logged as the children's control changes, so a read back, a seek and its replay all see it, and the tape records nothing for it. Designed and built 2026-10-07; <code>earliest</code> and <code>rank</code> built 2026-10-22 for astv's change order, which sorts its changes by line and starts each no sooner than its orb lands:
+  A strategy of the host's own takes the same arguments; <code>layout</code> says where a plan puts each child and how long they take, and <code>plain</code> is the plan before any fit. A child's start and rate are the span's: it takes no <code>start</code> or anchored start, only an <code>earliest</code>, a rate the host writes on its handle lasts until the next fit, and a voice that loops for good or a plain owner is refused. The span fits again when a child joins and when one leaves; a seek puts its layout back as it stood. An owner sought forward passes the children it crosses as played straight through, whatever its rate: each starts, comes back from where it was kept quiet, and ends in turn, and the span fits from each end. Only what is still to come moves: a playing child keeps its place and changes rate without a jump, as a handle's <code>rate</code> write does, and a pending one is placed. A fit sees only the children that have arrived, so late ones are squeezed into what is left. A skipped child lands on its final state at that moment and its <code>end</code> mark is there, but the events its patch would have sent on the way are not sent. A span with a budget stays until the budget has passed, though its children finish sooner, so a late child can still join, and its <code>end</code> mark is wherever its children end or its budget does, whichever is later. A span held by a span is fitted through its own rate. A <code>seek</code> on its spec starts it that far into its budget. <code>span</code> refuses a rate below 0, since a fit lays the children out forward from the span's clock; a span turned back by its handle runs its children back as an owner does. A fit is made on the live mix and logged as the children's control changes, so a read back, a seek and its replay all see it, and the tape records nothing for it. Designed and built 2026-10-07; <code>earliest</code> and <code>rank</code> built 2026-10-22 for astv's change order, which sorts its changes by line and starts each no sooner than its orb lands:
 <pre><code>const phase = mix.span({ name: 'phase', order: 'queue', duration: 2000 });
 mix.cue({ patch: writeChange(change), owner: phase, rank: change.line,
           earliest: { of: { name: `orb ${change.id}`, score: 'orbs' }, mark: 'end' } });</code></pre></li>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",
@@ -60,6 +60,8 @@
     "site": "npm run dev -w site",
     "site:build": "npm run build -w site",
     "site:smoke": "npm run smoke -w site",
+    "stress": "node apps/stress/scripts/stress.mjs",
+    "stress:dev": "npm run dev -w @blits/stress",
     "playground": "npm run dev -w @blits/playground",
     "playground:smoke": "npm run smoke -w @blits/playground",
     "playground:check": "npm run typecheck -w @blits/playground && vitest run apps/playground/test && npm run playground:smoke"