@msb235/blits 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -4,6 +4,33 @@ This package follows [semver](https://semver.org). Below 1.0.0, a breaking chang
 version and everything else the patch. Each release lists its changes as **Breaking**, **Added** and
 **Fixed**, and the release workflow refuses a tag with no section here.
 
+## 0.6.0
+
+### Breaking
+
+- A voice's `hold` is `freeze`, SMIL's name for it, and a voice frozen after its passes is in state
+  `'frozen'`, not `'held'`: a host comparing `handle.state` to `'held'` must compare to `'frozen'`.
+  `hold` is still taken on a voice and an owner where `freeze` is not set, but it is deprecated and
+  a later release removes it; where both are set, `freeze` wins. `assess` still says `'held'` for a
+  channel whose input is not known, which is another thing.
+
+### Added
+
+- `ticker()`, one frame loop for any number of mixes: `add(mix)` syncs it every frame, `after(fn)`
+  runs once the mixes have synced, and `hold()` keeps the loop awake. It runs on animation frames, or on a
+  timer where there are none, as in a worker or Node, or with `grain: 'timer'`; `fps` caps the rate on
+  a grid, so a 60 Hz display capped at 30 runs every other frame. It sleeps while every mix is
+  `inert` and wakes on a mix's `onWake`. A mix or callback that throws stops neither the loop nor the
+  others; the error is thrown again on a microtask.
+- `mix.onWake(fn)`: called when a host call makes the mix need frames again after a sync — a cue,
+  a fade, a rate, a seek, a `drop`, a motion retargeted — once until the next sync, and never
+  during one. A host's loop sleeping on `inert` wakes on it instead of on every path that cues.
+
+### Fixed
+
+- `slew` and `lag` given `from` start a subject on their input when `dt` is infinite, as under
+  reduced motion, rather than showing `from` for its first frame and snapping on the next.
+
 ## 0.5.0
 
 ### Breaking

package/README.md

@@ -76,8 +76,8 @@ so the engine keeps no dependencies; its README says how it works.
 
 ## Status
 
-v0.5.0, with four consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
-transitions, weasel its animator's tweens, and
+v0.6.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+transitions, weasel its animator's tweens, sherpa its seams, and
 [klieg](https://github.com/orochi235/klieg) composes all three of its systems — letter motion,
 part effects, and the environment a sign is lit by — on a mix each.
 That port was an extraction rather than a rewrite, so it is also the evidence that the arithmetic

package/dist/book.d.ts

@@ -6,7 +6,7 @@ export type Listed = Marked & {
 };
 /** What a booker reads of the mix that made it. */
 export interface BookHost<I, O> {
-    /** The voices in the mix, pending, live, held or fading. */
+    /** The voices in the mix, pending, live, frozen or fading. */
     readonly voices: readonly Voice<I, O>[];
     /** The host's timestamp at the last sync. */
     readonly timestamp: number;

package/dist/chain.d.ts

@@ -4,10 +4,10 @@ import type { Subject, Voice } from './voice.js';
  * The first of this subject's records, linked through every live voice that reaches it. A voice
  * is asked once, through the record it keeps for the subject anyway; a pending one is linked when
  * it goes live, since `target` is asked on first sight, and sight only comes once a voice plays
- * or holds before.
+ * or freezes before.
  */
 export declare function chain<I, O>(this: Mixer<I, O>, subject: I, now: number): Subject<unknown>;
-/** A voice's record for a subject where its chain links it: the voice plays or holds, and reaches it. */
+/** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
 export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, slot: number): Subject<unknown> | null;
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
 export declare function aims<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): boolean;

package/dist/chain.js

@@ -27,7 +27,7 @@ function stub() {
  * The first of this subject's records, linked through every live voice that reaches it. A voice
  * is asked once, through the record it keeps for the subject anyway; a pending one is linked when
  * it goes live, since `target` is asked on first sight, and sight only comes once a voice plays
- * or holds before.
+ * or freezes before.
  */
 export function chain(subject, now) {
     const was = this.chains.get(subject);
@@ -77,10 +77,10 @@ export function chain(subject, now) {
         this.chains.set(subject, head);
     return head;
 }
-/** A voice's record for a subject where its chain links it: the voice plays or holds, and reaches it. */
+/** A voice's record for a subject where its chain links it: the voice plays or freezes, and reaches it. */
 export function linkable(voice, subject, now, slot) {
     const state = voice.state;
-    if (state === 'done' || (state === 'pending' && !voice.holdsBefore))
+    if (state === 'done' || (state === 'pending' && !voice.freezesBefore))
         return null;
     const held = this.held(voice, subject, now, slot);
     return held.reaches ? held : null;

package/dist/clock.d.ts

@@ -16,10 +16,10 @@ export declare function envelope(fadeIn: number, out: {
     rest: boolean;
 } | null, ease: Curve | undefined, reduced: boolean, now: number, since: number): number;
 /**
- * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
- * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ * A subject's voice time `raw` once the voice's freezes apply: 0 before it starts if it freezes
+ * before, else NaN, where it shows nothing; `span` once its passes end if it freezes after.
  */
-export declare function heldTime(raw: number, before: boolean, after: boolean, span: number): number;
+export declare function frozenTime(raw: number, before: boolean, after: boolean, span: number): number;
 /** A weight held to 0..1. */
 export declare function clampWeight(raw: number): number;
 /**

package/dist/clock.js

@@ -39,10 +39,10 @@ export function envelope(fadeIn, out, ease, reduced, now, since) {
     return w;
 }
 /**
- * A subject's voice time `raw` once the voice's holds apply: 0 before it starts if it holds before,
- * else NaN, where it shows nothing; `span` once its passes end if it holds after.
+ * A subject's voice time `raw` once the voice's freezes apply: 0 before it starts if it freezes
+ * before, else NaN, where it shows nothing; `span` once its passes end if it freezes after.
  */
-export function heldTime(raw, before, after, span) {
+export function frozenTime(raw, before, after, span) {
     if (raw < 0)
         return before ? 0 : Number.NaN;
     return after && raw > span ? span : raw;

package/dist/crowd.d.ts

@@ -31,7 +31,7 @@ export declare const enum Hot {
 }
 /** A crowd row's flags, at `Hot.FLAGS`. */
 export declare const enum Flag {
-    /** The voice is playing: live, held or fading. */
+    /** The voice is playing: live, frozen or fading. */
     PLAYING = 1,
     /** Its weight and clock are `hot`'s: no fade in or out, rate ramp, subject ramp or kept state. */
     FAST = 2,
@@ -47,8 +47,8 @@ export declare const enum Flag {
     VOICE = 64,
     /** The row's voice is a motion voice; otherwise its patch is keys or a stateless fn. */
     MOTION = 128,
-    /** The voice holds before or after, so its clock is read from the voice. */
-    HOLDS = 256,
+    /** The voice freezes before or after, so its clock is read from the voice. */
+    FREEZES = 256,
     /** A keys row whose stops `keys` holds, at `Hot.AT`, with its duration at `Hot.X0` and passes at `Hot.MS`. */
     FLAT = 512,
     /** The row's patch is a tween. */

package/dist/crowd.js

@@ -1,7 +1,7 @@
 import { bareRows, clock, unbare } from './bare.js';
 import { clampWeight, passAt, phaseAt, weighed } from './clock.js';
 import { KeyRows } from './keyrows.js';
-import { held, SPARSE } from './lane.js';
+import { frozenAt, SPARSE } from './lane.js';
 import { closed } from './motion.js';
 import { move } from './sample.js';
 /**
@@ -214,8 +214,8 @@ function rows(lanes, c, first, id) {
         const voice = c.voices[p];
         const elapsedNow = fast ? clock(hot, h, now) : voice.elapsedAt(now);
         let elapsed = elapsedNow - delay;
-        if ((f & 256 /* Flag.HOLDS */) !== 0)
-            elapsed = held(voice, elapsed);
+        if ((f & 256 /* Flag.FREEZES */) !== 0)
+            elapsed = frozenAt(voice, elapsed);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             continue;
@@ -298,11 +298,11 @@ export function row(c, p, voice, slot, elapsed, delay, w) {
 function copyVoice(c, p) {
     const v = c.voices[p];
     const h = p * c.stride;
-    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.HOLDS */);
-    if (v.state === 'live' || v.state === 'held' || v.state === 'fading')
+    let f = c.hot[h + 0 /* Hot.FLAGS */] & ~(64 /* Flag.VOICE */ | 1 /* Flag.PLAYING */ | 2 /* Flag.FAST */ | 256 /* Flag.FREEZES */);
+    if (v.state === 'live' || v.state === 'frozen' || v.state === 'fading')
         f |= 1 /* Flag.PLAYING */;
-    if (v.holdsBefore || v.holdsAfter)
-        f |= 256 /* Flag.HOLDS */;
+    if (v.freezesBefore || v.freezesAfter)
+        f |= 256 /* Flag.FREEZES */;
     if (v.ramp === null &&
         v.owner === null &&
         !((v.fade.in ?? 0) > 0) &&

package/dist/due.js

@@ -26,10 +26,10 @@ function dueOf(mix, voice) {
     due = Math.min(due, voice.outAt);
     if (Number.isFinite(voice.span)) {
         const end = voice.span + voice.latest;
-        // A held voice goes live again once its clock is back before its end: by a seek, by a
+        // A frozen voice goes live again once its clock is back before its end: by a seek, by a
         // subject staggered later than any before, or by running backwards, which is checked each
         // frame while it can.
-        if (voice.state === 'held') {
+        if (voice.state === 'frozen') {
             if (voice.rate <= 0 || voice.ramp !== null)
                 return Number.NEGATIVE_INFINITY;
             if (!Number.isNaN(mix.now) && voice.elapsedAt(mix.now) < end)

package/dist/fill.js

@@ -3,7 +3,7 @@ import { passAt, phaseAt, silent, weighed } from './clock.js';
 import { flush } from './columns.js';
 import { crowdsUpTo, freshen } from './crowd.js';
 import { foldLocus, gatherLocus } from './gather.js';
-import { held } from './lane.js';
+import { frozenAt } from './lane.js';
 import { reach } from './meet.js';
 import { absent } from './numbers.js';
 import { AT, NOTHING, readKeys, seg, segment, shifted } from './patch.js';
@@ -250,7 +250,7 @@ export function one(lane, p, slot, elapsedNow, duration, passes) {
     if (this.per[slot * 6 /* Per.SLOT */ + 5 /* Per.LANE_FILL */] === this.fills - 1)
         data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
     const delay = data[o + 0 /* Row.DELAY */];
-    const elapsed = held(voice, elapsedNow - delay);
+    const elapsed = frozenAt(voice, elapsedNow - delay);
     if (!(elapsed >= 0)) {
         data[o + 2 /* Row.WEIGHT */] = 0;
         return false;

package/dist/fold.js

@@ -1,4 +1,4 @@
-import { heldTime, passAt, phaseAt, silent } from './clock.js';
+import { frozenTime, passAt, phaseAt, silent } from './clock.js';
 import { copy as copyValue } from './clone.js';
 import { recordHost, remember } from './history.js';
 import { stateful } from './hosts.js';
@@ -46,11 +46,11 @@ export function influence(voice, subject, now, held) {
     if (voice.out?.rest && held.rested)
         return null;
     const raw = voice.elapsedAt(now) - held.delay;
-    if (raw < 0 && !voice.holdsBefore)
+    if (raw < 0 && !voice.freezesBefore)
         return null;
-    const elapsed = heldTime(raw, voice.holdsBefore, voice.holdsAfter, voice.span);
-    // A held subject's clock stands still at the edge it holds: -1 before, 1 after, 0 playing.
-    const still = raw < 0 ? -1 : voice.holdsAfter && raw > voice.span ? 1 : 0;
+    const elapsed = frozenTime(raw, voice.freezesBefore, voice.freezesAfter, voice.span);
+    // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
+    const still = raw < 0 ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
     const phase = phaseAt(elapsed, duration, voice.passes);
     const pass = passAt(elapsed, duration, voice.passes);
@@ -77,7 +77,7 @@ export function influence(voice, subject, now, held) {
     reading.horizon = this.horizonFor(voice, held.delay, now);
     const tick = this.opts.stepMs;
     if (voice.patch.step && held.probed !== now && still >= 0) {
-        // Held after, it steps once more to where its last pass ended, and no further.
+        // Frozen after, it steps once more to where its last pass ended, and no further.
         const to = still === 1 ? voice.timeAt(held.delay + voice.span) : now;
         if (tick !== undefined && tick > 0 && !this.reducedNow)
             this.tick(voice, subject, held, tick, to);
@@ -456,7 +456,7 @@ export function read(voice, subject, now, dry, held) {
         if (held.reaches && held.probed === now && held.delta && held.seeks === voice.seeks) {
             const setting = voice.setting;
             // The setting the probe that read the delta had, but for `dt`: a dry read advances nothing.
-            const elapsed = heldTime(voice.elapsedAt(now) - held.delay, voice.holdsBefore, voice.holdsAfter, voice.span);
+            const elapsed = frozenTime(voice.elapsedAt(now) - held.delay, voice.freezesBefore, voice.freezesAfter, voice.span);
             setting.timestamp = now;
             setting.dt = 0;
             setting.elapsed = elapsed;

package/dist/held.js

@@ -85,8 +85,8 @@ export function held(voice, subject, now, slot) {
     voice.seen++;
     if (delay > voice.latest) {
         voice.latest = delay;
-        // A later end can take a held voice live again.
-        if (voice.state === 'held')
+        // A later end can take a frozen voice live again.
+        if (voice.state === 'frozen')
             schedule(this, voice);
     }
     return held;
@@ -102,7 +102,7 @@ export function sinceOf(voice, delay) {
     return voice.owner === null ? t : mixTime(voice.owner, t);
 }
 export function shownOf(voice, since) {
-    return voice.holdsBefore && voice.opened < since ? voice.opened : since;
+    return voice.freezesBefore && voice.opened < since ? voice.opened : since;
 }
 /** A voice has gone live: the records it made while pending count from where it started. */
 export function started(mix, voice) {

package/dist/hosts.js

@@ -99,7 +99,7 @@ export function fits(mix, voice) {
     const patch = voice.patch;
     if (voice.keeping)
         return false;
-    if (voice.state === 'pending' && voice.holdsBefore)
+    if (voice.state === 'pending' && voice.freezesBefore)
         return false;
     // A fill weighs a voice's owners once for every subject, which a signal on one would not be.
     if (voice.owner !== null && signalled(voice))

package/dist/index.d.ts

@@ -6,4 +6,6 @@ export { glide, spring, tween } from './motion.js';
 export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
 export { gate, lag, level, peak, slew } from './signals.js';
+export type { Ticked, Ticker, TickerOptions } from './ticker.js';
+export { ticker } from './ticker.js';
 export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Doubt, Easing, Engine, FadeOptions, FadeSpec, Handle, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Patch, Placement, Projection, Query, Sent, Setting, Signal, VoiceSpec, } from './types.js';

package/dist/index.js

@@ -3,3 +3,4 @@ export { mix, mixer } from './mixer.js';
 export { glide, spring, tween } from './motion.js';
 export { keys, patch } from './patch.js';
 export { gate, lag, level, peak, slew } from './signals.js';
+export { ticker } from './ticker.js';

package/dist/lane.d.ts

@@ -204,7 +204,7 @@ export declare class Lane<I, O> implements Positions<I, O> {
     remove(slot: number): void;
 }
 /**
- * A subject's voice time once its voice's holds apply: held at 0 before it starts and at the end of
- * its passes after, and NaN where it shows nothing.
+ * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
+ * of its passes after, and NaN where it shows nothing.
  */
-export declare function held<I, O>(voice: Voice<I, O>, elapsed: number): number;
+export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -1,5 +1,5 @@
 import { unbareLane } from './bare.js';
-import { heldTime } from './clock.js';
+import { frozenTime } from './clock.js';
 import { motionOf } from './motion.js';
 /**
  * Below what share of its subjects probed last frame a lane stops filling, and above what share it
@@ -179,9 +179,9 @@ export class Lane {
     }
 }
 /**
- * A subject's voice time once its voice's holds apply: held at 0 before it starts and at the end of
- * its passes after, and NaN where it shows nothing.
+ * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
+ * of its passes after, and NaN where it shows nothing.
  */
-export function held(voice, elapsed) {
-    return heldTime(elapsed, voice.holdsBefore, voice.holdsAfter, voice.span);
+export function frozenAt(voice, elapsed) {
+    return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
 }

package/dist/marks.js

@@ -62,7 +62,7 @@ export function markOf(mix, voice, mark) {
         outAt = out.at;
     else if (Number.isFinite(voice.outAt))
         outAt = voice.outAt;
-    else if (!voice.holdsAfter && Number.isFinite(voice.span)) {
+    else if (!voice.freezesAfter && Number.isFinite(voice.span)) {
         const t = voice.timeAt(voice.span + voice.latest);
         if (Number.isFinite(t))
             outAt = Math.max(start, t);

package/dist/mixer.d.ts

@@ -100,8 +100,11 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     stirred: boolean;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs: number;
+    syncing: boolean;
+    stirFns: (() => void)[] | null;
     /** Records a change to the mix's voices or controls. */
     stir(): void;
+    onWake(fn: () => void): () => void;
     /**
      * Per subject, the first record of the chain through every live voice that reaches it, or a stub
      * where none does. Relinked when `version` moves, which is whenever the list or a voice's pending
@@ -168,6 +171,7 @@ export declare class Mixer<I, O> implements Mix<I, O> {
     blend(patches: readonly Patch<I, O, unknown>[], by: Signal<I>, spec?: Omit<VoiceSpec<I, O>, 'patch' | 'weight' | 'locus'>): Handle<I>[];
     owns(spec: OwnerSpec<I>): Handle<I>;
     sync(timestamp: number): void;
+    private syncAt;
     book(opts: BookOptions): Booker;
     probe(subject: I, out?: O): O;
     pull(subjects: Iterable<I>, into: Columns<O>): void;

package/dist/mixer.js

@@ -86,10 +86,29 @@ export class Mixer {
     stirred = false;
     /** Counts the changes `stir` records, which a frame's record of a probe is current only before. */
     stirs = 0;
+    syncing = false;
+    stirFns = null;
     /** Records a change to the mix's voices or controls. */
     stir() {
-        this.stirred = true;
         this.stirs++;
+        if (this.stirred)
+            return;
+        this.stirred = true;
+        const fns = this.stirFns;
+        if (fns !== null && !this.syncing)
+            for (const fn of [...fns])
+                fn();
+    }
+    onWake(fn) {
+        if (this.stirFns === null)
+            this.stirFns = [];
+        const fns = this.stirFns;
+        fns.push(fn);
+        return () => {
+            const i = fns.indexOf(fn);
+            if (i >= 0)
+                fns.splice(i, 1);
+        };
     }
     /**
      * Per subject, the first record of the chain through every live voice that reaches it, or a stub
@@ -200,6 +219,15 @@ export class Mixer {
         return this.cue({ ...spec, patch: ownerPatch });
     }
     sync(timestamp) {
+        this.syncing = true;
+        try {
+            this.syncAt(timestamp);
+        }
+        finally {
+            this.syncing = false;
+        }
+    }
+    syncAt(timestamp) {
         if (this.rebasing && !Number.isNaN(this.last))
             this.offset += timestamp - this.last;
         this.rebasing = false;
@@ -337,14 +365,14 @@ export class Mixer {
     still(voice, now) {
         if (voice.state === 'done')
             return true;
-        if (voice.state !== 'held' && voice.state !== 'live')
+        if (voice.state !== 'frozen' && voice.state !== 'live')
             return false;
         if (typeof voice.spec.weight === 'function' || voice.parts !== null)
             return false;
         const fadeIn = this.reducedNow ? 0 : (voice.fade.in ?? 0);
         if (fadeIn > 0 && now - this.sinceOf(voice, voice.latest) < fadeIn)
             return false;
-        if (voice.state === 'held' || voice.holding !== null)
+        if (voice.state === 'frozen' || voice.holding !== null)
             return true;
         const motion = voice.motion;
         return motion !== undefined && voice.elapsedAt(now) >= voice.latest && motion.landed();

package/dist/move.js

@@ -48,7 +48,7 @@ function moveTo(mix, now) {
             continue;
         if (Number.isNaN(voice.opened))
             voice.opened = now;
-        if ((voice.state === 'live' || voice.state === 'held') && voice.outAt <= now)
+        if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
             beginFade(mix, voice, {}, Math.max(startOf(voice), voice.outAt));
         if (voice.state === 'pending' &&
             (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
@@ -63,13 +63,13 @@ function moveTo(mix, now) {
                 // The fade starts when the last pass ended, 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.holdsAfter)
-                        voice.state = 'held';
+                    if (voice.freezesAfter)
+                        voice.state = 'frozen';
                     else
                         beginFade(mix, voice, {}, Math.max(startOf(voice), Math.min(now, voice.timeAt(end))));
                 }
             }
-            else if (voice.state === 'held')
+            else if (voice.state === 'frozen')
                 voice.state = 'live';
         }
         // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.

package/dist/owner.d.ts

@@ -34,7 +34,7 @@ export declare function heldByInput<I, O>(voice: Voice<I, O>): boolean;
 /**
  * What one owner multiplies into its children's weight for a subject at mix time `now`: its weight,
  * or its signal's read by `base`, times its own fade, held to 0..1. Its fade in counts from when it
- * started, or from when it first showed where it holds before.
+ * started, or from when it first showed where it freezes before.
  */
 export declare function ownWeight<I, O>(owner: Voice<I, O>, now: number, reduced: boolean, base: (owner: Voice<I, O>) => number): number;
 /** What every owner above a voice multiplies into its weight. */

package/dist/owner.js

@@ -80,12 +80,12 @@ export function heldByInput(voice) {
 /**
  * What one owner multiplies into its children's weight for a subject at mix time `now`: its weight,
  * or its signal's read by `base`, times its own fade, held to 0..1. Its fade in counts from when it
- * started, or from when it first showed where it holds before.
+ * started, or from when it first showed where it freezes before.
  */
 export function ownWeight(owner, now, reduced, base) {
     const b = typeof owner.spec.weight === 'function' ? base(owner) : owner.weight;
     const start = owner.owner === null ? owner.start : mixTime(owner.owner, owner.start);
-    const since = owner.holdsBefore && owner.opened < start ? owner.opened : start;
+    const since = owner.freezesBefore && owner.opened < start ? owner.opened : start;
     return clampWeight(b * envelope(owner.fade.in ?? 0, owner.out, owner.ease, reduced, now, since));
 }
 /** What every owner above a voice multiplies into its weight. */

package/dist/project.js

@@ -75,8 +75,8 @@ export function project(mix, c, timestamp) {
                     ? 'pending'
                     : copy.out && copy.out.at <= t
                         ? 'fading'
-                        : copy.holdsAfter && copy.elapsedAt(t) >= copy.span + copy.latest
-                            ? 'held'
+                        : copy.freezesAfter && copy.elapsedAt(t) >= copy.span + copy.latest
+                            ? 'frozen'
                             : 'live';
         count(c);
     }

package/dist/signals.d.ts

@@ -16,7 +16,8 @@ export declare function level<I, H = unknown>(initial?: number): Signal<I, H> &
 /**
  * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * unless `dt` is infinite.
  *
  * @category signal
  */
@@ -31,7 +32,7 @@ export declare function slew<I, H = unknown>(of: Signal<I, H>, { riseMs, fallMs,
  * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
  * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
  * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from`.
+ * A subject starts on its input, or at `from` unless `dt` is infinite.
  *
  * @category signal
  */

package/dist/signals.js

@@ -30,19 +30,25 @@ export function level(initial = 0) {
         },
     });
 }
-/** Where a follower starts for a subject: on its input, or at `from`, seen now so the next frame moves. */
-const firstSight = (target, from, now) => from === undefined ? { value: target, seen: Number.NaN } : { value: from, seen: now };
+/**
+ * Where a follower starts for a subject: on its input, or at `from`, seen now so the next frame
+ * moves. Under reduced motion it starts on its input, since every later frame would snap there.
+ */
+const firstSight = (target, from, setting) => from === undefined || !Number.isFinite(setting.dt)
+    ? { value: target, seen: Number.NaN }
+    : { value: from, seen: setting.timestamp };
 /**
  * The package's one decay primitive: follows its input at a rate limit, no faster than `riseMs` per
  * unit climbing or `fallMs` draining. The mix keeps its state per voice and subject, so two voices
- * handed the same slew each follow on their own. A subject starts on its input, or at `from`.
+ * handed the same slew each follow on their own. A subject starts on its input, or at `from`
+ * unless `dt` is infinite.
  *
  * @category signal
  */
 export function slew(of, { riseMs = 0, fallMs = 0, from }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
-        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
+        const held = setting.keep(read, () => firstSight(target, from, setting));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;
@@ -66,14 +72,14 @@ export function slew(of, { riseMs = 0, fallMs = 0, from }) {
  * sample it are spaced while the input holds still. `riseMs` and `fallMs` are time constants: after
  * one, 63% of the way is covered. 0 follows at once. Within `floor` of its input it lands on it, so a
  * subject can reach rest; pass 0 to keep the curve exact. The mix keeps its state per voice and subject.
- * A subject starts on its input, or at `from`.
+ * A subject starts on its input, or at `from` unless `dt` is infinite.
  *
  * @category signal
  */
 export function lag(of, { riseMs = 0, fallMs = 0, floor = 1e-6, from, }) {
     const read = (subject, setting) => {
         const target = of(subject, setting);
-        const held = setting.keep(read, () => firstSight(target, from, setting.timestamp));
+        const held = setting.keep(read, () => firstSight(target, from, setting));
         if (setting.timestamp === held.seen)
             return held.value;
         let next = target;

package/dist/ticker.d.ts

@@ -0,0 +1,48 @@
+/** What a ticker runs: a mix, or anything that syncs, sleeps on `inert` and wakes by `onWake`. */
+export interface Ticked {
+    sync(timestamp: number): void;
+    readonly inert: boolean;
+    onWake(fn: () => void): () => void;
+}
+export interface TickerOptions {
+    /**
+     * The most frames a second it syncs. Under animation frames it skips a frame that comes sooner
+     * than that, on a grid, so a 60 Hz display capped at 30 runs every other frame. Under a timer it
+     * is the timer's rate, 60 unless given.
+     */
+    fps?: number;
+    /**
+     * Where frames come from: `'frame'`, `requestAnimationFrame`, or `'timer'`, `setTimeout`. By
+     * default animation frames where they exist, and a timer where they don't, as in a worker
+     * without them or in Node.
+     */
+    grain?: 'frame' | 'timer';
+    /**
+     * The clock every mix is synced by. By default an animation frame's own timestamp, or
+     * `performance.now()` under a timer. A worker's `performance.now()` counts from its own origin,
+     * not the page's.
+     */
+    now?: () => number;
+    /** Stands in for `requestAnimationFrame`, as in a test. */
+    raf?: (callback: (timestamp: number) => void) => number;
+    /** Stands in for `cancelAnimationFrame`. */
+    caf?: (id: number) => void;
+}
+export interface Ticker {
+    /** Syncs `mix` every frame from now on, and wakes the loop on its `onWake`. Returns a remove. */
+    add(mix: Ticked): () => void;
+    /** Calls `fn` each frame, after every mix has synced, with the frame's timestamp. Returns an unsubscribe. */
+    after(fn: (timestamp: number) => void): () => void;
+    /** Keeps frames coming whatever the mixes say, until the returned release is called. */
+    hold(): () => void;
+    /** Cancels the waiting frame; a mix waking, `hold` or `add` starts the loop again. */
+    stop(): void;
+    /** What the ticker's clock reads now. */
+    now(): number;
+}
+/**
+ * One frame loop for any number of mixes. It runs while a mix would still change or something
+ * holds it, and sleeps otherwise, until a mix wakes it. A mix or `after` callback that throws stops
+ * neither the loop nor the others: its error is thrown again on a microtask.
+ */
+export declare function ticker(opts?: TickerOptions): Ticker;

package/dist/ticker.js

@@ -0,0 +1,112 @@
+/** Slack under the interval that still counts as due, for a display whose frames jitter. */
+const SLACK = 1;
+/**
+ * One frame loop for any number of mixes. It runs while a mix would still change or something
+ * holds it, and sleeps otherwise, until a mix wakes it. A mix or `after` callback that throws stops
+ * neither the loop nor the others: its error is thrown again on a microtask.
+ */
+export function ticker(opts = {}) {
+    const g = globalThis;
+    const perfNow = () => (g.performance === undefined ? Date.now() : g.performance.now());
+    const byFrame = opts.raf !== undefined ||
+        (opts.grain !== 'timer' && typeof g.requestAnimationFrame === 'function');
+    const fps = opts.fps ?? (byFrame ? undefined : 60);
+    if (fps !== undefined && !(fps > 0 && fps < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: a ticker's fps is a finite number above 0, not ${fps}`);
+    const interval = fps === undefined ? 0 : 1000 / fps;
+    const mixes = [];
+    const unwakes = new Map();
+    const fns = [];
+    let holds = 0;
+    let pending = null;
+    let last = Number.NaN;
+    const now = opts.now ?? perfNow;
+    const later = (err) => g.queueMicrotask(() => {
+        throw err;
+    });
+    const request = byFrame
+        ? (opts.raf ??
+            ((cb) => g.requestAnimationFrame(cb)))
+        : (cb) => g.setTimeout(() => cb(now()), Number.isNaN(last) ? 0 : Math.max(0, last + interval - now()));
+    const cancel = byFrame
+        ? (opts.caf ?? ((id) => g.cancelAnimationFrame?.(id)))
+        : (id) => g.clearTimeout(id);
+    const schedule = () => {
+        if (pending === null)
+            pending = request(frame);
+    };
+    function frame(stamp) {
+        pending = null;
+        const t = opts.now === undefined ? stamp : opts.now();
+        // A capped loop skips a frame that comes early, and steps a grid so its rate does not drift
+        // with the display's or with a timer's rounding. A long gap, as after sleeping, starts it again.
+        if (interval > 0 && !Number.isNaN(last)) {
+            const gap = t - last;
+            if (gap < interval - SLACK) {
+                pending = request(frame);
+                return;
+            }
+            last = gap >= 2 * interval ? t : last + interval;
+        }
+        else
+            last = t;
+        for (const mix of [...mixes])
+            try {
+                mix.sync(t);
+            }
+            catch (err) {
+                later(err);
+            }
+        for (const fn of [...fns])
+            try {
+                fn(t);
+            }
+            catch (err) {
+                later(err);
+            }
+        if (holds > 0 || mixes.some((mix) => !mix.inert))
+            schedule();
+    }
+    return {
+        add(mix) {
+            if (!unwakes.has(mix)) {
+                mixes.push(mix);
+                unwakes.set(mix, mix.onWake(schedule));
+            }
+            schedule();
+            return () => {
+                const unwake = unwakes.get(mix);
+                if (unwake === undefined)
+                    return;
+                unwake();
+                unwakes.delete(mix);
+                mixes.splice(mixes.indexOf(mix), 1);
+            };
+        },
+        after(fn) {
+            fns.push(fn);
+            return () => {
+                const i = fns.indexOf(fn);
+                if (i >= 0)
+                    fns.splice(i, 1);
+            };
+        },
+        hold() {
+            holds++;
+            schedule();
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                holds--;
+            };
+        },
+        stop() {
+            if (pending !== null)
+                cancel(pending);
+            pending = null;
+        },
+        now,
+    };
+}

package/dist/types.d.ts

@@ -395,7 +395,7 @@ export interface VoiceSpec<I, O, H = unknown> {
     /**
      * true loops for good, false plays one pass, n plays n passes. A finite loop leaves when its
      * passes are done for the latest-staggered subject it has seen — over `fade.out` where one is
-     * set, at once where none is — unless it holds after.
+     * set, at once where none is — unless it freezes after.
      */
     loop?: boolean | number;
     /**
@@ -406,12 +406,14 @@ export interface VoiceSpec<I, O, H = unknown> {
     /**
      * Show a subject the first frame before it starts — while the voice is pending and while the
      * subject waits out its `stagger` — the last frame of the last pass after a finite loop plays
-     * out, or both. A held subject's clock stands still: `at` is asked for the edge frame and `step`
+     * out, or both. A frozen subject's clock stands still: `at` is asked for the edge frame and `step`
      * does not run, past one last step to the end of the last pass. `fade.in` counts from the first
-     * frame the voice shows. A voice holding after stays, `held`, until `fade()` or an anchored `out`
-     * takes it out, so every one cued must be faded or it stays in the mix for good. Does nothing to
-     * a motion patch, which holds its target already. Default: neither.
+     * frame the voice shows. A voice freezing after stays, `frozen`, until `fade()` or an anchored
+     * `out` takes it out, so every one cued must be faded or it stays in the mix for good. Does
+     * nothing to a motion patch, which keeps its target already. Default: neither.
      */
+    freeze?: 'before' | 'after' | 'both';
+    /** @deprecated Use `freeze`. A voice that sets only `hold` still freezes; `freeze` wins over it. */
     hold?: 'before' | 'after' | 'both';
     /** Steady weight, or a signal read per subject per frame. Default 1. */
     weight?: number | Signal<I, H>;
@@ -443,7 +445,7 @@ export interface VoiceSpec<I, O, H = unknown> {
      * the owner's clock, in ms from when the owner starts, and default to where that clock is now; a
      * bare name in an anchor means a sibling, another voice the owner holds. Its clock runs on the
      * owner's, so the owner's rate, ramp and seeks move it, and its weight is multiplied by the
-     * owner's weight and fade. Without a `hold` of its own it takes the owner's.
+     * owner's weight and fade. Without a `freeze` of its own it takes the owner's.
      */
     owner?: Handle<I>;
 }
@@ -467,7 +469,9 @@ export interface OwnerSpec<I, H = unknown> {
     weight?: number | Signal<I, H>;
     /** One ramp in and out over every child, multiplied into their weights as `weight` is. */
     fade?: FadeSpec;
-    /** The hold every child without one of its own takes. */
+    /** The freeze every child without one of its own takes. */
+    freeze?: 'before' | 'after' | 'both';
+    /** @deprecated Use `freeze`. An owner that sets only `hold` still freezes; `freeze` wins over it. */
     hold?: 'before' | 'after' | 'both';
     /** Words a source attaches to it, as a voice's. */
     tags?: readonly string[];
@@ -510,8 +514,8 @@ export type FadeOptions<I = unknown> = {
  */
 export interface Handle<I = unknown> {
     readonly id: number;
-    /** `held`: a voice holding after has played every pass and shows its last frame until faded. */
-    readonly state: 'pending' | 'live' | 'held' | 'fading' | 'done';
+    /** `frozen`: a voice freezing after has played every pass and shows its last frame until faded. */
+    readonly state: 'pending' | 'live' | 'frozen' | 'fading' | 'done';
     /** The handle of the owner this voice plays under; undefined for one on the mix clock. */
     readonly owner: Handle<I> | undefined;
     /** Live. Writes land on the next sync. */
@@ -533,7 +537,7 @@ export interface Handle<I = unknown> {
     /**
      * The weight this voice gave `subject` the last frame that subject was probed: after its fades
      * and its weight signal, before a locus folds it with its alternatives. 0 for a subject it does
-     * not reach, has not started on and does not hold before, has left at rest, or has never been
+     * not reach, has not started on and does not freeze before, has left at rest, or has never been
      * probed for; 0 once done.
      * Costs nothing until it is asked.
      */
@@ -714,7 +718,7 @@ export interface Mix<I, O, H = unknown> {
      */
     atRest(subject: I): boolean;
     /**
-     * A handle on every voice still in the mix, pending, live, held or fading, in the order they were
+     * A handle on every voice still in the mix, pending, live, frozen or fading, in the order they were
      * cued; given a tag, only the voices whose `tags` carry it. Each is the handle `cue` returned for
      * that voice, so a listed handle is `===` the cued one.
      */
@@ -722,12 +726,19 @@ export interface Mix<I, O, H = unknown> {
     /** Anything still contributing, fading, or pending. */
     readonly live: boolean;
     /**
-     * Another frame would change no pose, so a host's frame loop may sleep: every voice is done, held
+     * Another frame would change no pose, so a host's frame loop may sleep: every voice is done, frozen
      * at a plain weight, or a motion whose every subject has landed on its target. At rate 0 it is
      * enough that every voice not done has started, at a plain weight, with no anchor. A change made
      * since the last sync, a retarget or a rate included, makes it false until the next.
      */
     readonly inert: boolean;
+    /**
+     * Calls `fn` when a host call makes the mix need frames again after a sync: a cue, a fade, a
+     * handle's or the mix's rate, a seek, a `drop`, a motion retargeted. It fires once until the next
+     * sync clears the change, and never during `sync`. Returns a function that unsubscribes `fn`.
+     * A frame loop sleeping on `inert` subscribes here to wake.
+     */
+    onWake(fn: () => void): () => void;
     /** Fades every voice out: over `over` when given, over each voice's own `fade.out` otherwise. */
     mute(opts?: {
         over?: number;

package/dist/voice.d.ts

@@ -16,7 +16,7 @@ export interface Subject<S> {
     delay: number;
     /** The mix timestamp this subject's delay ran out at, which its step grid counts from. */
     since: number;
-    /** The mix timestamp its fade in counts from: `since`, or earlier for a voice holding before. */
+    /** The mix timestamp its fade in counts from: `since`, or earlier for a voice freezing before. */
     shown: number;
     /** The weight this voice gave this subject the last frame it was probed, 0 where it gave none. */
     weight: number;
@@ -104,7 +104,7 @@ export declare class Voice<I, O> {
     start: number;
     /** The owner whose clock it runs on, its start included; null for one on the mix clock. */
     owner: Voice<I, O> | null;
-    state: 'pending' | 'live' | 'held' | 'fading' | 'done';
+    state: 'pending' | 'live' | 'frozen' | 'fading' | 'done';
     rate: number;
     weight: number;
     /**
@@ -159,9 +159,9 @@ export declare class Voice<I, O> {
     readonly span: number;
     /** The state behind a motion patch, undefined for any other. */
     readonly motion: Motions<I> | undefined;
-    /** Its `hold`, for a patch it applies to: motion holds its target already. */
-    readonly holdsBefore: boolean;
-    readonly holdsAfter: boolean;
+    /** Its `freeze`, for a patch it applies to: motion keeps its target already. */
+    readonly freezesBefore: boolean;
+    readonly freezesAfter: boolean;
     /** The mix time it first showed: when it was cued, or the first sync after. */
     opened: number;
     /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */

package/dist/voice.js

@@ -129,9 +129,9 @@ export class Voice {
     span;
     /** The state behind a motion patch, undefined for any other. */
     motion;
-    /** Its `hold`, for a patch it applies to: motion holds its target already. */
-    holdsBefore;
-    holdsAfter;
+    /** Its `freeze`, for a patch it applies to: motion keeps its target already. */
+    freezesBefore;
+    freezesAfter;
     /** The mix time it first showed: when it was cued, or the first sync after. */
     opened = Number.NaN;
     /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */
@@ -243,11 +243,13 @@ export class Voice {
                 ? this.duration * this.passes
                 : Number.POSITIVE_INFINITY;
         this.motion = motionOf(patch);
-        const holds = this.motion === undefined ? spec.hold : undefined;
-        // A voice with no hold of its own takes its owner's.
-        const inherits = holds === undefined && this.motion === undefined && owner !== null;
-        this.holdsBefore = inherits ? owner.holdsBefore : holds === 'before' || holds === 'both';
-        this.holdsAfter = inherits ? owner.holdsAfter : holds === 'after' || holds === 'both';
+        const freezes = this.motion === undefined ? (spec.freeze ?? spec.hold) : undefined;
+        // A voice with no freeze of its own takes its owner's.
+        const inherits = freezes === undefined && this.motion === undefined && owner !== null;
+        this.freezesBefore = inherits
+            ? owner.freezesBefore
+            : freezes === 'before' || freezes === 'both';
+        this.freezesAfter = inherits ? owner.freezesAfter : freezes === 'after' || freezes === 'both';
         this.setting = new VoiceSetting(host, send, this);
         this.rate = spec.rate ?? 1;
         this.weight = typeof spec.weight === 'number' ? spec.weight : 1;

package/docs/schema.html

@@ -160,7 +160,7 @@
   <h1>An effects schema, and the API around it</h1>
   <p class="lede">A small runtime package for concurrent effects. Each effect runs on its own clock with its own state and weight, and a mix folds them into one value per subject per frame by rules that belong to the channel, not the effect.</p>
   <p class="meta"><b>For:</b> whoever builds <code>blits</code>, and whoever ports klieg, wod, sherpa or magicsmoke onto it. <b>Answers:</b> what the vocabulary is, what an author writes, what a host calls, and where a second engine would plug in. The package implements this page; where the two differ, the code in <code>src/</code> is the one that runs.</p>
-  <span class="status">Built · v0.5.0 · design 2026-09-15, package 2026-09-28</span>
+  <span class="status">Built · v0.6.0 · design 2026-09-15, package 2026-09-28</span>
 </header>
 
 <h2 id="picture">In one picture</h2>
@@ -393,8 +393,8 @@ interface Setting&lt;S = void, H = unknown&gt; {
      kept, like <code>target</code>; the subject's fade in starts when the voice clock reaches it. */</span>
   stagger?: (subject: I) =&gt; number;
   <span class="cm">/** Show the first frame before a subject starts, the last after its passes run out, or both. Default: neither,
-     so the voice shows nothing outside its passes. See Holding. */</span>
-  hold?: 'before' | 'after' | 'both';
+     so the voice shows nothing outside its passes. See Freezing. <code>hold</code>, its name before 0.6.0, still works and is deprecated. */</span>
+  freeze?: 'before' | 'after' | 'both';
 
   <span class="cm">// weight</span>
   <span class="cm">/** Steady weight, or a signal read per subject per frame. Default 1. */</span>
@@ -428,8 +428,8 @@ interface Setting&lt;S = void, H = unknown&gt; {
 
 interface Handle&lt;I&gt; {
   readonly id: number;
-  <span class="cm">/** <code>held</code>: a voice holding after has played every pass and shows its last frame until faded. */</span>
-  readonly state: 'pending' | 'live' | 'held' | 'fading' | 'done';
+  <span class="cm">/** <code>frozen</code>: a voice freezing after has played every pass and shows its last frame until faded. */</span>
+  readonly state: 'pending' | 'live' | 'frozen' | 'fading' | 'done';
   <span class="cm">/** The owner's handle, for a voice an owner holds. */</span>
   readonly owner: Handle&lt;I&gt; | undefined;
   <span class="cm">/** Live. Writes land on the next sync. */</span>
@@ -456,14 +456,14 @@ interface Handle&lt;I&gt; {
 
 <p><b>Fading one subject.</b> <code>fade({ subject, over })</code> ramps one subject out of a voice and leaves the voice playing for every other subject; <code>over: 0</code> takes it out at once. When the ramp ends the voice forgets the subject &mdash; its record, its lane position and a motion patch&rsquo;s state for it &mdash; and no longer reaches it, so nothing it held stays stacked under whatever takes the subject over. A motion patch&rsquo;s <code>to</code> brings it back, met afresh: <code>from</code>, <code>target</code> and <code>stagger</code> are asked again. Any other voice reaches it again only once <code>drop</code> forgets the subject. This is what lets a host that starts many short animations, one per node, run them as one voice on one lane instead of a voice per call, while still cancelling a node or handing it to a different patch.</p>
 
-<p><b>Holding.</b> A voice shows nothing outside its passes unless it holds. <code>hold: 'before'</code> shows a subject the voice&rsquo;s first frame from the cue until the subject starts: while the voice is pending, and while the subject waits out its <code>stagger</code>. <code>hold: 'after'</code> shows the last frame of the last pass once a finite loop has played out, and the voice stays until <code>fade()</code> takes it out, ramping from that frame. <code>'both'</code> does both. wod asked for it to replace WAAPI&rsquo;s <code>fill</code>: a spin lands and holds its angle, and staggered wedges wait on their first frame rather than popping in.</p>
+<p><b>Freezing.</b> A voice shows nothing outside its passes unless it freezes, the name SMIL gives the same thing (<code>fill="freeze"</code>). <code>freeze: 'before'</code> shows a subject the voice&rsquo;s first frame from the cue until the subject starts: while the voice is pending, and while the subject waits out its <code>stagger</code>. <code>freeze: 'after'</code> shows the last frame of the last pass once a finite loop has played out, and the voice stays until <code>fade()</code> takes it out, ramping from that frame. <code>'both'</code> does both. wod asked for it to replace WAAPI&rsquo;s <code>fill</code>: a spin lands and freezes on its angle, and staggered wedges wait on their first frame rather than popping in.</p>
 <ul>
-  <li><b>A held subject&rsquo;s clock stands still.</b> It reads phase 0 of pass 0 before, and phase 1 of the last pass after, with <code>elapsed</code> pinned to that edge. <code>at</code> is asked for that frame. <code>step</code> does not run while a subject waits, so a stateful patch starts playing from the state it was cued with; after, it runs once more to where the last pass ended and then no more, so the held frame does not depend on when the last frame before it fell. A voice holding before stays <code>pending</code> until it starts, and <code>weightOf</code> reports the weight it gives a waiting subject.</li>
-  <li><b><code>fade.in</code> counts from the first frame the voice shows</b>, so with <code>'before'</code> it ramps in on the held frame rather than at full weight, and does not dip when play begins.</li>
-  <li><b>A voice holding after reaches <code>held</code>, not <code>fading</code>,</b> at the moment a voice without a hold would begin its fade out. <code>played</code> resolves true then. Its <code>out</code> and <code>end</code> marks are unfixed until it is faded, like those of a voice that loops for good, so <code>{ after: 'spin' }</code> waits for the fade. A host that wants to start something when the passes run out awaits <code>played</code>.</li>
-  <li><b>The host owns every held voice.</b> One cued per spin and never faded stays in the mix for good, one more voice folded every frame. The next voice&rsquo;s cue is the time to fade the last, at once or <code>at: 'rest'</code>.</li>
-  <li><b>Where it changes nothing.</b> A voice that loops for good never runs out of passes, so only <code>'before'</code> applies to it. A motion patch (<code>spring</code>, <code>glide</code>, <code>tween</code>) already holds its target and has no passes, so <code>hold</code> does nothing to it. Lanes give the same pose with it as without them, as for everything else.</li>
-  <li><b>What it costs.</b> A voice holding before runs on the general path while it is pending, which takes the channels it writes off their lanes until it starts; one that is already live, waiting only on a subject&rsquo;s stagger, stays on its lane. A mix with no hold reads no slower (<code>keys</code> and <code>fn</code> rows of <code>bench/frame.mjs</code>, three passes alternated against <code>main</code> on a laptop, 2026-10-03).</li>
+  <li><b>A frozen subject&rsquo;s clock stands still.</b> It reads phase 0 of pass 0 before, and phase 1 of the last pass after, with <code>elapsed</code> pinned to that edge. <code>at</code> is asked for that frame. <code>step</code> does not run while a subject waits, so a stateful patch starts playing from the state it was cued with; after, it runs once more to where the last pass ended and then no more, so the frozen frame does not depend on when the last frame before it fell. A voice freezing before stays <code>pending</code> until it starts, and <code>weightOf</code> reports the weight it gives a waiting subject.</li>
+  <li><b><code>fade.in</code> counts from the first frame the voice shows</b>, so with <code>'before'</code> it ramps in on the frozen frame rather than at full weight, and does not dip when play begins.</li>
+  <li><b>A voice freezing after reaches <code>frozen</code>, not <code>fading</code>,</b> at the moment a voice without a freeze would begin its fade out. <code>played</code> resolves true then. Its <code>out</code> and <code>end</code> marks are unfixed until it is faded, like those of a voice that loops for good, so <code>{ after: 'spin' }</code> waits for the fade. A host that wants to start something when the passes run out awaits <code>played</code>.</li>
+  <li><b>The host owns every frozen voice.</b> One cued per spin and never faded stays in the mix for good, one more voice folded every frame. The next voice&rsquo;s cue is the time to fade the last, at once or <code>at: 'rest'</code>.</li>
+  <li><b>Where it changes nothing.</b> A voice that loops for good never runs out of passes, so only <code>'before'</code> applies to it. A motion patch (<code>spring</code>, <code>glide</code>, <code>tween</code>) already keeps its target and has no passes, so <code>freeze</code> does nothing to it. Lanes give the same pose with it as without them, as for everything else.</li>
+  <li><b>What it costs.</b> A voice freezing before runs on the general path while it is pending, which takes the channels it writes off their lanes until it starts; one that is already live, waiting only on a subject&rsquo;s stagger, stays on its lane. A mix with no freeze reads no slower (<code>keys</code> and <code>fn</code> rows of <code>bench/frame.mjs</code>, three passes alternated against <code>main</code> on a laptop, 2026-10-03).</li>
 </ul>
 
 <p>Weights are the only knob the mix owns. Fade, crossfade, handover, alternatives, and hinge's continuous mode are all weights over time; the section on blending shows each one as such. A patch never sees a weight applied to its output, it only sees the number in <code>setting.weight</code> if it cares.</p>
@@ -526,17 +526,20 @@ interface Mix&lt;I, O, H = unknown&gt; {
   <span class="cm">/** Every mark the plan knows between two timestamps, earliest first. */</span>
   marks(from: number, to: number): Marked[];
 
-  <span class="cm">/** A handle on every voice still in the mix, pending, live, held or fading, in cue order; given a tag, only
+  <span class="cm">/** A handle on every voice still in the mix, pending, live, frozen or fading, in cue order; given a tag, only
      the voices carrying it. Each is the handle `cue` returned for that voice. */</span>
   voices(tag?: string): Handle&lt;I&gt;[];
 
   <span class="cm">/** Anything still contributing, fading, or pending. A host stops its loop when this is false. `cue` and
-     `blend` make it true again at once; the mix never calls back into the host, so restarting the loop is
-     the caller's to do on the same path that cued. */</span>
+     `blend` make it true again at once, and `onWake` says so. */</span>
   readonly live: boolean;
-  <span class="cm">/** Another frame would change no pose: every voice is done, held at a plain weight, or a motion whose every
+  <span class="cm">/** Another frame would change no pose: every voice is done, frozen at a plain weight, or a motion whose every
      subject has landed, or, at rate 0, every voice has started at a plain weight with no anchor. A host may sleep its loop while this is true and `live` still is. */</span>
   readonly inert: boolean;
+  <span class="cm">/** Calls `fn` when a host call makes the mix need frames again after a sync: a cue, a fade, a rate, a seek, a
+     `drop`, a motion retargeted. Once until the next sync, and never during one: the only time the mix calls
+     back into the host, and always from inside a call the host made. A sleeping loop wakes on it. */</span>
+  onWake(fn: () =&gt; void): () =&gt; void;
   <span class="cm">/** Fades every voice out: over `over` when given, over each voice's own `fade.out` otherwise. */</span>
   mute(opts?: { over?: number }): void;
   <span class="cm">/** Forgets per-subject state, a motion patch's included. Call when a subject is retired, or let the WeakMap do it. */</span>
@@ -571,7 +574,7 @@ function gate&lt;I&gt;(of: Signal&lt;I&gt;, at: number): Signal&lt;I&gt;;
 
 <h2 id="time">Time</h2>
 <ul>
-  <li><b>The mix is pull-based on a host clock.</b> The host owns the frame loop and calls <code>sync(timestamp)</code> with milliseconds on any monotonic clock it likes. klieg passes its <code>Clock.now()</code>; wod passes <code>performance.now()</code>; a test passes integers.</li>
+  <li><b>The mix is pull-based on a host clock.</b> The host owns the frame loop and calls <code>sync(timestamp)</code> with milliseconds on any monotonic clock it likes. klieg passes its <code>Clock.now()</code>; wod passes <code>performance.now()</code>; a test passes integers. A host with no loop of its own can take <code>ticker()</code>'s: it syncs every mix it was given on each animation frame, or on a timer where there are none, as in a worker, sleeps while every mix is <code>inert</code>, wakes on <code>onWake</code>, and caps the rate at <code>fps</code> when asked.</li>
   <li><b>Everything in a frame reads one timestamp.</b> A second <code>sync</code> with the same value is a no-op, and every <code>probe</code> between syncs answers from the same frame. This is what makes state advance once however many probes a wrapper makes.</li>
   <li><b>A voice's clock is <code>(timestamp − start) · rate</code>.</b> That reading is <code>setting.elapsed</code>, and its position within the current pass, <code>(elapsed mod duration) / duration</code>, is the <code>phase</code> the patch is handed first. Both reach the patch. A rate change rebases so <code>elapsed</code> is continuous.</li>
   <li><b>The mix has a rate of its own,</b> <code>mix.rate</code> and <code>mix.ramp(rate, over)</code>, shaped like a handle's and multiplied into every voice's: 0 pauses the whole mix, and a negative rate throws, since the mix only goes forward. It runs the mix clock: mix time is the host's timestamp, less what <code>rebase</code> took out, integrated at the mix's rate, and each voice integrates its own rate over mix time, so a ramp on both multiplies and no position jumps. Everything a voice owns runs on mix time and slows with it, which is what a pause has to mean for a fade caught halfway. A timestamp the host gives or reads stays on the host's clock, so a beat announced from an audio clock stays on the beat when the mix slows, and a start ahead of a paused mix waits for the host's clock to reach it. The mix's own ramp runs over host ms, since a ramp over its own slowing time would never arrive. A change made while paused lands at the next sync as always, and a weight signal is still asked at every probe, so one reading input follows it. At rate 0 the mix is <code>inert</code> once every voice not done has started, at a plain weight, with no anchor. Under <code>history</code> every rate change is kept, and a read back finds mix time through them as it finds a voice's clock through its handle's changes; without it a timestamp from before the last change converts at the rate in force, as one from before a <code>rebase</code> converts at the offset in force. weasel also scales a key and a handle; a mix leaves those levels to tags and to the host.
@@ -690,7 +693,7 @@ intro.fade();       <span class="cm">// one envelope over both</span></code></pr
     <tr><td><code>rate</code>, <code>ramp</code></td><td>Multiply into each child's own rate: a child's clock reads its owner's clock where a voice's reads the mix's.</td></tr>
     <tr><td><code>seek</code></td><td>Moves the owner's clock, and every child's phase with it. State stays where it is, as for a voice's own seek.</td></tr>
     <tr><td><code>weight</code> (a number or a signal), <code>fade</code></td><td>Multiply into each child's weight per subject, as the child's own fade does.</td></tr>
-    <tr><td><code>hold</code></td><td>Taken by every child with no hold of its own.</td></tr>
+    <tr><td><code>freeze</code></td><td>Taken by every child with no freeze of its own.</td></tr>
     <tr><td><code>played</code>, <code>done</code></td><td><code>played</code> once every child has finished its passes. The owner leaves once it has held a voice and has none left; a fade that ends takes its children with it.</td></tr>
     <tr><td><code>loop</code></td><td>Refused at <code>owns</code>: a pass would have to restart stateful children (decided 2026-10-04).</td></tr>
   </table></div>
@@ -803,7 +806,7 @@ export const mixer: Engine;   <span class="cm">// the one that ships</span></cod
   <li><b>Subject registration.</b> A <code>mix.subjects(list)</code> call would let the mix step every state eagerly. It puts a second source of truth about the pool in the host. Lazy state keyed by identity, stepped by the gap in the timestamp, needs nothing from the host and is the rule klieg already proved.</li>
   <li><b>A slew in place of the band.</b> Smoothing a gate's input instead of giving it two edges. It delays the crossing without deciding it, so an input that rests on the threshold chatters anyway, and the rate needed to help at all costs visible lag.</li>
   <li><b>Normalizing a locus's weights per channel.</b> The other way to make a crossfade hold its value on <code>mul</code>: keep the scale-and-merge fold and pick a per-channel divisor. It costs the property the mixer's fold order rests on &mdash; that weights are scalars resolved for the subject before any channel is touched &mdash; and it has no answer for <code>last</code>, which has no arithmetic to normalize. The <code>lerp</code> fold gets the same result from the rule the package already has.</li>
-  <li><b>Removing a held voice once another covers it.</b> WAAPI drops a finished, filling animation when a later one replaces every property it sets. In a mix, &ldquo;covers&rdquo; depends on weights, loci and each channel&rsquo;s fold, and a voice leaving on its own would change the pose with no call to point at. The host fades it.</li>
+  <li><b>Removing a frozen voice once another covers it.</b> WAAPI drops a finished, filling animation when a later one replaces every property it sets. In a mix, &ldquo;covers&rdquo; depends on weights, loci and each channel&rsquo;s fold, and a voice leaving on its own would change the pose with no call to point at. The host fades it.</li>
   <li><b>A mix option for the lurch guard.</b> A global "normalize when over 1" would apply to effects that legitimately stack. The cap belongs to the voices that crossfade, so it is a <code>locus</code>.</li>
 </ul>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msb235/blits",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Concurrent effects: each on its own clock with its own state and weight, folded into one value per subject per frame",
   "keywords": [
     "animation",