@msb235/blits 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,173 @@ 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.11.0
+
+### Breaking
+
+- A voice plays one pass unless told otherwise: `loop` defaults to `false`, where it defaulted to
+  `true`. A `cue` that left `loop` out and relied on looping for good now needs `loop: true`. A
+  patch with no duration, and a motion patch, have no passes and play as before.
+- `Marked.mark` and an anchor's `mark` are a `MarkName`, one of a voice's five or a name it placed
+  inside itself, where they were a `Mark`. Code that reads `mark` as one of the five, such as an
+  exhaustive `switch`, needs a case for the rest.
+
+### Added
+
+- `marks` on a voice's, an owner's and a span's spec: named marks inside it beside its five, each
+  at voice ms into a pass, `marks: { drop: 340 }`. An anchor names one as it names the five,
+  `{ of: 'lead', mark: 'drop' }`; `marks` lists it, `book` books it under its name, and a read
+  ahead stops at it. Each is reached once, on the first pass that reaches it from where the voice
+  starts, while its clock runs forward and before it ends. A name of one of the five, and a time
+  outside a pass, are refused at `cue`.
+- `@msb235/blits/lean`: the package with a `mix` that leaves lanes out, for a host whose scenes
+  are too small to need them. It gives the same poses, and a bundle of `mix`, `kit`, `sum` and
+  `patch` is 44.5 kB gzipped against 59.9 from the main entry (esbuild, minified). `lanes: true`
+  is refused there. Its engine is exported as `lean`.
+- A read ahead after a seek back plays the calls the tape holds: `project(t)` past a recorded
+  call threw, and now makes the call on its copies as a seek there makes it on the mix. It still
+  throws for a `drop` of a subject a motion patch holds, and for a retarget or push made before
+  its voice had met the subject. The tape moves forward and back while the read is made.
+- `stepMs` on a voice's spec: the interval its `step` runs at, in place of the mix's. 0 steps it
+  once a frame by the frame's gap.
+- `share(by, i, n)`: member `i` of `n`'s share of a signal, as `mix.blend` weighs it, to weight a
+  voice outside the blend as that member, such as one member played alone.
+- `mix.blend` takes a `BlendMember`, `{ patch, name?, tags?, hits? }`, in place of a bare patch, so
+  a member answers to its own name in an anchor and carries its own tags and hits. Bare patches
+  take the spec's as before.
+- A mix warns, once per patch and outside production, when the first delta a voice's `at` returns
+  holds a key outside the patch's `writes`, naming the voice and the key. The mix still drops the
+  key, as it always has; `checkPatch` in `@msb235/blits/testing` still finds one returned only on
+  some subjects or phases.
+- `hits` and `seek` on an owner's and a span's spec. A hit is an event at a time on the owner's
+  clock, booked once while the owner plays, with its `score` and `tags`; a seek is where that clock
+  starts, so an owner cued at a rate below 0 with a seek plays its children back from there.
+- `seek({ frame })` and `project({ frame })`, on a mix and a transport, reach a frame by its
+  number, which `mix.seq` and `transport.seq` read. Rate 0 can hold mix time still across several
+  frames, and a seek or read by time lands on the last of them; by number it lands on any one
+  history still holds.
+- `catchUp: 'fresh'` on a voice's spec: a stateful subject first probed after its delay ran out
+  starts stepping from that probe with fresh state, where the default, `exact`, steps it from its
+  origin. The `stepMs` grid still counts from the origin, the fade-in is unchanged, and a handle
+  `seek` still rebuilds from the voice's start. Its state depends on when the host first looked,
+  so a read that meets such a subject late assesses it `held`.
+- A read ahead stops at each known event between now and the time read: each call the tape holds,
+  and each mark `marks` would list. A subject asked about is read at every stop, so a patch that
+  steps takes one step per stretch and a signal that keeps state sees each boundary: a voice
+  starting on the way meets its subject at its start, where it met it at the time read. `assess`
+  says `exact` for a stateful signal a read ahead fed, where it said `stepped`. The stops are made
+  only while a voice has a `step` or a signal weight; otherwise a read ahead crosses the gap in
+  one go as before.
+
+### Fixed
+
+- A seek ahead, or a read ahead, to the mix time rate 0 is holding stays at the host's own time.
+  It took the earliest host time the mix read that time at, behind calls already on the tape, so
+  a later seek back cued a voice still playing a second time and the next probe never returned.
+- `weightOf` on lanes reports the weight a voice over every subject gave a subject before a
+  subject fade made it keep a record per subject, until the next read. It said 0, where the
+  general path said the weight.
+- A seek or read back to before a `drop` finds a subject's fade out of a voice as it stood: mid
+  ramp, or faded out. It found the subject at full weight, and one faded out of a voice that had
+  not met it stayed out even before the fade. A subject a motion's retarget brought back after a
+  fade out is found faded out between the two.
+- `rise` on a voice faded before its start leaves it `pending`, to start on time and follow its
+  anchor again, as a seek back finds it. It went `live` at once and played from where its clock
+  would have read 0, ahead of its start, so a seek back played on differently from playing
+  straight through.
+- A read back to the frame a `drop` was made in, before anything read the mix that frame, shows
+  the subject met afresh, as the frame did. It showed the record the subject had before the drop,
+  a slewed weight's state included, in `project(t)` and `project({ frame })`.
+- `assess` after a seek back says `stepped` for a stateful signal the seek put back from a copy
+  history kept and stepped on, where a read at the mix's own time said `exact`. It goes on saying
+  so for that record as the mix plays on, since the state carries on from the step.
+- A voice running back from past its end shows nothing until it reaches its passes, unless it
+  freezes after, as a voice playing forward shows nothing before its start unless it freezes
+  before. It showed its last frame: `rate: -1, seek: 600` on a 300 ms pass showed it for its
+  first 300 ms, and so did a child its owner, turned back, had put past its end.
+- An owner's `out` and `end` marks are known while it plays, at its last child's end, once every
+  child's end is. They were fixed only when it left, so `marks` listed them only then and only
+  under `history`, a booker took them a frame late, an anchor to an owner's end waited until it
+  left, and without `history` they were never booked. Its `coast` stays listed once it has left,
+  where it went with its last child.
+- `pull` reads `undefined` at a position its list has gained. A list read as `[undefined]` and
+  then as `[undefined, undefined]` threw, reading the new position as the subject it read there
+  last time.
+- A spring, glide or tween made by another copy of blits of the same release, loaded beside this
+  one, runs as a motion on this copy's mix: on lanes, and retargeted, pushed and read through its
+  handle, which refused it. It played through `at` off the lanes. Copies of different releases
+  still keep apart.
+- `mix.span` refuses a rate below 0. A span cued backward placed none of its children, which
+  waited for good, and never left. Its handle's `rate` still turns one that plays.
+- A voice whose patch has no duration books no hits while its clock runs back, as every other
+  voice does. One cued backward booked each hit ahead of it.
+- A fade set for a time after a voice's passes run out no longer begins in place of the voice
+  ending, where one frame crossed both: `fade({ at })` on a voice with no `freeze` that ended
+  before `at` played on, held at its last frame, until the fade finished.
+- A seek forward to the time of a recorded call lands that frame once. It landed it again after
+  the call, so a `rise` played there on a voice past its end began the voice's fade over.
+- A voice cued with `seek`, or sought while pending, keeps its count of rebuilds with its
+  controls when it starts. A seek back to after its start, then a handle `seek` played again
+  before the subject was read, left the subject's state as it was rather than rebuilding it.
+- A mix sought back time after time no longer steps a subject from the same copy of its state,
+  further each time. A seek lets go of the copies made after the moment it sought, so a mix
+  sought 300 ms back and to where it was before every frame stepped each subject from the copy
+  before its first seek: 70 steps at the first frame and 1069 at the 300th, at `stepMs` 5. The
+  copy a record is put back from now keeps its state stepped ahead to near the moment sought,
+  and the next record put back from it steps on from there: 67 to 74 steps at every frame. It
+  shows the same values. Under `maxDt`, without `stepMs`, or for a patch that `reads` a host
+  field, a record steps from the copy as before.
+- Replacing a voice makes less garbage. A one-subject tween voice retargeted as it is cued, while
+  another leaves and its subject is dropped, allocates about 13 KB, from 21.5
+  (`bench/churnwho.mjs`, 5,000 voices), and a `pull` keeps what it knows of a channel between
+  calls, about 1.2 KB a call for four channels. Frame time is unchanged.
+- A seek back, or a read back, places a subject whose start had moved while it waited where the
+  move put it. A copy of a record kept while its `stagger` delay was running, on a voice with
+  `freeze: 'before'`, holds the start as it was then; a rate, a ramp, a `seek` with
+  `state: 'keep'`, an owner's rate or the mix's rate then moved that start, and a record put back
+  from the copy to a moment past the old start kept the old one, so its `step` ran on from the
+  wrong time. A seek lets go of the later copies, so a mix sought back before every frame showed
+  it at every frame from then on; `project(t)` showed it for `t` up to one copy's interval past
+  the move.
+- A seek back to before a subject faded out of a voice finds the voice reaching it again, where
+  the voice had not met the subject before the fade. The subject stayed out of the voice with
+  `lanes: false`, and with lanes on for a voice naming its `subjects`; otherwise lanes brought it
+  back, so the two paths read differently. A read back to before the fade, `project(t)`, left
+  it out on both, and reaches it now.
+- A seek or a read back into a subject's ramp out of a voice, `fade({ subject, over })`, finds
+  the ramp once it has ended. The subject read at full weight there, and after a seek it stayed
+  in the voice at full weight for good.
+- `weightOf` reads 0 after a seek back until the subject is probed again. What a subject's last
+  probe by then read is not kept, and it reported a weight from after the moment sought, or one
+  older than its last probe for a voice on a lane, so the two paths read differently.
+- A write to the handle of a voice waiting for its cue after a seek back changes nothing, and the
+  tape does not record it. It put the voice on the mix's schedule, so the voice started at its
+  start time outside the mix, folded in but missing from `voices()`, and it branched the tape,
+  which left the voice's cue in the old future.
+- Dropping a subject no longer costs time in step with how many subjects the mix holds. With a
+  tween voice per subject, stopping one voice and dropping its subject cost 2.2 µs among 1,000
+  subjects and 15.6 among 10,000; it costs 0.9 and 2.6 (`bench/restart.mjs`).
+- The first `pull` after a voice naming a subject comes or goes, or a subject is dropped, no
+  longer reads every subject's chain to find the ones that changed, and a retargeted tween copies
+  its stretch without an iterator. The frame after 100 voices are replaced among 10,000 took
+  about 2.1 ms and takes about 1.35.
+
+## 0.10.0
+
+### Breaking
+
+- A booker is ended with `cancel()`, and `take` returns `{ cancel() }` to hear that its item moved
+  or went away. Both were `stop`: `mix.book(...).stop()` and `{ stop() }`.
+
+### Added
+
+- A booked hit carries `subjects`: the ones its voice names with `subjects`, or undefined for a
+  voice that names none. `BookedHit` and `BookOptions` take the subject type as a second
+  parameter.
+- `at(timestamp)` on a booker: where a host time falls on the outside clock, by the offset the
+  booker keeps.
+- `mix.timestamp`: the host's timestamp at the last sync.
+
 ## 0.9.0
 
 ### Breaking

package/README.md

@@ -28,7 +28,7 @@ const flicker = patch<Part, PartPose>(
 );
 
 const m = mix<Part, PartPose>(PART);
-const handle = m.cue({ patch: flicker, fade: { in: 300, out: 300 } });
+const handle = m.cue({ patch: flicker, loop: true, fade: { in: 300, out: 300 } });
 
 // Once a frame: tell the mix what time it is, then ask for the parts you are about to draw.
 function frame(timestamp: number) {
@@ -48,12 +48,12 @@ In order, on the same mix:
 
 ```ts
 // Place a voice at a time on the host's clock, or against another voice's marks.
-m.cue({ patch: typeIn, name: 'title', start: 1000, loop: false });
-m.cue({ patch: tint, loop: false, anchor: { start: { after: 'title', by: 200 } } });
+m.cue({ patch: typeIn, name: 'title', start: 1000 });
+m.cue({ patch: tint, anchor: { start: { after: 'title', by: 200 } } });
 
 // A span fits the voices it holds into a budget, one after another by default.
 const intro = m.span({ duration: 2000 });
-for (const line of lines) m.cue({ patch: typeIn, loop: false, owner: intro });
+for (const line of lines) m.cue({ patch: typeIn, owner: intro });
 
 // Read the mix half a second ahead without moving it, or move it: a scrubber.
 const next = m.project(m.now + 500).probe(part);
@@ -91,6 +91,17 @@ npm run site:smoke   # build, then load every page headless and fail on any erro
 
 `.github/workflows/site.yml` deploys it to GitHub Pages on every push to `main`, and by hand.
 
+## A smaller bundle
+
+Lanes, which work a channel out for every subject at once, are about a quarter of the package. A
+host with tens of subjects does not need them:
+
+```ts
+import { kit, mix, patch, sum } from '@msb235/blits/lean';
+```
+
+Everything else is the same and so are the poses. `lanes: true` is refused there.
+
 ## Writing patches for blits in another library
 
 A library that ships patches exports them with the channels they write, as a `Kit` of its own
@@ -123,7 +134,7 @@ do yet.
 
 ## Status
 
-v0.9.0, with five consumers. magicsmoke runs every fault on it, wod its wheel, tricks and
+v0.10.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.

package/dist/blend.js

@@ -1,5 +1,6 @@
 import { stateful } from './hosts.js';
 import { reading } from './reading.js';
+import { shareOf } from './signals.js';
 import { Store } from './store.js';
 export function blendOf(by, stops) {
     return {
@@ -29,11 +30,6 @@ export function ownBlends(voices) {
         of.members.push(v);
     }
 }
-/** A blend member's weight for its signal's read `k`: the members' stops sit evenly along 0..1. */
-function shareOf(k, i, stops) {
-    const d = stops === 0 ? 0 : Math.abs(k * stops - i);
-    return d >= 1 ? 0 : 1 - d;
-}
 /** A blend member's share of its signal's read for this subject this frame, made by the first to ask. */
 export function blended(voice, subject, held, slot) {
     const { of, i } = voice.blend;

package/dist/book.d.ts

@@ -19,9 +19,11 @@ export interface BookHost<I, O> {
     /** Mix time a voice is gone at, where something has fixed it. */
     endOf(voice: Voice<I, O>): number | undefined;
     marks(from: number, to: number): Listed[];
-    /** The booker stopped: forget it. */
+    /** The booker canceled: forget it. */
     unhook(booker: Book<I, O>): void;
 }
+/** Whether voice ms `at` falls in a pass of a patch `duration` long: 0 up to it, or 0 on for none. */
+export declare function inPass(at: number, duration: number): boolean;
 /** Refuses hits a voice could never play. */
 export declare function checkHits(hits: readonly Hit[], duration: number): void;
 /** One `book` call: maps host time onto the outside clock and takes each item once. */
@@ -34,22 +36,23 @@ export declare class Book<I, O> implements Booker {
     /** The mix clock at the previous sync, where a voice's clock change counts from. */
     private prev;
     private round;
-    private stopped;
+    private canceled;
     /** The host time the mix last sought at: a mark at or before it was taken before the seek. */
     private floor;
     /** Bookings of marks, by `keyOf`, kept while listed so one already taken is not taken late. */
     private readonly marked;
     private readonly tracks;
     private readonly due;
-    constructor(host: BookHost<I, O>, opts: BookOptions);
+    constructor(host: BookHost<I, O>, opts: BookOptions<unknown, I>);
     /** Books what comes within `ahead` of this sync, and retracts what moved. */
     sync(): void;
-    stop(): void;
+    cancel(): void;
     /**
-     * The mix was sought to `host.now`, back or ahead: what is booked ahead is stopped, and
+     * The mix was sought to `host.now`, back or ahead: what is booked ahead is canceled, and
      * everything after that moment is booked as the mix reaches it.
      */
     sought(): void;
+    at(timestamp: number): number;
     /** Whether a standing booking now falls at host time `time` within `RETIME_MS`. */
     private stands;
     private fits;

package/dist/book.js

@@ -2,13 +2,17 @@
 const RESYNC_MS = 50;
 /** The share of each frame's residual folded into the offset. */
 const SLEW = 0.05;
-/** A booking whose time moves by more than this is stopped and taken again. */
+/** A booking whose time moves by more than this is canceled and taken again. */
 const RETIME_MS = 1;
 const none = [];
+/** Whether voice ms `at` falls in a pass of a patch `duration` long: 0 up to it, or 0 on for none. */
+export function inPass(at, duration) {
+    return at >= 0 && (duration > 0 ? at < duration : Number.isFinite(at));
+}
 /** Refuses hits a voice could never play. */
 export function checkHits(hits, duration) {
     for (const h of hits)
-        if (!(h.at >= 0) || (duration > 0 ? !(h.at < duration) : !Number.isFinite(h.at)))
+        if (!inPass(h.at, duration))
             throw new RangeError(duration > 0
                 ? `blits: a hit's at is voice ms into a pass, 0 up to ${duration}, not ${h.at}`
                 : `blits: a hit's at is voice ms, 0 or more, not ${h.at}`);
@@ -23,7 +27,7 @@ export class Book {
     /** The mix clock at the previous sync, where a voice's clock change counts from. */
     prev = Number.NaN;
     round = 0;
-    stopped = false;
+    canceled = false;
     /** The host time the mix last sought at: a mark at or before it was taken before the seek. */
     floor = Number.NEGATIVE_INFINITY;
     /** Bookings of marks, by `keyOf`, kept while listed so one already taken is not taken late. */
@@ -36,7 +40,7 @@ export class Book {
     }
     /** Books what comes within `ahead` of this sync, and retracts what moved. */
     sync() {
-        if (this.stopped)
+        if (this.canceled)
             return;
         const host = this.host;
         const now = host.timestamp;
@@ -72,36 +76,36 @@ export class Book {
                 if (b.time <= now)
                     t.booked.delete(k);
     }
-    stop() {
-        if (this.stopped)
+    cancel() {
+        if (this.canceled)
             return;
-        this.stopped = true;
+        this.canceled = true;
         for (const b of this.marked.values())
             if (b.time > this.last)
-                b.taken?.stop();
+                b.taken?.cancel();
         for (const t of this.tracks.values())
             for (const b of t.booked.values())
                 if (b.time > this.last)
-                    b.taken?.stop();
+                    b.taken?.cancel();
         this.marked.clear();
         this.tracks.clear();
         this.host.unhook(this);
     }
     /**
-     * The mix was sought to `host.now`, back or ahead: what is booked ahead is stopped, and
+     * The mix was sought to `host.now`, back or ahead: what is booked ahead is canceled, and
      * everything after that moment is booked as the mix reaches it.
      */
     sought() {
-        if (this.stopped)
+        if (this.canceled)
             return;
         const last = this.last;
         for (const b of this.marked.values())
             if (b.time > last)
-                b.taken?.stop();
+                b.taken?.cancel();
         for (const t of this.tracks.values())
             for (const b of t.booked.values())
                 if (b.time > last)
-                    b.taken?.stop();
+                    b.taken?.cancel();
         this.marked.clear();
         this.tracks.clear();
         const host = this.host;
@@ -116,6 +120,9 @@ export class Book {
                     met: this.round,
                 });
     }
+    at(timestamp) {
+        return this.est + (timestamp - this.last);
+    }
     /** Whether a standing booking now falls at host time `time` within `RETIME_MS`. */
     stands(b, time) {
         if (time === undefined || !Number.isFinite(time))
@@ -139,7 +146,7 @@ export class Book {
             if (b !== undefined) {
                 if (b.time <= now || this.stands(b, m.timestamp))
                     continue;
-                b.taken?.stop();
+                b.taken?.cancel();
                 marked.delete(key);
             }
             const { order: _, ...item } = m;
@@ -148,7 +155,7 @@ export class Book {
         for (const [key, b] of marked)
             if (!seen.has(key)) {
                 if (b.time > now)
-                    b.taken?.stop();
+                    b.taken?.cancel();
                 marked.delete(key);
             }
     }
@@ -184,7 +191,7 @@ export class Book {
                 const time = this.timeOfHit(voice, hits, Math.floor(key / n), key % n, end);
                 if (this.stands(b, time))
                     continue;
-                b.taken?.stop();
+                b.taken?.cancel();
                 t.booked.delete(key);
                 moved = true;
             }
@@ -195,6 +202,11 @@ export class Book {
             if (!(hi > t.seenTo))
                 continue;
             const lo = Math.max(t.seenTo, voice.elapsedAt(loAt));
+            // Its clock runs back: hits come only as it runs forward.
+            if (!(lo <= hi)) {
+                t.seenTo = hi;
+                continue;
+            }
             const d = voice.duration;
             const last = d > 0 ? Math.min(voice.passes - 1, Math.floor(hi / d)) : 0;
             for (let pass = d > 0 ? Math.max(0, Math.floor(lo / d)) : 0; pass <= last; pass++) {
@@ -217,6 +229,7 @@ export class Book {
                         score: voice.spec.score,
                         name: voice.spec.name,
                         tags: voice.spec.tags ?? none,
+                        subjects: voice.named?.list,
                     };
                     this.due.push({ time, item, into: t.booked, key });
                 }
@@ -228,7 +241,7 @@ export class Book {
                 continue;
             for (const b of t.booked.values())
                 if (b.time > now)
-                    b.taken?.stop();
+                    b.taken?.cancel();
             this.tracks.delete(voice);
         }
     }
@@ -242,8 +255,23 @@ export class Book {
         return this.host.hostOf(t);
     }
 }
-const markIndex = { start: 1, in: 2, coast: 3, out: 4, end: 5 };
 /** A mark's identity: its voice and which of its marks, or the announcement. */
 function keyOf(m) {
-    return m.order * 6 + (m.mark === undefined ? 0 : markIndex[m.mark]);
+    const k = m.order * 6;
+    switch (m.mark) {
+        case undefined:
+            return k;
+        case 'start':
+            return k + 1;
+        case 'in':
+            return k + 2;
+        case 'coast':
+            return k + 3;
+        case 'out':
+            return k + 4;
+        case 'end':
+            return k + 5;
+        default:
+            return `${m.order}\u0000${m.mark}`;
+    }
 }

package/dist/chain.d.ts

@@ -12,12 +12,23 @@ export declare function relink<I, O>(this: Mixer<I, O>, subject: I, was: Subject
 export declare function linkable<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, 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;
+/**
+ * The record a voice has of a subject now, as a seek or a read back to mix time `now` and frame
+ * `seq` takes it: none where it says only that the voice does not reach a subject it reached
+ * then, before the subject faded out of it. The subject had no record then, and is met afresh.
+ */
+export declare function heldAt<I, O>(voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined, now: number, seq: number): Subject<unknown> | undefined;
 /**
  * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
  * are relinked, every subject's for a voice over all of them and only its own for one naming
  * its subjects, and lanes take it on or off.
  */
 export declare function changed<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/**
+ * Makes one subject's chain stale, to be linked again at its next read, and counts it in `relinks`,
+ * which its number is stamped with for `pull`.
+ */
+export declare function unlink<I, O>(mix: Mixer<I, O>, head: Subject<unknown>): void;
 /** Files a voice under each subject it names, or among the voices that name none. */
 export declare function index<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
 export declare function unindex<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;

package/dist/chain.js

@@ -87,14 +87,26 @@ export function linkable(voice, subject, slot) {
 }
 /** Whether a voice reaches a subject by what its spec says: the subjects it names, or its `target`. */
 export function aims(voice, subject) {
+    return aimsAt(voice, subject, this.now);
+}
+/** As `aims` at mix time `now`, counting a subject as faded out only by frame `seq`. */
+function aimsAt(voice, subject, now, seq = Number.POSITIVE_INFINITY) {
     // A read back to before a subject left still finds it reached.
     const left = voice.parted?.get(subject);
-    if (left !== undefined && !(this.now < left.at))
+    if (left !== undefined && !(now < left.at) && left.seq <= seq)
         return false;
     if (voice.named !== null)
         return voice.named.has(subject);
     return voice.spec.target ? voice.spec.target(subject) : true;
 }
+/**
+ * The record a voice has of a subject now, as a seek or a read back to mix time `now` and frame
+ * `seq` takes it: none where it says only that the voice does not reach a subject it reached
+ * then, before the subject faded out of it. The subject had no record then, and is met afresh.
+ */
+export function heldAt(voice, subject, held, now, seq) {
+    return held !== undefined && !held.reaches && aimsAt(voice, subject, now, seq) ? undefined : held;
+}
 /**
  * A voice joined or left the list, or started or stopped waiting: the chains it is linked into
  * are relinked, every subject's for a voice over all of them and only its own for one naming
@@ -114,10 +126,20 @@ export function changed(mix, voice) {
     for (const subject of voice.named) {
         const head = mix.chains.get(subject);
         if (head !== undefined)
-            head.version = Number.NaN;
+            unlink(mix, head);
     }
     mix.relinks++;
 }
+/**
+ * Makes one subject's chain stale, to be linked again at its next read, and counts it in `relinks`,
+ * which its number is stamped with for `pull`.
+ */
+export function unlink(mix, head) {
+    head.version = Number.NaN;
+    const at = ++mix.relinks;
+    if (head.slot >= 0 && mix.lanes !== null)
+        mix.lanes.unlinked[head.slot] = at;
+}
 /** Files a voice under each subject it names, or among the voices that name none. */
 export function index(mix, voice) {
     if (voice.holding !== null)

package/dist/clock.d.ts

@@ -88,3 +88,17 @@ export declare function rebaseWith(c: Clock, now: number): void;
  * has then, so what it reads stays continuous and so does its speed.
  */
 export declare function retime(c: Clock, now: number, rate: number, over: number): void;
+/**
+ * The fixed interval a voice's `step` runs at: its own `stepMs`, else the mix's. Undefined where
+ * it steps once a frame by the frame's gap, as every voice does under reduced motion.
+ */
+export declare function stepOf(mix: {
+    readonly opts: {
+        readonly stepMs?: number;
+    };
+    readonly reducedNow: boolean;
+}, voice: {
+    readonly spec: {
+        readonly stepMs?: number;
+    };
+}): number | undefined;

package/dist/clock.js

@@ -1,6 +1,6 @@
 /** How many passes a voice's `loop` plays. */
 export function passesOf(loop) {
-    const l = loop ?? true;
+    const l = loop ?? false;
     return l === true ? Number.POSITIVE_INFINITY : l === false ? 1 : l;
 }
 /** Whether `elapsed` voice ms is past the last of `passes` passes of a patch of `duration` ms. */
@@ -177,3 +177,11 @@ export function retime(c, now, rate, over) {
     c.ramp = over > 0 && rate !== from ? { from, to: rate, over } : null;
     c.rate = rate;
 }
+/**
+ * The fixed interval a voice's `step` runs at: its own `stepMs`, else the mix's. Undefined where
+ * it steps once a frame by the frame's gap, as every voice does under reduced motion.
+ */
+export function stepOf(mix, voice) {
+    const tick = voice.spec.stepMs ?? mix.opts.stepMs;
+    return tick !== undefined && tick > 0 && !mix.reducedNow ? tick : undefined;
+}

package/dist/columns.d.ts

@@ -12,13 +12,12 @@ export interface Column {
 export declare function clampRun(out: Float64Array, at: number, n: number, [lo, hi]: readonly [number, number]): void;
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
- * `heads` holds each position's remembered chain head unless all are known current: what
+ * each position's remembered chain head was current when the mix's `relinks` read `since`: what
  * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
- * from the lanes; returns the first position that does not, or the list's length.
+ * from the lanes and its head has not been made stale since; returns the first position that does
+ * not, or the list's length.
  */
-export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, list: readonly I[], was: readonly I[], heads: readonly ({
-    version: number;
-} | undefined)[] | null, from: number, columns: readonly Column[], now: number, version: number): number;
+export declare function pullRun<I, O>(lanes: Lanes<I, O>, slots: Int32Array, list: readonly I[], was: readonly I[], since: number, from: number, columns: readonly Column[], now: number, version: number): number;
 /**
  * Queues a subject's values for each column at subject `n`'s places, for a `pull` that reads
  * from the lanes while every voice is on one; `flush` writes what is queued, column by column. A

package/dist/columns.js

@@ -6,11 +6,12 @@ export function clampRun(out, at, n, [lo, hi]) {
 }
 /**
  * For a `pull` of a list it read last time in the same order, with every voice on a lane, where
- * `heads` holds each position's remembered chain head unless all are known current: what
+ * each position's remembered chain head was current when the mix's `relinks` read `since`: what
  * `prepare` and `writeLater` do for each subject from position `from`, while the subject reads
- * from the lanes; returns the first position that does not, or the list's length.
+ * from the lanes and its head has not been made stale since; returns the first position that does
+ * not, or the list's length.
  */
-export function pullRun(lanes, slots, list, was, heads, from, columns, now, version) {
+export function pullRun(lanes, slots, list, was, since, from, columns, now, version) {
     const ready = lanes.filled(now, version) ? 1 /* Begin.READY */ : lanes.begin(now, version);
     if (ready !== 1 /* Begin.READY */ || !lanes.whole)
         return from;
@@ -20,6 +21,8 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
     const wide = lanes.wide;
     const frame = lanes.frameProbes;
     const subjects = lanes.subjects;
+    const unlinked = lanes.unlinked;
+    const current = since === Number.POSITIVE_INFINITY;
     if (columns !== lanes.queuedFor) {
         flush(lanes);
         lanes.queuedFor = columns;
@@ -35,11 +38,12 @@ export function pullRun(lanes, slots, list, was, heads, from, columns, now, vers
     let start = from;
     for (; n < list.length; n++) {
         const subject = list[n];
-        if (was[n] !== subject || (heads !== null && heads[n]?.version !== version))
+        if (was[n] !== subject)
             break;
         const slot = slots[n];
         const o = slot * 6 /* Per.SLOT */;
         if (slot < 0 ||
+            (!current && !(unlinked[slot] <= since)) ||
             per[o + 0 /* Per.FILLED */] >= busy ||
             per[o + 2 /* Per.IDLE */] !== 0 ||
             per[o + 1 /* Per.SEEN */] < wide ||
@@ -163,6 +167,8 @@ function rests(lanes, c, runs) {
                 out[i + a] = c.rest[a];
     }
 }
+/** The longest run of values `copies` copies itself: `set` takes a view, an object a run. */
+const VIEWED = 256;
 /** Copies a laned channel's values for every queued run into its rows. */
 function copies(lanes, c, values, runs) {
     const slots = lanes.queueSlots;
@@ -174,7 +180,7 @@ function copies(lanes, c, values, runs) {
         const at = rows[r] * axes;
         const base = slots[r] * axes;
         const span = counts[r] * axes;
-        if (span > 64)
+        if (span > VIEWED)
             out.set(values.subarray(base, base + span), at);
         else
             for (let i = 0; i < span; i++)

package/dist/crowd.d.ts

@@ -47,7 +47,7 @@ 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 freezes before or after, so its clock is read from the voice. */
+    /** The voice freezes, or may run back past its end, 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,