@msb235/blits 0.8.0 → 0.9.0

package/dist/gone.js

@@ -12,15 +12,16 @@ export class GoneIndex {
     count = 0;
     general = [];
     named = new Store();
-    /** 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.NEGATIVE_INFINITY;
     slack = 0;
 }
 function add(ix, voice) {
-    if (voice.doneAt < ix.latest)
-        ix.slack = Math.max(ix.slack, ix.latest - voice.doneAt);
+    const to = voice.reachedTo;
+    if (to < ix.latest)
+        ix.slack = Math.max(ix.slack, ix.latest - to);
     else
-        ix.latest = voice.doneAt;
+        ix.latest = to;
     if (voice.named === null) {
         ix.general.push(voice);
         return;
@@ -107,14 +108,14 @@ export function keepGone(mix, keep) {
     ix.count = kept.length;
 }
 /**
- * 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 function expireGone(mix, reach) {
     const ix = goneIndex(mix);
     if (!Number.isFinite(ix.slack)) {
-        keepGone(mix, (v) => v.doneAt >= reach);
+        keepGone(mix, (v) => v.reachedTo >= reach);
         return;
     }
     const list = mix.gone;
@@ -122,7 +123,7 @@ export function expireGone(mix, reach) {
     let end = 0;
     let any = false;
     for (let seen = Number.NEGATIVE_INFINITY; end < list.length && seen < edge; end++) {
-        const done = list[end].doneAt;
+        const done = list[end].reachedTo;
         if (done < reach)
             any = true;
         if (done > seen)
@@ -134,7 +135,7 @@ export function expireGone(mix, reach) {
     const out = [];
     for (let i = 0; i < end; i++) {
         const v = list[i];
-        (v.doneAt < reach ? out : kept).push(v);
+        (v.reachedTo < reach ? out : kept).push(v);
     }
     list.splice(0, end, ...kept);
     remove(ix, out);

package/dist/handle.js

@@ -85,12 +85,17 @@ export class VoiceHandle {
         if (voice === null)
             return;
         voice.written = true;
-        const now = this.#host.nowFor(voice);
-        // A pending voice's clock reads 0 at its start, and a rate taken from now would cross 0 sooner:
-        // a subject it freezes before would play, and step, ahead of a voice that has not started.
-        const u = voice.state === 'pending' && voice.start > now && r > 0 ? voice.start : now;
-        leave(voice, u);
-        retime(voice, u, r, over);
+        if (voice.state === 'pending') {
+            // Its clock is anchored at its start, wherever that comes, and its rate is taken from there.
+            const from = voice.ramp === null ? voice.rate : voice.ramp.from;
+            voice.ramp = over > 0 && r !== from ? { from, to: r, over } : null;
+            voice.rate = r;
+        }
+        else {
+            const now = this.#host.nowFor(voice);
+            leave(voice, now);
+            retime(voice, now, r, over);
+        }
         this.#host.changed(voice);
         this.#host.record('rate', () => this.ramp(r, over));
     }
@@ -99,9 +104,12 @@ export class VoiceHandle {
         if (voice === null)
             return 'exact';
         voice.written = true;
-        const u = this.#host.nowFor(voice);
-        leave(voice, u);
-        voice.rebase(u);
+        // A pending voice's clock is anchored at its start, so it starts there on time.
+        if (voice.state !== 'pending') {
+            const u = this.#host.nowFor(voice);
+            leave(voice, u);
+            voice.rebase(u);
+        }
         voice.anchorElapsed = elapsed;
         voice.seeks++;
         const doubt = this.#host.sought(voice, opts?.state !== 'keep');

package/dist/held.d.ts

@@ -9,7 +9,17 @@ export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subjec
  * counts from its last seek that rebuilt state, as its records do.
  */
 export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, delay: number): number;
+/**
+ * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
+ * where a voice sought ahead of its start has a subject's delay run out before it; and from when
+ * the voice first showed, for one freezing before.
+ */
 export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
+/**
+ * A pending voice starts at `now`. Starting anywhere but 0 it was sought there, so a record made
+ * while it waited is made again for where its clock is.
+ */
+export declare function begin<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, now: number): void;
 /**
  * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still
  * ahead count from where its clock now puts them.

package/dist/held.js

@@ -1,6 +1,8 @@
+import { changed } from './chain.js';
 import { schedule } from './due.js';
 import { everyoneOf, inherit, sighted } from './everyone.js';
 import { originOf } from './origin.js';
+import { startOf } from './place.js';
 import { record } from './record.js';
 import { unreach, unreached } from './unreached.js';
 /** The record a voice gives every subject it does not reach. */
@@ -82,6 +84,11 @@ export function held(voice, subject, slot) {
         if (voice.state === 'frozen')
             schedule(this, voice);
     }
+    if (delay < voice.soonest) {
+        voice.soonest = delay;
+        // An earlier start moves where a voice running back ends.
+        schedule(this, voice);
+    }
     return held;
 }
 /**
@@ -92,8 +99,28 @@ export function sinceOf(voice, delay) {
     const p = voice.patch;
     return originOf(voice, delay, p.state !== undefined || p.step !== undefined || voice.keeping);
 }
+/**
+ * The mix time a subject's fade in counts from: `since`, but no earlier than its voice starts,
+ * where a voice sought ahead of its start has a subject's delay run out before it; and from when
+ * the voice first showed, for one freezing before.
+ */
 export function shownOf(voice, since) {
-    return voice.freezesBefore && voice.opened < since ? voice.opened : since;
+    const start = startOf(voice);
+    const from = since < start ? start : since;
+    return voice.freezesBefore && voice.opened < from ? voice.opened : from;
+}
+/**
+ * A pending voice starts at `now`. Starting anywhere but 0 it was sought there, so a record made
+ * while it waited is made again for where its clock is.
+ */
+export function begin(mix, voice, now) {
+    voice.state = 'live';
+    if (voice.anchorElapsed !== 0) {
+        voice.seeks++;
+        voice.rebuilds++;
+    }
+    reorigin(mix, voice, now);
+    changed(mix, voice);
 }
 /**
  * A voice's start or clock moved, or it went live at `now`: the records whose `since` was still

package/dist/hosts.js

@@ -111,7 +111,11 @@ export function fits(mix, voice) {
     const patch = voice.patch;
     if (voice.keeping)
         return false;
-    if (voice.state === 'pending' && voice.freezesBefore)
+    // Waiting to start, a voice shows the frame it will start on, which no fill reads its clock for.
+    if ((voice.freezesBefore || voice.state === 'fading') && voice.unstarted(mix.now))
+        return false;
+    // A fill takes a time before 0 as before a subject's start, which no time is for this voice.
+    if (voice.beginless || voice.out?.back === true)
         return false;
     // A fill weighs a voice's owners once for every subject, which a signal on one would not be.
     if (voice.owner !== null && signalled(voice))

package/dist/keyfill.js

@@ -1,5 +1,6 @@
 import { foldNumber } from './channels.js';
 import { clampWeight, frozenTime, phaseAt, same, weighed } from './clock.js';
+import { unband } from './fold.js';
 import { shortWay } from './turns.js';
 /**
  * A keys voice's fill outside a locus, its weight a number: what `one` does for each subject, in
@@ -44,6 +45,7 @@ export function runKeys(lanes, lane) {
         const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
+            unband(records[p]);
             continue;
         }
         if (!flat) {
@@ -63,8 +65,10 @@ export function runKeys(lanes, lane) {
             lanes.gather(lane, lane.delta);
             flatten(chans, read, nums, kinds);
         }
-        if (!(w > 0))
+        if (!(w > 0)) {
+            unband(records[p]);
             continue;
+        }
         let k = 0;
         for (let i = 0; i < n; i++) {
             const ch = chans[i];

package/dist/locus.d.ts

@@ -21,6 +21,8 @@ export interface LocusScratch<I, O> {
     mGroups: number[];
     values: unknown[];
     taken: Float64Array;
+    /** Per slot of a stock `last` channel, the weight of the member its value came from. */
+    heaviest: Float64Array;
     met: Uint8Array;
     touched: number[];
     owned: (number[] | undefined)[];
@@ -34,7 +36,8 @@ export declare function own<I, O>(k: LocusScratch<I, O>, slot: number, value: nu
 /**
  * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
- * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
+ * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
 export declare function foldLocus<I, O>(this: Mixer<I, O>, k: LocusScratch<I, O>, group: number): number;

package/dist/locus.js

@@ -1,4 +1,4 @@
-import { copy } from './clone.js';
+import { first } from './clone.js';
 export function locusScratch(channels) {
     return {
         n: 0,
@@ -15,6 +15,7 @@ export function locusScratch(channels) {
         mGroups: [],
         values: new Array(channels).fill(undefined),
         taken: new Float64Array(channels),
+        heaviest: new Float64Array(channels),
         met: new Uint8Array(channels),
         touched: [],
         owned: new Array(channels).fill(undefined),
@@ -37,7 +38,8 @@ export function own(k, slot, value, rest) {
 /**
  * Folds one locus's members into one contribution through each channel's own `lerp`: its value per
  * channel goes in `k.values`, the channels in `k.touched` in the order first met, and its weight
- * is returned. A channel folding by scale takes its value in an array of `k`'s own, lerped in
+ * is returned. A stock `last` channel has nothing to lerp, so it takes its heaviest member's value,
+ * the later cued of two as heavy. A channel folding by scale takes its value in an array of `k`'s own, lerped in
  * place, since the fold only reads it.
  */
 export function foldLocus(k, group) {
@@ -67,20 +69,28 @@ export function foldLocus(k, group) {
                 k.met[slot] = 1;
                 k.touched.push(slot);
                 taken[slot] = weight;
+                k.heaviest[slot] = weight;
                 k.values[slot] =
                     this.lerpsInto[slot] !== undefined && channel.scale && Array.isArray(value)
                         ? own(k, slot, value, channel.rest)
-                        : copy(value);
+                        : first(value);
                 continue;
             }
             const total = taken[slot] + weight;
+            taken[slot] = total;
+            if (channel.kind === 'last') {
+                if (weight >= k.heaviest[slot]) {
+                    k.heaviest[slot] = weight;
+                    k.values[slot] = first(value);
+                }
+                continue;
+            }
             const was = k.values[slot];
             const lerp = this.lerpsInto[slot];
             k.values[slot] =
                 lerp !== undefined && was === k.owned[slot]
                     ? lerp(was, was, value, weight / total)
                     : channel.lerp(was, value, weight / total);
-            taken[slot] = total;
         }
     }
     for (let t = 0; t < k.touched.length; t++)

package/dist/marks.js

@@ -99,8 +99,8 @@ export function markOf(mix, voice, mark) {
         if (Number.isFinite(t))
             outAt = Math.max(start, t);
     }
-    else if (!voice.freezesAfter && Number.isFinite(voice.span)) {
-        const t = voice.timeAt(voice.span + voice.latest);
+    else if (!(voice.backs ? voice.freezesBefore : voice.freezesAfter)) {
+        const t = voice.endsAt();
         if (Number.isFinite(t))
             outAt = Math.max(start, t);
     }
@@ -138,8 +138,8 @@ function coastOf(mix, voice, start) {
             t = Math.max(t, c);
         }
     }
-    else if (Number.isFinite(voice.span))
-        t = voice.timeAt(voice.span + voice.latest);
+    else
+        t = voice.endsAt();
     if (t === undefined || !Number.isFinite(t))
         return undefined;
     t = Math.max(start, t);

package/dist/motion.d.ts

@@ -40,7 +40,8 @@ export type Moving<I, O, V extends Value> = Patch<I, O, void> & {
     /**
      * Sets `subject` moving at `velocity`, units per second, from voice time `at`, default the mix's
      * latest frame; for a subject no frame of its voice has met yet, or still inside its stagger, its
-     * first read, after any change with a time due by then.
+     * first read, after any change with a time due by then. A subject faded out of the voice comes
+     * back at the latest frame too, however long it is before it is next read.
      */
     push(subject: I, velocity: V, at?: number): void;
 };
@@ -76,7 +77,8 @@ export declare function spring<I, O, V extends Value = number>(writes: keyof O,
     /**
      * Heads `subject` for `target` from voice time `at`, keeping its velocity: by default the mix's
      * latest frame, or for a subject no frame of its voice has met yet, or still inside its stagger,
-     * its first read, after any change with a time due by then.
+     * its first read, after any change with a time due by then. A subject faded out of the voice
+     * comes back at the latest frame too, however long it is before it is next read.
      */
     to(subject: I, target: V, at?: number): void;
 };
@@ -115,7 +117,8 @@ export declare function tween<I, O, V extends Value = number>(writes: keyof O, o
     /**
      * Heads `subject` for `target` from voice time `at`, over a full `ms` from where it is: by default
      * the mix's latest frame, or for a subject no frame of its voice has met yet, or still inside its
-     * stagger, its first read, after any change with a time due by then.
+     * stagger, its first read, after any change with a time due by then. A subject faded out of the
+     * voice comes back at the latest frame too, however long it is before it is next read.
      */
     to(subject: I, target: V, at?: number): void;
 };

package/dist/motions.d.ts

@@ -33,8 +33,11 @@ export interface Change {
 export interface MotionOwner {
     /** The subject's voice time at the mix's latest frame; NaN where no frame of the voice met it. */
     frame(id: number, subject: unknown): number;
-    /** Brings a subject the voice faded out back to it, so a change is not made for nothing. */
-    revive(id: number, subject: unknown): void;
+    /**
+     * Brings a subject the voice faded out back to it, so a change is not made for nothing: its
+     * voice time now, which a change bringing it back is made at; NaN for any other subject.
+     */
+    revive(id: number, subject: unknown): number;
     /** The mix clock at its latest frame; NaN before the first. */
     now(): number;
     /** The number of the frame the mix is playing. */

package/dist/motions.js

@@ -454,7 +454,7 @@ export class Motions {
      * The queue keeps the changes with a time in time order, ahead of any still waiting for one.
      */
     change(subject, c) {
-        this.owner?.revive(this.ownerId, subject);
+        const back = this.owner === null ? Number.NaN : this.owner.revive(this.ownerId, subject);
         const s = this.slot(subject);
         this.check(c.to, this.n);
         this.check(c.v, this.n);
@@ -464,6 +464,8 @@ export class Motions {
             const at = this.frame(subject);
             if (!Number.isNaN(at))
                 c.at = at;
+            else if (!Number.isNaN(back))
+                c.at = back;
         }
         const list = this.pending?.[s];
         if (list === undefined) {

package/dist/move.js

@@ -1,9 +1,12 @@
 import { changed } from './chain.js';
+import { elapsedWith } from './clock.js';
 import { popDue, schedule } from './due.js';
 import { detour } from './everyone.js';
 import { beginFade, part, retire } from './fade.js';
 import { expireGone, keepGone } from './gone.js';
-import { reorigin } from './held.js';
+import { begin } from './held.js';
+import { noted } from './history.js';
+import { leave as leaveClock } from './origin.js';
 import { ownerReading } from './owner.js';
 import { mixAt, place, repin, startOf } from './place.js';
 import { pageVoice } from './revive.js';
@@ -60,28 +63,37 @@ function moveTo(mix, now) {
         if (Number.isNaN(voice.opened))
             voice.opened = now;
         if (voice.state === 'pending' &&
-            (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start) {
-            voice.state = 'live';
-            reorigin(mix, voice, now);
-            changed(mix, voice);
-        }
+            (voice.owner === null ? now : ownerReading(voice.owner, now)) >= voice.start)
+            begin(mix, voice, now);
         // After it starts, so a fade due by now on a voice that started since the last frame begins.
         if ((voice.state === 'live' || voice.state === 'frozen') && voice.outAt <= now)
             beginFade(mix, voice, { over: Number.isNaN(voice.outOver) ? undefined : voice.outOver }, Math.max(startOf(voice), voice.outAt));
-        if (voice.state !== 'pending' && Number.isFinite(voice.span)) {
-            const end = voice.span + voice.latest;
-            if (voice.elapsedAt(now) >= end) {
+        if (voice.state !== 'pending') {
+            if (voice.turns)
+                turn(mix, voice, now);
+            // Its passes run out at its end running forward, and at its start running back. A clock
+            // standing still at or before its start is where it was: waiting, or frozen there.
+            const way = heading(voice, now);
+            const at = voice.elapsedAt(now);
+            const back = way < 0;
+            const atStart = !voice.beginless && at <= voice.soonest;
+            // An owner run back to its start stays for what it holds, and leaves with its last child.
+            const holds = voice.holding !== null && voice.holding.children.length > 0;
+            const over = back
+                ? atStart && !holds
+                : Number.isFinite(voice.span) && at >= voice.span + voice.latest;
+            if (over) {
                 voice.play(true, now, mix.transport.seq);
-                // The fade starts when the last pass ended, not at the frame that noticed, so it plays
+                // The fade starts when its passes ran out, not at the frame that noticed, so it plays
                 // the same at any frame rate and a read at another time can find it.
                 if (voice.state === 'live') {
-                    if (voice.freezesAfter)
+                    if (back ? voice.freezesBefore : voice.freezesAfter)
                         voice.state = 'frozen';
                     else
-                        beginFade(mix, voice, {}, Math.max(startOf(voice), Math.min(now, voice.timeAt(end))));
+                        beginFade(mix, voice, { back }, Math.max(startOf(voice), Math.min(now, voice.endsAt())));
                 }
             }
-            else if (voice.state === 'frozen')
+            else if (voice.state === 'frozen' && !(atStart && way === 0))
                 voice.state = 'live';
         }
         // A projection reads a finished ramp as weight 0, and leaves the live voice's subjects be.
@@ -118,6 +130,31 @@ function moveTo(mix, now) {
         prune(mix);
     forget(mix);
 }
+/**
+ * Which way a voice's clock is running at mix time `now`, through every owner above it: above 0
+ * forward, below 0 back, 0 standing still.
+ */
+function heading(voice, now) {
+    let way = 1;
+    for (let v = voice; v !== null; v = v.owner)
+        way *= Math.sign(v.rateAt(v.owner === null ? now : ownerReading(v.owner, now)));
+    return way;
+}
+/**
+ * A ramp through 0 has turned a voice's clock around by `now`: the clock is anchored again where
+ * it turned, so it runs one way from there and the time it reads any position is one time.
+ */
+function turn(mix, voice, now) {
+    const r = voice.ramp;
+    const at = voice.anchorNow + (r.over * r.from) / (r.from - r.to);
+    if ((voice.owner === null ? now : ownerReading(voice.owner, now)) < at)
+        return;
+    leaveClock(voice, at);
+    voice.anchorElapsed = elapsedWith(voice, at);
+    voice.ramp = { from: 0, to: r.to, over: voice.anchorNow + r.over - at };
+    voice.anchorNow = at;
+    noted(mix, voice);
+}
 /** Past this many voices retiring in one frame, one pass over the list beats a search for each. */
 const SEARCHED = 8;
 /**
@@ -208,7 +245,7 @@ export function forget(mix) {
         // With a store a voice that has left pages out where it can, and stays where it cannot.
         if (mix.transport.pager !== null) {
             const reach = mix.now - history.ms;
-            keepGone(mix, (v) => v.doneAt >= reach || !pageVoice(mix, v, reach));
+            keepGone(mix, (v) => v.reachedTo >= reach || !pageVoice(mix, v, reach));
         }
         else {
             expireGone(mix, mix.transport.keepsFrom());

package/dist/origin.js

@@ -48,8 +48,9 @@ function fresh(voice) {
  */
 export function originOf(voice, elapsed, rebuilt) {
     const past = voice.clocks;
-    let t = Number.NaN;
-    if (past !== null) {
+    // A voice with no first pass shows every subject from its start, whatever its stagger.
+    let t = voice.beginless ? voice.start : Number.NaN;
+    if (past !== null && Number.isNaN(t)) {
         for (let i = rebuilt ? fresh(voice) : 0; i < past.length; i++) {
             const p = past[i];
             const at = timeWith(p, elapsed);

package/dist/owner.d.ts

@@ -19,6 +19,8 @@ export declare function ownerReading<I, O>(owner: Voice<I, O>, now: number): num
 export declare function ownedElapsed<I, O>(voice: Voice<I, O>, owner: Voice<I, O>, now: number): number;
 /** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
 export declare function mixTime<I, O>(owner: Voice<I, O>, t: number): number;
+/** Whether an odd number of the owners above a voice run back, which turns its clock around. */
+export declare function turnedBack<I, O>(voice: Voice<I, O>): boolean;
 /** Takes a child into its owner. */
 export declare function adopt<I, O>(owner: Voice<I, O>, child: Voice<I, O>): void;
 /** A child left: its owner, where that was its last child and it should leave too. */

package/dist/owner.js

@@ -1,4 +1,4 @@
-import { clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
+import { backWith, clampWeight, elapsedWith, envelope, timeWith } from './clock.js';
 /** What an owner is cued with in place of a patch: it writes nothing, so no fold ever meets it. */
 export const ownerPatch = Object.freeze({
     form: 'fn',
@@ -29,9 +29,17 @@ export function ownedElapsed(voice, owner, now) {
 }
 /** The mix time an owner's clock reads `t`, by its controls now; Infinity where it never will. */
 export function mixTime(owner, t) {
-    const up = timeWith(owner, t);
+    const up = owner.backs ? backWith(owner, t) : timeWith(owner, t);
     return owner.owner === null ? up : mixTime(owner.owner, up);
 }
+/** Whether an odd number of the owners above a voice run back, which turns its clock around. */
+export function turnedBack(voice) {
+    let back = false;
+    for (let o = voice.owner; o !== null; o = o.owner)
+        if (o.backs)
+            back = !back;
+    return back;
+}
 /** Takes a child into its owner. */
 export function adopt(owner, child) {
     const h = owner.holding;

package/dist/paging.js

@@ -110,12 +110,7 @@ export function pageTransport(transport) {
         return;
     const reach = transport.now - history.ms;
     const records = [];
-    const frames = transport.frames;
-    let n = 0;
-    while (n + 1 < frames.length && frames[n + 1].at <= reach)
-        n++;
-    for (const f of frames.splice(0, n))
-        records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u });
+    transport.frames.shed(reach, (f) => records.push({ mix: '', stream: 'frame', at: f.at, seq: f.seq, data: f.u }));
     const pace = transport.pace;
     const timeOf = (u) => (pace === null ? u : pace.reading(u));
     if (transport.announced.some((a) => timeOf(a.at) < reach)) {

package/dist/place.js

@@ -1,3 +1,4 @@
+import { same } from './clock.js';
 import { departedMatches } from './departed.js';
 import { reorigin } from './held.js';
 import { noted } from './history.js';
@@ -5,6 +6,7 @@ import { markOf } from './marks.js';
 import { mixTime, ownerReading } from './owner.js';
 import { holders, scored, scoredGone, scoreVersion, unhold } from './scored.js';
 import { none } from './voice.js';
+import { warnOnce } from './warn.js';
 /** What a voice's own owner's clock reads now: the mix clock for a voice no owner holds. */
 export function localNow(mix, voice) {
     return voice.owner === null ? mix.now : ownerReading(voice.owner, mix.now);
@@ -38,7 +40,6 @@ function startAt(mix, voice, start) {
         return false;
     voice.start = start;
     voice.anchorNow = start;
-    voice.anchorElapsed = 0;
     voice.clocks = null;
     // A clock moved outright, as a seek moves it: what a record computed at this mix time is stale.
     voice.seeks++;
@@ -121,9 +122,22 @@ export function place(mix) {
                 const t = by === undefined ? undefined : resolve(mix, by, voice);
                 if (t !== undefined) {
                     const m = voice.owner === null ? t : mixTime(voice.owner, t);
-                    const at = anchor.out !== undefined ? m : m - (voice.fade.out ?? 0);
-                    if (at !== voice.outAt) {
+                    const start = startOf(voice);
+                    let at = anchor.out !== undefined ? m : m - (voice.fade.out ?? 0);
+                    let over = Number.NaN;
+                    // A fade out begins no earlier than its voice starts, and one that has to end by `m`
+                    // is shortened to; an end before the start leaves the voice an instant at its start.
+                    if (at < start && Number.isFinite(start)) {
+                        at = start;
+                        if (anchor.end !== undefined) {
+                            over = m > start ? m - start : 0;
+                            if (m < start && !mix.projecting)
+                                warnOnce(voice, `${voice.spec.name ?? `voice ${voice.id}`}'s placement ends before it starts, so it plays as an instant`);
+                        }
+                    }
+                    if (at !== voice.outAt || !same(over, voice.outOver)) {
                         voice.outAt = at;
+                        voice.outOver = over;
                         noted(mix, voice);
                         moved = true;
                     }

package/dist/project.d.ts

@@ -15,4 +15,4 @@ export declare function mirror<I, O>(mix: Mixer<I, O>, c: Mixer<I, O>): void;
  * A projection back starts each subject from the latest copy kept at or before `t`, else from its
  * voice's start with fresh state, which is exact for a voice stepped at a fixed interval.
  */
-export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut): Subject<unknown> | undefined;
+export declare function recall<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, t: number, cut: Cut, c?: Mixer<I, O>, copy?: Voice<I, O>): Subject<unknown> | undefined;