@msb235/blits 0.15.0 → 0.16.0

package/dist/rows.js

@@ -4,6 +4,7 @@ import { reach } from './meet.js';
 import { motionOf } from './motion.js';
 import { open } from './qualify.js';
 import { settle } from './sample.js';
+import { Seat, seatOf } from './seat.js';
 /** Whether two crowds' channels are the same list. */
 function same(a, b) {
     if (a.length !== b.length)
@@ -38,14 +39,13 @@ export function unplace(lanes, c, p) {
 export function sameCrowds(lanes, members) {
     let live = 0;
     for (const v of members) {
-        if (!lanes.crowdOf.has(v.id))
+        if (!lanes.seats.has(v.id))
             return false;
         live++;
     }
     let rows = 0;
-    for (const [id, c] of lanes.crowdOf) {
-        const p = c.rowOf.get(id);
-        if (c.voices[p].state !== 'done')
+    for (const s of lanes.seats.values()) {
+        if (s.crowd.voices[s.row].state !== 'done')
             rows++;
     }
     return rows === live;
@@ -64,13 +64,15 @@ export function regroup(lanes, members) {
                 leaveCrowd(lanes, c, p);
         }
     const old = lanes.crowds;
-    const was = new Map(lanes.crowdOf);
+    const was = new Map(lanes.seats);
+    for (const s of was.values())
+        s.lanes = null;
     lanes.crowds = [];
-    lanes.crowdOf.clear();
+    lanes.seats.clear();
     lanes.overlap = false;
     for (const v of members) {
         const from = was.get(v.id);
-        join(lanes, v, from, from?.rowOf.get(v.id), old);
+        join(lanes, v, from?.crowd, from?.row, old);
     }
     if (lanes.crowds.length === 0) {
         lanes.lawsByKey.clear();
@@ -104,8 +106,9 @@ export function join(lanes, v, from, at, old) {
         newRow(lanes, c, p, v);
     if (c.hot[p * c.stride + 6 /* Hot.EPOCH */] === 0 && v.state !== 'pending')
         c.hot[p * c.stride + 6 /* Hot.EPOCH */] = open(lanes, v);
-    c.rowOf.set(v.id, p);
-    lanes.crowdOf.set(v.id, c);
+    const seat = new Seat(lanes, c, p);
+    lanes.seats.set(v.id, seat);
+    v.seat = seat;
     v.laned = true;
 }
 /** A crowd row takes up its voice as it now stands: opened once it starts, its fields copied again. */
@@ -122,27 +125,28 @@ export function retouchRow(lanes, c, p, v) {
 export function compactSparse(lanes) {
     for (const c of lanes.crowds)
         if (c.dead > 64 && c.dead * 4 >= c.size)
-            compact(c);
+            compact(lanes, c);
 }
 /**
  * Slides a crowd's rows down over the empty ones its departed voices left, in order, so its rows
  * stay in voice order; a qualify did this by rebuilding every crowd, a dropped frame at 10k rows.
  */
-function compact(c) {
+function compact(lanes, c) {
     // The rows' stops are copied into a fresh pool, leaving the departed rows' behind.
     const keys = c.keys;
     c.keys = new KeyRows();
     let q = 0;
     for (let p = 0; p < c.size; p++) {
         const v = c.voices[p];
-        if (c.rowOf.get(v.id) !== p) {
+        const s = seatOf(lanes, v);
+        if (s === null || s.crowd !== c || s.row !== p) {
             c.odd?.delete(p);
             continue;
         }
         if (q !== p) {
             copyRow(c, p, c, q, keys);
             c.odd?.delete(p);
-            c.rowOf.set(v.id, q);
+            s.row = q;
         }
         else
             copyKeys(keys, c, q);
@@ -166,8 +170,12 @@ export function bury(lanes, c, p) {
     c.deltas[p] = null;
     c.motions[p] = undefined;
     c.hot[p * c.stride + 0 /* Hot.FLAGS */] = 0;
-    c.rowOf.delete(v.id);
-    lanes.crowdOf.delete(v.id);
+    lanes.seats.delete(v.id);
+    const s = v.seat;
+    if (s !== null && s.lanes === lanes) {
+        s.lanes = null;
+        v.seat = null;
+    }
     c.dead++;
 }
 /** Copies `n` numbers of a row; a view of them to hand `set` was three objects a row moved. */
@@ -202,7 +210,7 @@ function copyRow(from, p, to, q, keys = from.keys) {
 function copyKeys(keys, c, q) {
     const h = q * c.stride;
     if ((c.hot[h + 0 /* Hot.FLAGS */] & 512 /* Flag.FLAT */) !== 0)
-        c.hot[h + 8 /* Hot.AT */] = c.keys.copy(keys, c.hot[h + 8 /* Hot.AT */]);
+        c.hot[h + 9 /* Hot.AT */] = c.keys.copy(keys, c.hot[h + 9 /* Hot.AT */]);
 }
 function newRow(lanes, c, p, v) {
     const run = motionOf(v.patch);
@@ -210,9 +218,9 @@ function newRow(lanes, c, p, v) {
     c.hot.fill(0, h, h + c.stride);
     const at = v.built === null ? -1 : c.keys.add(v.built, c.chans);
     if (at >= 0) {
-        c.hot[h + 8 /* Hot.AT */] = at;
-        c.hot[h + 10 /* Hot.X0 */] = v.duration;
-        c.hot[h + 9 /* Hot.MS */] = v.passes;
+        c.hot[h + 9 /* Hot.AT */] = at;
+        c.hot[h + 11 /* Hot.X0 */] = v.duration;
+        c.hot[h + 10 /* Hot.MS */] = v.passes;
     }
     c.restale(p, 64 /* Flag.VOICE */ |
         (run === undefined ? 0 : 128 /* Flag.MOTION */) |

package/dist/sample.js

@@ -43,7 +43,8 @@ export function runMotion(lanes, lane, run) {
     }
     const samples = lane.samples;
     const xs = run.xs;
-    const ease = run.ease;
+    // A tween round the hue is no straight line between its ends: `sampleBare` reads it round the hue.
+    const ease = run.round ? undefined : run.ease;
     // A tween whose stretches tell the lane before they change keeps no sample: see `unbareLane`.
     if (run.watcher === null) {
         run.watcher = lanes;

package/dist/seat.d.ts

@@ -0,0 +1,17 @@
+import type { Crowd } from './crowd.js';
+import type { Voice } from './voice.js';
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export declare class Seat<I, O> {
+    lanes: object | null;
+    readonly crowd: Crowd<I, O>;
+    row: number;
+    constructor(lanes: object | null, crowd: Crowd<I, O>, row: number);
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export declare function seatOf<I, O>(lanes: object, voice: Voice<I, O>): Seat<I, O> | null;
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export declare function seated<I, O>(lanes: object, voice: Voice<I, O>, c: Crowd<I, O>, p: number): boolean;

package/dist/seat.js

@@ -0,0 +1,25 @@
+/**
+ * A crowd voice's row, held on the voice and by its id in its lanes' `seats`: one place to read
+ * both its crowd and its row, where two maps by id were two cache misses a stop at 40,000 voices.
+ * `lanes` is the lanes it was given in, null once they let it go.
+ */
+export class Seat {
+    lanes;
+    crowd;
+    row;
+    constructor(lanes, crowd, row) {
+        this.lanes = lanes;
+        this.crowd = crowd;
+        this.row = row;
+    }
+}
+/** `voice`'s seat in `lanes`, null where it has none there. */
+export function seatOf(lanes, voice) {
+    const s = voice.seat;
+    return s !== null && s.lanes === lanes ? s : null;
+}
+/** Whether row `p` of `c` is `voice`'s seat in `lanes`, not a row it has left. */
+export function seated(lanes, voice, c, p) {
+    const s = seatOf(lanes, voice);
+    return s !== null && s.crowd === c && s.row === p;
+}

package/dist/seek.js

@@ -6,7 +6,6 @@ import { apart, copyHeld, copyHeldInto, lastIndex, lastWithin, unread } from './
 import { laneHost } from './hosts.js';
 import { Leavings } from './leavings.js';
 import { move, nextFrame } from './move.js';
-import { ownerReading } from './owner.js';
 import { place } from './place.js';
 import { unpull } from './pull.js';
 import { isRested } from './record.js';
@@ -209,17 +208,6 @@ function restoreVoice(mix, voice, t, seq) {
     }
     records.back(t, cut, future);
 }
-/** Each voice's state at mix time `t`, once every clock above it is back where it was. */
-function stateAt(voice, t) {
-    // A fade begins at once, even one whose ramp starts later, at the voice's start.
-    if (voice.out !== null)
-        return 'fading';
-    if ((voice.owner === null ? t : ownerReading(voice.owner, t)) < voice.start)
-        return 'pending';
-    if (voice.freezesAfter && voice.elapsedAt(t) >= voice.span + voice.latest)
-        return 'frozen';
-    return 'live';
-}
 /**
  * Moves every mix on the transport to mix time `to`, as it stood at the end of that frame, or to
  * the end of the frame numbered `to.frame`.
@@ -334,7 +322,7 @@ function back(mix, t, seq, on) {
     for (const voice of kept)
         restoreVoice(mix, voice, t, seq);
     for (const voice of kept)
-        voice.state = stateAt(voice, t);
+        voice.state = voice.stateAt(t);
     mix.cued = kept;
     mix.gone = gone;
     mix.retired = [];

package/dist/shared.d.ts

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export declare const release = "0.15.0";
+export declare const release = "0.16.0";
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/shared.js

@@ -2,7 +2,7 @@
  * The package version, for a fact whose shape follows the code too closely to version by hand:
  * copies of different releases keep apart. `test/copies.test.ts` holds it to `package.json`.
  */
-export const release = '0.15.0';
+export const release = '0.16.0';
 /**
  * A WeakMap every copy of blits loaded in one realm shares, so a fact one copy records about a
  * patch or channel it made is read by another copy's mix. The name carries a version, bumped when

package/dist/spans.d.ts

@@ -29,7 +29,10 @@ export declare function refit<I, O>(mix: Mixer<I, O>, span: Voice<I, O>, from?:
 export declare function refloor<I, O>(mix: Mixer<I, O>): void;
 /** Whether a span whose last child just left at mix time `at` stays, its budget not yet out. */
 export declare function lingers<I, O>(span: Voice<I, O>, at: number): boolean;
-/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+/**
+ * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
+ * ran out.
+ */
 export declare function lapse<I, O>(mix: Mixer<I, O>, now: number): void;
 /** Fits every span again, as after a seek put its children back. */
 export declare function refitAll<I, O>(mix: Mixer<I, O>): void;

package/dist/spans.js

@@ -6,7 +6,7 @@ import { reorigin } from './held.js';
 import { noted } from './history.js';
 import { nextFrame } from './move.js';
 import { leave } from './origin.js';
-import { ownerReading } from './owner.js';
+import { ownerReading, plays } from './owner.js';
 import { resolve } from './place.js';
 /** What a span keeps beside its owner: its claim, its fit, and how the last fit came out. */
 export class Fitting {
@@ -222,13 +222,16 @@ export function lingers(span, at) {
     const f = span.fitting;
     return f !== null && Number.isFinite(f.budget) && ownerReading(span, at) < f.budget;
 }
-/** Lets the spans that are empty and out of budget leave, at the moment their budget ran out. */
+/**
+ * Lets the spans out of budget that hold no child still playing leave, at the moment their budget
+ * ran out.
+ */
 export function lapse(mix, now) {
     for (const span of mix.owners ?? []) {
         const f = span.fitting;
         if (f === null || span.state === 'done' || !Number.isFinite(f.budget))
             continue;
-        if ((span.holding?.children.length ?? 0) > 0)
+        if (plays(span, now))
             continue;
         if (ownerReading(span, now) >= f.budget)
             retire(mix, span, span.timeAt(f.budget));

package/dist/strays.js

@@ -1,3 +1,4 @@
+import { delayOf } from './delay.js';
 import { unpart } from './fade.js';
 import { pageOut } from './paging.js';
 import { record, taping, unplayable } from './tape.js';
@@ -75,7 +76,7 @@ export function motionOwner(mix) {
                 return Number.NaN;
             unpart(m, v, subject);
             // Its record is gone until it is next read, so its stagger is asked here as it will be there.
-            return timeIn(m, v, v.spec.stagger ? v.spec.stagger(subject) : 0);
+            return timeIn(m, v, delayOf(v, subject));
         },
     };
 }
@@ -107,7 +108,7 @@ function changeAhead(to, id, motion, given, change) {
             unpart(to, v, subject);
         if (at === undefined) {
             const frame = frameOf(to, v, subject);
-            const back = parted ? timeIn(to, v, v.spec.stagger ? v.spec.stagger(subject) : 0) : frame;
+            const back = parted ? timeIn(to, v, delayOf(v, subject)) : frame;
             if (!Number.isNaN(frame))
                 at = frame;
             else if (!Number.isNaN(back))

package/dist/touch.js

@@ -1,5 +1,4 @@
 import { headOf } from './chain.js';
-import { restamp } from './everyone.js';
 import { nextFrame } from './move.js';
 /**
  * What `Mix.touch` does: makes stale every delta read this frame, for one subject or for all, so
@@ -22,7 +21,7 @@ export function touch(mix, subject) {
             held.seeks = -1;
         const slot = headOf(mix, subject)?.slot ?? -1;
         for (const voice of mix.sharers)
-            restamp(voice, slot);
+            mix.share?.restamp(voice, slot);
     }
     mix.lanes?.refill();
     mix.stir();

package/dist/trace.d.ts

@@ -0,0 +1,4 @@
+import type { Mixer } from './mixer.js';
+import type { Trace, TraceOptions } from './types.js';
+/** `mix.trace`: see `Mix.trace`. */
+export declare function traceMix<I, O>(mix: Mixer<I, O>, from: number, to: number, opts?: TraceOptions): Trace<I, O>;

package/dist/trace.js

@@ -0,0 +1,255 @@
+import { straight } from './easing.js';
+/**
+ * How far inside a sampled stretch its ends are read, ms, but for the window's own: a stretch ends
+ * where a voice may jump, and its end is read on its own side of the jump.
+ */
+const NUDGE = 1e-6;
+/** Two values at one time this close are one point, not a jump. */
+const close = (a, b) => Math.abs(a - b) <= 1e-6 * Math.max(1, Math.abs(a), Math.abs(b));
+/** `mix.trace`: see `Mix.trace`. */
+export function traceMix(mix, from, to, opts = {}) {
+    if (!(from <= to) || !Number.isFinite(from) || !Number.isFinite(to))
+        throw new RangeError(`blits: a trace runs from a time to one no earlier, not ${from} to ${to}`);
+    const grid = opts.grid ?? 5;
+    if (!(grid > 0 && grid < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: a trace's grid is a finite number of ms above 0, not ${grid}`);
+    const known = knowable(mix, from);
+    const projections = new Map();
+    const poses = new Map();
+    const plans = new Map();
+    const poseAt = (subject, t) => {
+        let mine = poses.get(subject);
+        if (mine === undefined) {
+            mine = new Map();
+            poses.set(subject, mine);
+        }
+        let pose = mine.get(t);
+        if (pose === undefined) {
+            let p = projections.get(t);
+            if (p === undefined) {
+                p = mix.project(t);
+                projections.set(t, p);
+            }
+            pose = p.probe(subject, mix.pose());
+            mine.set(t, pose);
+        }
+        return pose;
+    };
+    return {
+        from,
+        to,
+        of(subject, channel) {
+            const name = channel;
+            const slot = mix.slotOf.get(name);
+            if (slot === undefined)
+                throw new Error(`blits: the mix has no channel ${name}`);
+            const value = (t) => {
+                const v = poseAt(subject, t)[name];
+                return typeof v === 'number' ? v : Number.NaN;
+            };
+            let plan = plans.get(subject);
+            if (plan === undefined) {
+                plan = planOf(mix, subject, from, to);
+                plans.set(subject, plan);
+            }
+            const op = mix.scalars[slot];
+            const shaped = known &&
+                !plan.unknown.has(slot) &&
+                !mix.bounded.includes(slot) &&
+                (op === 'sum' || (op === 'mul' && (plan.writers.get(slot) ?? 0) <= 1));
+            const bent = plan.bent.get(slot);
+            const straightOver = (a, b) => shaped && (bent === undefined || bent.every(([lo, hi]) => !(lo < b && hi > a)));
+            if (from === to)
+                return { at: [from], value: [value(from)], exact: shaped };
+            const at = [];
+            const values = [];
+            let exact = true;
+            const add = (t, v) => {
+                const n = at.length;
+                if (n > 0 && at[n - 1] === t && close(values[n - 1], v))
+                    values[n - 1] = v;
+                else {
+                    at.push(t);
+                    values.push(v);
+                }
+            };
+            const knots = [from, ...(plan.knots.get(slot) ?? []), to];
+            for (let i = 0; i + 1 < knots.length; i++) {
+                const a = knots[i];
+                const b = knots[i + 1];
+                if (straightOver(a, b)) {
+                    // Read inside, so a jump at either end is not read; the line reaches each end exactly.
+                    const t1 = a + (b - a) / 3;
+                    const t2 = b - (b - a) / 3;
+                    const v1 = value(t1);
+                    const slope = (value(t2) - v1) / (t2 - t1);
+                    add(a, v1 - slope * (t1 - a));
+                    add(b, v1 + slope * (b - t1));
+                    continue;
+                }
+                exact = false;
+                const e = Math.min(NUDGE, (b - a) / 4);
+                add(a, value(a === from ? a : a + e));
+                for (let k = Math.max(0, Math.ceil((a - from) / grid));; k++) {
+                    const g = from + k * grid;
+                    if (g >= b - e)
+                        break;
+                    if (g > a + e)
+                        add(g, value(g));
+                }
+                add(b, value(b === to ? b : b - e));
+            }
+            return { at, value: values, exact };
+        },
+    };
+}
+/**
+ * Whether the mix's own state lets a trace know any shape: a window at or after the mix's time,
+ * with no recorded call ahead.
+ */
+function knowable(mix, from) {
+    const transport = mix.transport;
+    if (!(from >= mix.now))
+        return false;
+    const tape = transport.tape;
+    return tape === undefined || tape.timestampAt(tape.undoDepth()) === undefined;
+}
+function planOf(mix, subject, from, to) {
+    const plan = { knots: new Map(), bent: new Map(), unknown: new Set(), writers: new Map() };
+    for (const voice of mix.cued) {
+        if (voice.state === 'done' || !mix.aims(voice, subject))
+            continue;
+        if (shapeOf(mix, voice, subject, from, to, plan))
+            continue;
+        for (const slot of voice.slots)
+            plan.unknown.add(slot);
+    }
+    for (const [slot, knots] of plan.knots)
+        plan.knots.set(slot, knots.sort((a, b) => a - b).filter((t, i, all) => i === 0 || t !== all[i - 1]));
+    return plan;
+}
+/** The most breakpoints one voice may add to a window before it is read on the grid instead. */
+const MOST = 4096;
+/**
+ * Adds a voice's breakpoints for one subject to `plan`, and returns true, where its shape is known
+ * through the window: a `keys` voice on its own clock at a steady rate and a number weight. Returns
+ * false, adding nothing, for any other.
+ */
+function shapeOf(mix, voice, subject, from, to, plan) {
+    const spec = voice.spec;
+    const built = voice.built;
+    const patch = voice.patch;
+    if (patch.form !== 'keys' || built === null || patch.step !== undefined)
+        return false;
+    if (typeof spec.weight === 'function' || voice.owner !== null || voice.holding !== null)
+        return false;
+    if (voice.fitting !== null || voice.arc !== null || voice.blend !== null)
+        return false;
+    if (spec.anchor !== undefined || spec.role !== undefined || spec.within !== undefined)
+        return false;
+    if (spec.stepMs !== undefined || spec.from !== undefined)
+        return false;
+    if (voice.ramp !== null || !(voice.rate > 0) || voice.out !== null || voice.back !== null)
+        return false;
+    if (voice.parts !== null || voice.parted !== null || voice.left !== null)
+        return false;
+    if (Number.isFinite(voice.outAt) || voice.state === 'fading')
+        return false;
+    // Under a mix rate, a waiting voice's start is pinned to the host's clock, where a ramp moves it.
+    if (voice.state === 'pending' && mix.transport.pace !== null)
+        return false;
+    const knots = [];
+    const bent = [];
+    const bentBy = new Map();
+    const at = (t) => {
+        if (t > from && t < to)
+            knots.push(t);
+    };
+    const reduced = mix.reduced;
+    const held = voice.sharing ? undefined : voice.subjects.get(subject);
+    const delay = held?.delay ?? (spec.stagger ? spec.stagger(subject) : 0);
+    const time = (raw) => voice.timeAt(raw + delay);
+    const fadeIn = reduced ? 0 : (voice.fade.in ?? 0);
+    if (fadeIn > 0) {
+        // Where its fade in counts from is known only once the subject has met the voice.
+        if (held === undefined)
+            return false;
+        if (held.shown + fadeIn > from) {
+            bent.push([held.shown, held.shown + fadeIn]);
+            at(held.shown);
+            at(held.shown + fadeIn);
+        }
+    }
+    const duration = voice.duration;
+    const span = voice.span;
+    at(voice.start);
+    at(time(0));
+    if (Number.isFinite(span))
+        at(time(span));
+    const ends = voice.endsAt();
+    at(ends);
+    if (!voice.freezesAfter && Number.isFinite(ends)) {
+        const over = reduced ? 0 : Number.isNaN(voice.outOver) ? (voice.fade.out ?? 0) : voice.outOver;
+        if (over > 0) {
+            bent.push([ends, ends + over]);
+            at(ends + over);
+        }
+        // It leaves when its latest subject ends, which a subject first met later can move.
+        if (spec.stagger !== undefined)
+            bent.push([time(span), Number.POSITIVE_INFINITY]);
+    }
+    if (duration > 0) {
+        const first = Math.max(0, Math.floor((voice.elapsedAt(from) - delay) / duration));
+        const last = Math.min(Math.ceil(voice.passes) - 1, Math.floor((voice.elapsedAt(to) - delay) / duration));
+        let stops = 0;
+        for (const track of built.tracks)
+            stops += track.all.length + 1;
+        if ((last - first + 1) * stops > MOST)
+            return false;
+        for (let pass = first; pass <= last; pass++) {
+            const base = pass * duration;
+            at(time(base));
+            at(time(base + duration));
+            for (const track of built.tracks) {
+                const slot = mix.slotOf.get(track.channel);
+                if (track.numbers === null)
+                    return false;
+                const wait = track.delay;
+                if (wait >= duration)
+                    continue;
+                if (wait > 0)
+                    at(time(base + wait));
+                let before = Number.NaN;
+                for (const pt of track.all) {
+                    const t = time(base + wait + Math.min(1, Math.max(0, pt.at)) * (duration - wait));
+                    at(t);
+                    if (!Number.isNaN(before) && !straight(pt.ease)) {
+                        const list = bentBy.get(slot);
+                        if (list === undefined)
+                            bentBy.set(slot, [[before, t]]);
+                        else
+                            list.push([before, t]);
+                    }
+                    before = t;
+                }
+            }
+        }
+    }
+    for (const slot of voice.slots) {
+        const times = plan.knots.get(slot);
+        if (times === undefined)
+            plan.knots.set(slot, [...knots]);
+        else
+            times.push(...knots);
+        plan.writers.set(slot, (plan.writers.get(slot) ?? 0) + 1);
+        const mine = [...bent, ...(bentBy.get(slot) ?? [])];
+        if (mine.length === 0)
+            continue;
+        const list = plan.bent.get(slot);
+        if (list === undefined)
+            plan.bent.set(slot, mine);
+        else
+            list.push(...mine);
+    }
+    return true;
+}

package/dist/turns.js

@@ -51,7 +51,8 @@ export function turnToward(ch, values, base, value, taken, u) {
     }
     const axes = ch.axes;
     let out = value;
-    if (taken !== 0) {
+    // A first value of other axes than the lane's, as an ink contribution is, widens through the lerp.
+    if (taken !== 0 || out.length !== axes) {
         held = lift(values, base, axes, held);
         out = ch.channel.lerp(held, value, u);
     }

package/dist/types/mix.d.ts

@@ -3,6 +3,7 @@ import type { Kit } from './channel.js';
 import type { HistoryOptions, Tape } from './history.js';
 import type { Band, Easing, Patch, Sent, Signal } from './patch.js';
 import type { Booker, BookOptions, Marked } from './place.js';
+import type { Trace, TraceOptions } from './trace.js';
 import type { Transport } from './transport.js';
 import type { BlendMember, Circle, Handle, OwnerSpec, SpanHandle, SpanSpec, VoiceSpec } from './voice.js';
 /**
@@ -250,6 +251,20 @@ export interface Mix<I, O, H = unknown> {
     project(at: number | {
         readonly frame: number;
     }): Projection<I, O>;
+    /**
+     * Reads the mix over a window of mix time, `from` to `to`, without moving it, as `project` reads
+     * one moment: `trace.of(subject, channel)` gives that channel as points joined by straight lines.
+     * Where every voice feeding the channel is a `keys` voice whose shape is known through the
+     * window, the points are its own breakpoints and the lines are exact; elsewhere the run is read
+     * every `grid` ms, as many `project` calls would read it.
+     *
+     * Exact needs, of each voice reaching the subject and writing the channel: a `keys` patch whose
+     * stops are plain numbers, eased `linear`; a number weight; no owner, anchor, role, blend,
+     * `within`, `stepMs`, `from: 'current'`, or rate ramp; a fade in finished by `from` and no fade
+     * out under way or due. The channel folds by `sum`, or by `mul` from one such voice, and has no
+     * `bounds`. The window lies at or after the mix's own time, and the tape holds no calls ahead.
+     */
+    trace(from: number, to: number, opts?: TraceOptions): Trace<I, O>;
     /**
      * Moves the mix to mix time `time` and plays on from there. It lands as the mix stood at the end
      * of that frame; where rate 0 held the clock at `time` for several frames, the last of them.

package/dist/types/trace.d.ts

@@ -0,0 +1,51 @@
+/**
+ * What `mix.trace` takes besides its window.
+ *
+ * @category mix
+ */
+export interface TraceOptions {
+    /**
+     * Where a run cannot be known exactly, how far apart it is read, in ms of mix time. Default 5.
+     */
+    grid?: number;
+}
+/**
+ * One channel of one subject over a trace's window, as points joined by straight lines: the value
+ * between two points is the straight line between them. Two points at one time are a jump, from
+ * the first value to the second. The first point is at the window's start and the last at its end.
+ *
+ * @category mix
+ */
+export interface Run {
+    /** Mix times, ascending; a time given twice is a jump. */
+    readonly at: readonly number[];
+    /** The channel's value at each of `at`; NaN where it holds no number. */
+    readonly value: readonly number[];
+    /**
+     * Whether the lines are the mix's own values everywhere in the window, not only at the points.
+     * Where they are not, the points are each `grid` apart and the lines between them approximate.
+     */
+    readonly exact: boolean;
+}
+/**
+ * The channels of `O` that hold one number.
+ *
+ * @category mix
+ */
+export type NumberChannel<O> = {
+    [K in keyof O]-?: NonNullable<O[K]> extends number ? K : never;
+}[keyof O];
+/**
+ * The mix read over a window of mix time, with nothing in the live mix moved. Valid until the mix
+ * is next synced or cued.
+ *
+ * @category mix
+ */
+export interface Trace<I, O> {
+    /** The window's start, in mix time. */
+    readonly from: number;
+    /** The window's end, in mix time. */
+    readonly to: number;
+    /** One subject's channel over the window. */
+    of(subject: I, channel: NumberChannel<O>): Run;
+}