@msb235/blits 0.8.1 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,104 @@ 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.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
+
+- A stock `last()` channel in a locus takes its heaviest member's value, and the later cued of
+  two as heavy. It stepped through its members in cue order, so three voices at weights 0.3,
+  0.3, and 0.4 showed the second. Two members read as before.
+- A placement whose `end` comes before its start is an instant: the voice starts and ends at its
+  start, shows nothing, and warns once outside production. Its `end` mark was reported ahead of
+  its `start`, so a voice anchored after it started before it did, and with a `fade.out` it
+  showed a whole fade from its start. An `end` that leaves less room than `fade.out` now
+  shortens the fade to finish when asked, where the fade ran its whole length past it, and an
+  `out` before the start is reported at the start, where its fade always began.
+- A `to` or `push` that brings back a subject faded out of its voice is made at the frame of
+  the call, as one for a subject never faded is. It was made at the subject's next read, so how
+  far the motion had got depended on when the host next probed the subject.
+- A handle `seek` on a pending voice holds: the voice starts on time, already at the sought
+  position, and one freezing before shows that frame while it waits. The seek was taken from
+  the moment of the call, and lost outright when an anchor or the mix's rate moved the start.
+- A rate of 0, a negative rate, or a ramp set on a pending voice applies from its start, as a
+  rate above 0 always did. At rate 0 the voice starts on time and holds its first frame, where
+  it stopped its clock short of its start for good and never showed.
+
+- A voice playing backward ends where it starts. When its clock runs back to 0, `played`
+  resolves and it leaves over `fade.out`, showing its first frame through the fade, or holds
+  that frame where it freezes before; its `coast`, `out`, and `end` marks are there. A voice at
+  a rate below 0 showed nothing once past its start and never left the mix. A stateful patch
+  steps once more to the moment its subject reached its start.
+- A voice cued at a rate below 0 with no `seek` starts at its end, where it started at 0 and
+  was over at once.
+- A fade in counts from no earlier than its voice's start. A subject whose delay had already run
+  out when the voice started (a negative `stagger`, or a seek made in the frame of the cue)
+  came in with its fade partway or done.
+
+### Added
+
+- `seek` on a cue: where in itself the voice starts, in voice ms.
+- A voice with no end cued backward, a loop for good or a patch with no duration, plays from 0
+  into the pass before, with `setting.pass` and `setting.elapsed` below 0. It runs on the
+  general path.
+- `handle.ramp` through 0 eases a voice into reverse, or out of it.
+- `@msb235/blits-tone`, a package in `packages/tone` that drives Tone.js from a mix on the audio
+  clock. Its own changelog has what it does.
+
+### Fixed
+
+- `project(mix.now)` reads what `probe` does. It landed what the next sync would, so after a
+  handle `seek` past a voice's end it showed the voice gone while the mix still showed its last
+  frame, and after a fade it placed a voice anchored on the faded one a frame early.
+- A read back of a voice that was pending counts each subject's origin from the controls the
+  voice had then, not from where a later seek, rate, or anchor has since put it.
+
+- A seek back inside `history.ms` plays the host's calls again when the mix's rate is above 1.
+  The tape was let go of by mix time while its calls are stamped in host time, so at rate 2 a call
+  made 250 ms of host time before a seek back was already gone and never played again.
+- A voice taken out with a time already older than history reaches, such as `fade({ at })` given
+  a moment long past, comes back for a seek or a read back to before that call. It was forgotten
+  at the next sync, so `seek` and `project` to the frame before the call found no voice.
+- A `HistoryStore` is told of every seek back through `cut`, as its doc says. It was told only
+  when the seek read records from the store, so a mark announced with a past `at`, paged at once,
+  stayed in the store after a seek back to before it was announced.
+- A `color(last())` channel on a lane switches off when its voice's weight falls to 0, as it does
+  off lanes. A lane left it on, so a weight coming back inside the band (0.4 to 0.6 by default)
+  showed the color where a mix with `lanes: false` showed none.
+
+- A span's children play from where the one before each ended, not from the frame that noticed
+  it. Each child leaving fitted the rest again from the sync's time, so the next started up to a
+  frame late and the rest sped up to make room: 200 children of 10 ms in a 2000 ms span, fitted
+  with none skipped at cue, had 199 skipped once synced every 16 ms. A read ahead never fitted
+  again, so `project` showed a child retimed by `faster` up to a frame ahead of the mix.
+
+- A voice whose owner runs backward leaves over its `fade.out` from where it reached its start,
+  as one turned back by its own handle does. An owner run back to its start left at once and
+  took every voice it held with it, so a child with a 100 ms `fade.out` vanished in one frame
+  and listed no `coast`, `out`, or `end` mark. An owner at its start now stays for what it
+  holds and leaves with its last child.
+
+- `setting.dt` is the gap since the subject was last sampled for a patch with no `step`, and for
+  a weight signal, as its doc says. It was the time since the subject's origin, growing every
+  frame: a mix synced at 16, 48, and 64 handed such a patch 16, 48, and 64, and now hands it 16,
+  32, and 16.
+
 ## 0.8.1
 
 ### Fixed

package/README.md

@@ -116,9 +116,14 @@ state shared between subjects, a `step` that lands differently from the same sta
 [three.quarks](https://github.com/Alchemist0823/three.quarks) particles. It is published separately
 so the engine keeps no dependencies; its README says how it works.
 
+`packages/tone` is `@msb235/blits-tone`, a driver that schedules a mix on the audio clock through
+[Tone.js](https://tonejs.github.io): channels as parameter curves read ahead, and hits and marks at
+their sample. It is published separately for the same reason, and its README says what it does not
+do yet.
+
 ## Status
 
-v0.8.1, 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.
@@ -135,7 +140,12 @@ Zero runtime dependencies, ESM only, types included.
 
 ```
 npm install
-npm run check   # lint, typecheck, test
+npm run check          # lint, typecheck, test
+npm run test:general   # the tests again with lanes off
 ```
 
+A lane is a channel the mix computes for every subject at once, and the general path is the same
+fold made subject by subject. `test:general` turns lanes off in every mix that does not set `lanes`
+itself, so the whole suite runs on the general path.
+
 MIT.

package/dist/book.d.ts

@@ -19,7 +19,7 @@ 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;
 }
 /** Refuses hits a voice could never play. */
@@ -34,22 +34,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,7 +2,7 @@
 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 = [];
 /** Refuses hits a voice could never play. */
@@ -23,7 +23,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 +36,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 +72,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 +116,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 +142,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 +151,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 +187,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;
             }
@@ -217,6 +220,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 +232,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);
         }
     }

package/dist/clock.d.ts

@@ -69,6 +69,16 @@ export interface Clock {
 export declare function elapsedWith(c: Clock, now: number): number;
 /** The time a clock reads `elapsed`, inverting `elapsedWith`; Infinity where it never will. */
 export declare function timeWith(c: Clock, elapsed: number): number;
+/**
+ * The time a clock running back reads `elapsed`: `timeWith` for the clock that reads the negative
+ * of this one, which runs forward where this runs back.
+ */
+export declare function backWith(c: Clock, elapsed: number): number;
+/**
+ * The phase of a time before 0, for a loop with no first pass: where the pass before 0, and each
+ * one before that, would read it.
+ */
+export declare function phaseBefore(elapsed: number, duration: number): number;
 /** A clock's rate at `now`. */
 export declare function rateWith(c: Clock, now: number): number;
 /** Moves a clock's anchor to `now`, carrying what is left of a ramp. */

package/dist/clock.js

@@ -125,6 +125,29 @@ export function timeWith(c, elapsed) {
         return Number.POSITIVE_INFINITY;
     return c.anchorNow + r.over + (elapsed - atEnd) / r.to;
 }
+/**
+ * The time a clock running back reads `elapsed`: `timeWith` for the clock that reads the negative
+ * of this one, which runs forward where this runs back.
+ */
+export function backWith(c, elapsed) {
+    const r = c.ramp;
+    return timeWith({
+        anchorNow: c.anchorNow,
+        anchorElapsed: -c.anchorElapsed,
+        rate: -c.rate,
+        ramp: r === null ? null : { from: -r.from, to: -r.to, over: r.over },
+    }, -elapsed);
+}
+/**
+ * The phase of a time before 0, for a loop with no first pass: where the pass before 0, and each
+ * one before that, would read it.
+ */
+export function phaseBefore(elapsed, duration) {
+    if (!(duration > 0))
+        return 0;
+    const into = elapsed % duration;
+    return (into < 0 ? into + duration : into) / duration;
+}
 /** A clock's rate at `now`. */
 export function rateWith(c, now) {
     const r = c.ramp;

package/dist/cue.js

@@ -4,7 +4,7 @@ import { copyable } from './clone.js';
 import { schedule } from './due.js';
 import { shares } from './everyone.js';
 import { finiteRate, plainWeight, VoiceHandle } from './handle.js';
-import { reorigin } from './held.js';
+import { begin } from './held.js';
 import { handle } from './hosts.js';
 import { motionOf } from './motion.js';
 import { adopt, ownerPatch, ownerReading } from './owner.js';
@@ -76,6 +76,8 @@ export function playable(mix, spec) {
         throw new RangeError(`blits: loop takes true, false or a whole number of passes, not ${loop}`);
     if (spec.rate !== undefined)
         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 (typeof spec.weight === 'number')
         plainWeight(spec.weight);
     fitsKit(patch, mix.kit);
@@ -150,13 +152,8 @@ function enter(mix, voice) {
         mix.wantsPose = true;
     if (anchor) {
         place(mix);
-        if (!Number.isNaN(mix.now) &&
-            voice.state === 'pending' &&
-            localNow(mix, voice) >= voice.start) {
-            voice.state = 'live';
-            reorigin(mix, voice, mix.now);
-            changed(mix, voice);
-        }
+        if (!Number.isNaN(mix.now) && voice.state === 'pending' && localNow(mix, voice) >= voice.start)
+            begin(mix, voice, mix.now);
     }
     if (owner?.fitting)
         refit(mix, owner);

package/dist/due.js

@@ -20,6 +20,9 @@ function dueOf(mix, voice) {
         due = Math.min(due, back.at + (1 - back.from) * back.over);
     if (voice.state === 'pending')
         return Math.min(due, Number.isNaN(voice.start) ? due : voice.start);
+    // A ramp through 0 turns the clock around, which is looked for each frame until it has.
+    if (voice.turns)
+        return Number.NEGATIVE_INFINITY;
     if (voice.state === 'fading') {
         const out = voice.out;
         if (out === null || out.rest)
@@ -27,20 +30,24 @@ function dueOf(mix, voice) {
         return Math.min(due, out.at + out.over);
     }
     due = Math.min(due, voice.outAt);
-    if (Number.isFinite(voice.span)) {
-        const end = voice.span + voice.latest;
-        // 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 === 'frozen') {
-            if (voice.rate <= 0 || voice.ramp !== null)
-                return Number.NEGATIVE_INFINITY;
-            if (!Number.isNaN(mix.now) && voice.elapsedAt(mix.now) < end)
-                return Number.NEGATIVE_INFINITY;
-        }
-        if (voice.state === 'live')
-            due = Math.min(due, voice.timeAt(end));
+    if (voice.state === 'frozen') {
+        const at = Number.isNaN(mix.now) ? Number.NaN : voice.elapsedAt(mix.now);
+        // Frozen at its start, having run back to it, it stays while its rate is never above 0,
+        // until a handle or a subject staggered ahead of every other moves it.
+        const r = voice.ramp;
+        const never = r === null ? voice.rate <= 0 : r.from <= 0 && r.to <= 0;
+        if (never && !voice.beginless && at <= voice.soonest)
+            return due;
+        // Frozen at its end, it goes live again once its clock is back before it: by a seek, by a
+        // subject staggered later than any before, or by running back, which is checked each frame
+        // while it can.
+        if (voice.rate <= 0 || r !== null)
+            return Number.NEGATIVE_INFINITY;
+        if (at < voice.span + voice.latest)
+            return Number.NEGATIVE_INFINITY;
     }
+    if (voice.state === 'live')
+        due = Math.min(due, voice.endsAt());
     return due;
 }
 /** Files a voice in the due queue at its current due, replacing any entry it had. */

package/dist/everyone.js

@@ -32,6 +32,7 @@ export function shares(mix, voice) {
         voice.holding === null &&
         voice.blend === null &&
         !voice.freezesBefore &&
+        !voice.beginless &&
         voice.slots.every((s) => {
             const channel = mix.channels[s];
             return channel.rest !== undefined && numericOf(channel)?.op !== 'last';
@@ -113,6 +114,8 @@ export function open(voice, rec, slot) {
         return;
     const stamps = voice.stamps;
     const o = slot * 2 /* Stamp.SIZE */;
+    // A subject never read counts its `dt` from the voice's origin, not another subject's last call.
+    rec.stepped = rec.since;
     if (stamps === null || o >= stamps.length) {
         rec.probed = Number.NaN;
         rec.seeks = 0;

package/dist/fade.d.ts

@@ -21,6 +21,7 @@ export declare function beginFade<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, op
     over?: number;
     at?: 'rest';
     deadline?: number;
+    back?: boolean;
 }, at?: number): void;
 /**
  * Turns a fading voice around: it climbs back from where its fade out had got to, up the same

package/dist/fade.js

@@ -104,7 +104,8 @@ export function beginFade(mix, voice, opts, at) {
         return;
     const over = mix.reduced ? 0 : (opts.over ?? voice.fade.out ?? 0);
     // A voice is linked into its subjects' chains once it plays, and a fading one plays.
-    if (voice.state === 'pending')
+    const waiting = voice.state === 'pending';
+    if (waiting)
         changed(mix, voice);
     // A fade at rest marks each subject's record as it comes to rest, at its next read: one already
     // read this frame is read again, as after `touch`.
@@ -120,8 +121,11 @@ export function beginFade(mix, voice, opts, at) {
         rest: opts.at === 'rest',
         deadline: opts.deadline,
     };
+    if (opts.back)
+        voice.out.back = true;
     noted(mix, voice);
-    if (opts.at === 'rest')
+    // A fade at rest, from a voice's start, or of a voice yet to start takes it off its lane.
+    if (opts.at === 'rest' || opts.back || waiting)
         mix.lanes?.invalidate();
     else
         mix.lanes?.refill();
@@ -190,7 +194,9 @@ export function retire(mix, voice, at) {
     // The record its setting last wrote to, which a retired voice no longer calls for.
     voice.keepOn = null;
     mix.retired.push(voice);
-    voice.doneAt = at ?? (Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now);
+    const now = Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now;
+    voice.doneAt = at ?? now;
+    voice.decidedAt = now;
     voice.doneSeq = mix.transport.seq;
     // The frames up to this one showed it, though its fade ended before: it leaves the list now.
     mix.transport.settle();
@@ -209,6 +215,6 @@ export function retire(mix, voice, at) {
         // A child the fit skipped had no time in it, so the rest of the fit stands: fitting again
         // between siblings skipped together would play the ones still to leave.
         else if (span.fitting !== null && span.state !== 'done' && !voice.skipped)
-            refit(mix, span);
+            refit(mix, span, voice.doneAt);
     }
 }

package/dist/fill.js

@@ -3,6 +3,7 @@ import { passAt, phaseAt, same, silent, weighed } from './clock.js';
 import { flush } from './columns.js';
 import { crowdsUpTo, freshen } from './crowd.js';
 import { open as openRecord, shut as shutRecord } from './everyone.js';
+import { unband } from './fold.js';
 import { foldLocus, gatherLocus } from './gather.js';
 import { runKeys } from './keyfill.js';
 import { frozenAt } from './lane.js';
@@ -301,6 +302,7 @@ export function one(lane, p, slot) {
     const elapsed = frozenAt(voice, elapsedNow - delay);
     if (!(elapsed >= 0)) {
         data[o + 2 /* Row.WEIGHT */] = 0;
+        unband(lane.records[p]);
         return false;
     }
     if (!lane.placed || !same(elapsed, lane.placedAt)) {
@@ -322,6 +324,7 @@ export function one(lane, p, slot) {
         arg[5 /* Arg.FADE */] = lane.fade;
         if (!this.signalled(voice, slot, lane.records[p])) {
             data[o + 2 /* Row.WEIGHT */] = 0;
+            unband(lane.records[p]);
             return false;
         }
         w = arg[0 /* Arg.WEIGHT */];
@@ -329,6 +332,8 @@ export function one(lane, p, slot) {
     else
         w = weighed(voice.weight, lane.fade, this.parting(voice, slot));
     data[o + 2 /* Row.WEIGHT */] = w;
+    if (!(w > 0))
+        unband(lane.records[p]);
     this.folding = lane;
     this.rec = lane.records[p] ?? null;
     if (voice.built !== null) {

package/dist/fold.js

@@ -1,4 +1,4 @@
-import { frozenTime, passAt, phaseAt, silent } from './clock.js';
+import { passAt, phaseAt, phaseBefore, silent } from './clock.js';
 import { copy as copyValue, first } from './clone.js';
 import { open as openRecord, shut as shutRecord, weighAt } from './everyone.js';
 import { recordHost, remember } from './history.js';
@@ -69,16 +69,15 @@ export function contribution(voice, subject, now, held) {
         return null;
     if (held.rebuilt !== voice.rebuilds)
         rebuild(this, voice, subject, now, held);
-    const raw = voice.elapsedAt(now) - held.delay;
-    // Not `raw < 0`: see `frozenTime` for the clock that reads NaN before its start.
-    const early = !(raw >= 0);
-    if (early && !voice.freezesBefore)
+    const raw = voice.rawAt(now, held.delay);
+    const early = voice.before(raw, now);
+    if (early && !voice.holdsFirst)
         return null;
-    const elapsed = frozenTime(raw, voice.freezesBefore, voice.freezesAfter, voice.span);
+    const elapsed = voice.shownAt(raw);
     // A frozen subject's clock stands still at the edge it freezes at: -1 before, 1 after, 0 playing.
     const still = early ? -1 : voice.freezesAfter && raw > voice.span ? 1 : 0;
     const duration = voice.duration;
-    const phase = phaseAt(elapsed, duration, voice.passes);
+    const phase = elapsed < 0 ? phaseBefore(elapsed, duration) : phaseAt(elapsed, duration, voice.passes);
     const pass = passAt(elapsed, duration, voice.passes);
     this.prime(voice, held, now, elapsed, pass);
     const setting = voice.setting;
@@ -102,20 +101,27 @@ export function contribution(voice, subject, now, held) {
         recordHost(this, now);
     reading.horizon = this.horizonFor(voice, held.delay, now);
     const tick = this.opts.stepMs;
-    if (voice.patch.step && held.probed !== now && still >= 0) {
-        // 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 (held.stepped < held.since) {
-            held.stepped = held.since;
-            setting.dt = this.capped(now - held.since);
-        }
-        if (tick !== undefined && tick > 0 && !this.reducedNow)
-            this.tick(voice, subject, held, tick, to);
-        else if (still === 0 ? now !== held.stepped : to > held.stepped) {
-            if (still === 1)
-                setting.dt = this.capped(to - held.stepped);
-            voice.patch.step(held.state, setting.dt, subject, setting);
-            held.stepped = to;
+    if (voice.patch.step && held.probed !== now) {
+        // Frozen after, it steps once more to where its last pass ended, and no further; run back
+        // past its start, to where it reached it. Before a start it has yet to reach, it does not step.
+        const to = still === 0
+            ? now
+            : still === 1
+                ? voice.timeAt(held.delay + voice.span)
+                : voice.ranBackTo(held.delay, now);
+        if (!Number.isNaN(to)) {
+            if (held.stepped < held.since) {
+                held.stepped = held.since;
+                setting.dt = this.capped(now - held.since);
+            }
+            if (tick !== undefined && tick > 0 && !this.reducedNow)
+                this.tick(voice, subject, held, tick, to);
+            else if (still === 0 ? now !== held.stepped : to > held.stepped) {
+                if (still !== 0)
+                    setting.dt = this.capped(to - held.stepped);
+                voice.patch.step(held.state, setting.dt, subject, setting);
+                held.stepped = to;
+            }
         }
     }
     let delta = null;
@@ -648,7 +654,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 = frozenTime(voice.elapsedAt(now) - held.delay, voice.freezesBefore, voice.freezesAfter, voice.span);
+            const elapsed = voice.shownAt(voice.rawAt(now, held.delay));
             setting.timestamp = now;
             setting.dt = 0;
             setting.elapsed = elapsed;

package/dist/gone.d.ts

@@ -13,7 +13,7 @@ export declare class GoneIndex<I, O> {
     count: number;
     general: Voice<I, O>[];
     named: Store<I, Voice<I, O>[]>;
-    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    /** The latest `reachedTo` in `of`, and how far any voice's falls before one listed ahead of it. */
     latest: number;
     slack: number;
 }
@@ -25,8 +25,8 @@ export declare function goneIndex<I, O>(mix: Mixer<I, O>): GoneIndex<I, O>;
  */
 export declare function keepGone<I, O>(mix: Mixer<I, O>, keep: (v: Voice<I, O>) => boolean): void;
 /**
- * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
- * finish, so only the front can hold one: past the point where a voice finished `slack` after
- * `reach`, none behind it finished before `reach`.
+ * Lets go of the gone voices no seek or read back to `reach` finds playing: those that finished
+ * before it, in a frame before it. Voices go in about that order, so only the front can hold one:
+ * past the point where a voice is reached `slack` after `reach`, none behind it falls before.
  */
 export declare function expireGone<I, O>(mix: Mixer<I, O>, reach: number): void;