@msb235/blits 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -4,6 +4,157 @@ 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

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

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

@@ -22,6 +22,8 @@ export interface BookHost<I, O> {
     /** 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. */

package/dist/book.js

@@ -5,10 +5,14 @@ const SLEW = 0.05;
 /** 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}`);
@@ -198,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++) {
@@ -246,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,

package/dist/crowd.js

@@ -317,7 +317,10 @@ function copyVoice(c, p) {
     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.freezesBefore || v.freezesAfter)
+    // A keys or fn voice an owner holds can turn back with the owner, which copies it no more.
+    if (v.freezesBefore ||
+        v.freezesAfter ||
+        (v.motion === undefined && (v.owner !== null || v.hidesPast)))
         f |= 256 /* Flag.FREEZES */;
     if (v.ramp === null &&
         v.owner === null &&

package/dist/cue.js

@@ -1,3 +1,4 @@
+import { blendOf } from './blend.js';
 import { checkHits } from './book.js';
 import { changed } from './chain.js';
 import { copyable } from './clone.js';
@@ -6,14 +7,15 @@ import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
 import { begin } from './held.js';
 import { handle } from './hosts.js';
+import { checkMarks } from './marks.js';
 import { motionOf } from './motion.js';
-import { adopt, ownerPatch, ownerReading } from './owner.js';
+import { adopt, Holding, ownerPatch, ownerReading } from './owner.js';
 import { checkPlacement, localNow, mixAt, pin, place } from './place.js';
 import { enlist } from './roster.js';
 import { scoredAdd } from './scored.js';
 import { checkChild, refit } from './spans.js';
-import { motionOwner } from './strays.js';
-import { record } from './tape.js';
+import { cuedById, motionOwner } from './strays.js';
+import { record, unplayable } from './tape.js';
 import { Voice } from './voice.js';
 export function cue(mix, spec) {
     const patch = spec.patch;
@@ -28,6 +30,8 @@ export function cue(mix, spec) {
         checkPlacement(mix, spec, anchor, owner);
     if (spec.hits !== undefined)
         checkHits(spec.hits, patch.duration);
+    if (spec.marks !== undefined)
+        checkMarks(spec.marks, patch.duration);
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
     // A voice an owner holds is placed on the owner's clock: ms from when it starts.
     const local = owner === null ? mix.now : ownerReading(owner, mix.now);
@@ -51,7 +55,14 @@ export function cue(mix, spec) {
     const h = handle(mix, voice);
     voice.handle = h;
     // By its handle, so a voice a history store paged out and a seek revived is the one cued again.
-    record(mix, 'cue', () => recue(mix, VoiceHandle.voiceOf(h) ?? lost(h)));
+    record(mix, 'cue', (stage) => {
+        const parked = VoiceHandle.voiceOf(h) ?? lost(h);
+        const to = stage.mix(mix);
+        if (to === mix)
+            recue(mix, parked);
+        else if (to !== undefined)
+            recue(to, aheadOf(to, parked));
+    });
     return h;
 }
 /** Refuses a patch writing a channel `kit` lacks, or holds as another kind than it was written for. */
@@ -78,6 +89,10 @@ export function playable(mix, spec) {
         finiteRate(spec.rate);
     if (spec.seek !== undefined && !Number.isFinite(spec.seek))
         throw new RangeError(`blits: a voice's seek is a finite number of ms, not ${spec.seek}`);
+    if (spec.stepMs !== undefined && !(spec.stepMs >= 0 && spec.stepMs < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: a voice's stepMs is a finite number of ms, 0 or more, not ${spec.stepMs}`);
+    if (spec.catchUp !== undefined && spec.catchUp !== 'exact' && spec.catchUp !== 'fresh')
+        throw new RangeError(`blits: catchUp takes 'exact' or 'fresh', not ${String(spec.catchUp)}`);
     if (typeof spec.weight === 'number')
         plainWeight(spec.weight);
     fitsKit(patch, mix.kit);
@@ -110,6 +125,36 @@ function recue(mix, voice) {
         voice.state = 'live';
     enter(mix, voice);
 }
+/** Each read ahead's own blends, by the live blend its copies' members were cued in. */
+const blends = new WeakMap();
+/** A read ahead's copy of a voice a seek parked, as its cue left it, for the copy `to` to cue. */
+function aheadOf(to, parked) {
+    const copy = parked.copy(() => undefined);
+    if (parked.owner !== null) {
+        const owner = cuedById(to, parked.owner.id);
+        if (owner === undefined || owner.holding === null)
+            unplayable('a cue under an owner that has left');
+        copy.owner = owner;
+    }
+    if (copy.holding !== null)
+        copy.holding = new Holding();
+    if (copy.blend !== null) {
+        let own = blends.get(to);
+        if (own === undefined) {
+            own = new Map();
+            blends.set(to, own);
+        }
+        const live = copy.blend.of;
+        let of = own.get(live);
+        if (of === undefined) {
+            of = blendOf(copy.blend.of.by, copy.blend.of.stops);
+            own.set(live, of);
+        }
+        copy.blend = { of, i: copy.blend.i };
+        of.members.push(copy);
+    }
+    return copy;
+}
 function lost(h) {
     throw new Error(`blits: voice ${h.id} is paged out, and the seek that plays its cue again did not load it`);
 }
@@ -120,6 +165,7 @@ function enter(mix, voice) {
     const anchor = spec.anchor;
     const anchored = anchor !== undefined && (anchor.start !== undefined || anchor.in !== undefined);
     const motion = voice.motion;
+    voice.parked = false;
     if (owner !== null)
         adopt(owner, voice);
     if (!Number.isNaN(mix.now)) {
@@ -131,7 +177,8 @@ function enter(mix, voice) {
     // A start the host gave by its own clock, where the mix's rate puts it.
     if (!Number.isNaN(voice.pinned) && voice.state === 'pending')
         pin(mix, voice, voice.pinned);
-    if (motion !== undefined) {
+    // A read ahead's copy leaves the patch asking the live mix for its time.
+    if (motion !== undefined && !mix.projecting) {
         mix.playing.set(motion, (mix.playing.get(motion) ?? 0) + 1);
         mix.owner ??= motionOwner(new WeakRef(mix));
         motion.owner = mix.owner;

package/dist/departed.d.ts

@@ -1,5 +1,5 @@
 import type { Mixer } from './mixer.js';
-import type { Mark, Query } from './types.js';
+import type { MarkName, Query } from './types.js';
 import { type Voice } from './voice.js';
 /**
  * What a mix keeps of a voice it has forgotten, on leaving without history or past history's reach:
@@ -14,7 +14,8 @@ export interface Departed {
     readonly name: string | undefined;
     readonly tags: readonly string[];
     readonly writes: readonly unknown[];
-    readonly marks: Readonly<Record<Mark, number | undefined>>;
+    /** Its five, and those it placed inside itself. */
+    readonly marks: Readonly<Partial<Record<MarkName, number>>>;
     /** How many of the index's ends hold it. */
     held: number;
 }