@msb235/blits 0.14.0 → 0.15.0

package/dist/patch.d.ts

@@ -15,12 +15,14 @@ export interface PatchOptions<I, O, S, H = unknown> {
     reads?: readonly string[];
     state?(subject: I): S;
     step?(state: S, dt: number, subject: I, setting: Setting<S, H>): void;
-    /** `state` as plain data and back, for a history store: see `Patch.pack`. */
+    /** `state` as plain data and back, for a history store. See `Patch.pack`. */
     pack?(state: S): unknown;
     unpack?(data: unknown): S;
 }
 /**
- * The procedural form. Flicker, roving, a hash walk, a starter strike.
+ * A patch whose function computes its output from phase, subject and setting each frame.
+ *
+ * The procedural form, for flicker, roving, a hash walk, a starter strike.
  *
  * @category patch
  */
@@ -137,7 +139,9 @@ export declare function builtOf<I, O, S>(p: Patch<I, O, S>): Built;
 /** Evaluates a stop list into a fresh delta. */
 export declare function evalKeys<O>(stops: readonly Keyframe<O>[], writes: readonly (keyof O)[], phase: number, duration: number, opts: KeysOptions<O>, base?: Partial<O>): Partial<O>;
 /**
- * The declarative form. klieg's transition sugar and wod's keyframes.
+ * A patch that interpolates between keyframes over its duration.
+ *
+ * The declarative form, as klieg's transition sugar and wod's keyframes use.
  *
  * @category patch
  */

package/dist/patch.js

@@ -1,7 +1,9 @@
 import { lerpInto, lerpNumber } from './channels.js';
 import { curve, startSlope } from './easing.js';
 /**
- * The procedural form. Flicker, roving, a hash walk, a starter strike.
+ * A patch whose function computes its output from phase, subject and setting each frame.
+ *
+ * The procedural form, for flicker, roving, a hash walk, a starter strike.
  *
  * @category patch
  */
@@ -326,7 +328,9 @@ export function evalKeys(stops, writes, phase, duration, opts, base) {
     return readKeys(build(stops, writes, duration, opts), phase, {}, base);
 }
 /**
- * The declarative form. klieg's transition sugar and wod's keyframes.
+ * A patch that interpolates between keyframes over its duration.
+ *
+ * The declarative form, as klieg's transition sugar and wod's keyframes use.
  *
  * @category patch
  */

package/dist/places.d.ts

@@ -0,0 +1,53 @@
+import { Grid } from './grid.js';
+import { Store } from './store.js';
+/**
+ * The index the host gives each subject, by `place` or by its place in the list `plot` was given,
+ * and where the host says each one is, over `Grid`. Subjects are held as the rest of the mix holds
+ * them: an object weakly, anything else until `drop`. An index a subject leaves, by `drop` or by
+ * being collected, is handed out again.
+ */
+export declare class Places<I> extends Grid {
+    private readonly slotOf;
+    private readonly keepRefs;
+    /** By subject, its index. */
+    at: Store<I, number>;
+    /** By index, its subject's lane number, -1 for one with none or a subject let go. */
+    slots: Int32Array<ArrayBuffer>;
+    /** By lane number, the index it was put in `slots` at, -1 for none. */
+    placeOf: Int32Array<ArrayBuffer>;
+    /** Outside production, by index, its subject, for the check that a bound does not clip a signal. */
+    refs: (WeakRef<object> | I | undefined)[] | null;
+    /** While a bounded fill reads the subject at an index, that index, so `around` need not look it up; else -1. */
+    cur: number;
+    /** Indices a subject left, for `place` to hand out again. */
+    free: number[];
+    /** Whether `xy` is the mix's own, grown as `place` hands out indices, rather than the array `plot` was given. */
+    owned: boolean;
+    /**
+     * By index, the token its object subject is registered under: a reused index never hears of an
+     * old subject's collection.
+     */
+    private tokens;
+    private registry;
+    constructor(slotOf: (subject: I) => number, keepRefs: boolean);
+    /** Takes the host's subjects and positions; `xy` is read in place, so a move needs only `moved`. */
+    set(list: readonly I[], xy: Float64Array, cell: number): void;
+    /** `subject`'s index: the one it has, or a new one, a freed index first. */
+    place(subject: I): number;
+    private hold;
+    /** Room for indices below `n`; the mix's own positions start as no position, NaN. */
+    private room;
+    /** The lanes numbered `subject`: its place, if it has one, reads the number from now on. */
+    number(subject: I, slot: number): void;
+    private numbered;
+    /** The lanes let lane number `slot` go. */
+    forgot(slot: number): void;
+    /** The host dropped `subject`: its index is freed. */
+    drop(subject: I): void;
+    /** Frees index `i`, its subject dropped or collected. */
+    private release;
+    /** The subject at index `i`, where it is still held; only outside production. */
+    subjectAt(i: number): I | undefined;
+    /** Whether `subject` is within `r` of (`cx`, `cy`), by the same test `query` makes. */
+    inside(subject: I, cx: number, cy: number, r2: number): boolean;
+}

package/dist/places.js

@@ -0,0 +1,171 @@
+import { Grid } from './grid.js';
+import { Store } from './store.js';
+/**
+ * The index the host gives each subject, by `place` or by its place in the list `plot` was given,
+ * and where the host says each one is, over `Grid`. Subjects are held as the rest of the mix holds
+ * them: an object weakly, anything else until `drop`. An index a subject leaves, by `drop` or by
+ * being collected, is handed out again.
+ */
+export class Places extends Grid {
+    slotOf;
+    keepRefs;
+    /** By subject, its index. */
+    at = new Store();
+    /** By index, its subject's lane number, -1 for one with none or a subject let go. */
+    slots = new Int32Array(0);
+    /** By lane number, the index it was put in `slots` at, -1 for none. */
+    placeOf = new Int32Array(0);
+    /** Outside production, by index, its subject, for the check that a bound does not clip a signal. */
+    refs = null;
+    /** While a bounded fill reads the subject at an index, that index, so `around` need not look it up; else -1. */
+    cur = -1;
+    /** Indices a subject left, for `place` to hand out again. */
+    free = [];
+    /** Whether `xy` is the mix's own, grown as `place` hands out indices, rather than the array `plot` was given. */
+    owned = true;
+    /**
+     * By index, the token its object subject is registered under: a reused index never hears of an
+     * old subject's collection.
+     */
+    tokens = [];
+    registry = null;
+    constructor(slotOf, keepRefs) {
+        super();
+        this.slotOf = slotOf;
+        this.keepRefs = keepRefs;
+        this.refs = keepRefs ? [] : null;
+    }
+    /** Takes the host's subjects and positions; `xy` is read in place, so a move needs only `moved`. */
+    set(list, xy, cell) {
+        const n = list.length;
+        this.at = new Store();
+        for (let i = 0; i < n; i++)
+            this.at.set(list[i], i);
+        this.slots = new Int32Array(Math.max(n, 16)).fill(-1);
+        this.placeOf.fill(-1);
+        this.refs = this.keepRefs ? [] : null;
+        this.tokens = [];
+        this.free = [];
+        for (let i = 0; i < n; i++) {
+            const subject = list[i];
+            // A subject listed twice is at its last index.
+            if (this.at.get(subject) !== i)
+                continue;
+            this.hold(subject, i);
+        }
+        this.n = n;
+        this.xy = xy;
+        this.owned = false;
+        this.cell = cell;
+        this.dirty = true;
+    }
+    /** `subject`'s index: the one it has, or a new one, a freed index first. */
+    place(subject) {
+        const had = this.at.get(subject);
+        if (had !== undefined)
+            return had;
+        const i = this.free.pop() ?? this.n++;
+        this.room(i + 1);
+        this.at.set(subject, i);
+        this.hold(subject, i);
+        if (this.owned)
+            this.put(i, Number.NaN, Number.NaN);
+        return i;
+    }
+    hold(subject, i) {
+        const slot = this.slotOf(subject);
+        if (slot >= 0)
+            this.numbered(slot, i);
+        const object = typeof subject === 'object' && subject !== null;
+        if (this.refs !== null)
+            this.refs[i] = object ? new WeakRef(subject) : subject;
+        if (!object)
+            return;
+        const token = { i };
+        this.tokens[i] = token;
+        this.registry ??= new FinalizationRegistry((t) => {
+            if (this.tokens[t.i] === t)
+                this.release(t.i);
+        });
+        this.registry.register(subject, token, token);
+    }
+    /** Room for indices below `n`; the mix's own positions start as no position, NaN. */
+    room(n) {
+        if (this.slots.length < n) {
+            const slots = new Int32Array(Math.max(n, this.slots.length * 2)).fill(-1);
+            slots.set(this.slots);
+            this.slots = slots;
+        }
+        if (this.owned && this.xy.length < 2 * n) {
+            const xy = new Float64Array(Math.max(2 * n, this.xy.length * 2, 32)).fill(Number.NaN);
+            xy.set(this.xy);
+            this.xy = xy;
+        }
+    }
+    /** The lanes numbered `subject`: its place, if it has one, reads the number from now on. */
+    number(subject, slot) {
+        const i = this.at.get(subject);
+        if (i !== undefined)
+            this.numbered(slot, i);
+    }
+    numbered(slot, i) {
+        if (slot >= this.placeOf.length) {
+            const grown = new Int32Array(Math.max(slot + 1, this.placeOf.length * 2, 64)).fill(-1);
+            grown.set(this.placeOf);
+            this.placeOf = grown;
+        }
+        this.placeOf[slot] = i;
+        this.slots[i] = slot;
+    }
+    /** The lanes let lane number `slot` go. */
+    forgot(slot) {
+        if (slot >= this.placeOf.length)
+            return;
+        const i = this.placeOf[slot];
+        if (i < 0)
+            return;
+        this.placeOf[slot] = -1;
+        if (this.slots[i] === slot)
+            this.slots[i] = -1;
+    }
+    /** The host dropped `subject`: its index is freed. */
+    drop(subject) {
+        const i = this.at.get(subject);
+        if (i === undefined)
+            return;
+        this.at.delete(subject);
+        const token = this.tokens[i];
+        if (token !== undefined)
+            this.registry?.unregister(token);
+        this.release(i);
+    }
+    /** Frees index `i`, its subject dropped or collected. */
+    release(i) {
+        this.tokens[i] = undefined;
+        if (this.refs !== null)
+            this.refs[i] = undefined;
+        const slot = this.slots[i];
+        if (slot >= 0)
+            this.placeOf[slot] = -1;
+        this.slots[i] = -1;
+        // The host's own array is the host's: a reused index reads whatever it holds there.
+        if (this.owned)
+            this.put(i, Number.NaN, Number.NaN);
+        this.free.push(i);
+    }
+    /** The subject at index `i`, where it is still held; only outside production. */
+    subjectAt(i) {
+        const ref = this.refs?.[i];
+        const s = ref instanceof WeakRef ? ref.deref() : ref;
+        return s !== undefined && this.at.get(s) === i ? s : undefined;
+    }
+    /** Whether `subject` is within `r` of (`cx`, `cy`), by the same test `query` makes. */
+    inside(subject, cx, cy, r2) {
+        const i = this.at.get(subject);
+        if (i === undefined || 2 * i + 1 >= this.xy.length)
+            return false;
+        const dx = this.xy[2 * i] - cx;
+        const dy = this.xy[2 * i + 1] - cy;
+        return dx * dx + dy * dy <= r2;
+    }
+}

package/dist/plot.d.ts

@@ -0,0 +1,12 @@
+import type { Mixer } from './mixer.js';
+/** `Mix.plot`: the mix's subjects and their positions, `x` then `y` side by side in `xy`, read in place. */
+export declare function plot<I, O>(this: Mixer<I, O>, subjects: readonly I[], xy: Float64Array, cell?: number): void;
+/** `Mix.place`: the subject's index, its own or a new one, which a `within` finder names it by. */
+export declare function place<I, O>(this: Mixer<I, O>, subject: I): number;
+/** `Mix.moved`: the host wrote new positions into the `xy` it gave `plot`. */
+export declare function moved<I, O>(this: Mixer<I, O>): void;
+/**
+ * `Mix.put`: moves one subject, writing into the `xy` `plot` gave or the mix's own. The grid is built
+ * again only once a sixteenth of the indices have left their cells.
+ */
+export declare function put<I, O>(this: Mixer<I, O>, subject: I, x: number, y: number): void;

package/dist/plot.js

@@ -0,0 +1,52 @@
+import { bind } from './bound.js';
+import { Places } from './places.js';
+import { production } from './warn.js';
+/** `Mix.plot`: the mix's subjects and their positions, `x` then `y` side by side in `xy`, read in place. */
+export function plot(subjects, xy, cell) {
+    if (xy.length < 2 * subjects.length)
+        throw new RangeError(`blits: plot takes two numbers a subject, x then y: ${subjects.length} subjects need ${2 * subjects.length}, not ${xy.length}`);
+    if (cell !== undefined && !(cell > 0 && cell < Number.POSITIVE_INFINITY))
+        throw new RangeError(`blits: plot's cell is a size above 0, not ${cell}`);
+    placesOf(this).set(subjects, xy, cell ?? Number.NaN);
+    this.moved();
+}
+/** `Mix.place`: the subject's index, its own or a new one, which a `within` finder names it by. */
+export function place(subject) {
+    return placesOf(this).place(subject);
+}
+/**
+ * The mix's indices, made at the first `place` or `plot`. An `around` voice cued before then read 0
+ * everywhere, so it takes its circle with nothing to undo.
+ */
+function placesOf(mix) {
+    if (mix.places !== null)
+        return mix.places;
+    const places = new Places((s) => mix.chains.get(s)?.slot ?? -1, !production());
+    mix.places = places;
+    for (const voice of mix.cued)
+        if (voice.bound === null)
+            bind(mix, voice);
+    return places;
+}
+/** `Mix.moved`: the host wrote new positions into the `xy` it gave `plot`. */
+export function moved() {
+    if (this.places !== null)
+        this.places.dirty = true;
+    this.lanes?.refill();
+    this.stir();
+}
+/**
+ * `Mix.put`: moves one subject, writing into the `xy` `plot` gave or the mix's own. The grid is built
+ * again only once a sixteenth of the indices have left their cells.
+ */
+export function put(subject, x, y) {
+    const places = this.places;
+    const i = places === null ? undefined : places.at.get(subject);
+    if (places === null || i === undefined)
+        throw new Error('blits: put takes a subject with an index: place or plot it first');
+    if (2 * i + 1 >= places.xy.length)
+        throw new RangeError(`blits: put's subject is at index ${i}, past the positions plot was given: plot again with room for it`);
+    places.put(i, x, y);
+    this.lanes?.refill();
+    this.stir();
+}

package/dist/project.d.ts

@@ -1,7 +1,9 @@
+import { type Cut } from './cut.js';
 import { Mixer } from './mixer.js';
-import { type Cut, Transport } from './transport.js';
+import type { Subject } from './subject.js';
+import { Transport } from './transport.js';
 import type { TransportProjection } from './types.js';
-import type { Subject, Voice } from './voice.js';
+import type { Voice } from './voice.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
  * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
@@ -12,8 +14,6 @@ export declare function projectAll(transport: Transport, at: number | {
 }): TransportProjection;
 /** Sets each copied voice's state to what its clock and fade make it at `t`. */
 export declare function stateAt<I, O>(c: Mixer<I, O>, t: number): void;
-/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
-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.

package/dist/project.js

@@ -1,23 +1,20 @@
+import { copyAhead, mirror, playAhead, recordOf } from './ahead.js';
 import { ownBlends } from './blend.js';
-import { headOf, heldAt } from './chain.js';
+import { heldAt } from './chain.js';
 import { stepOf } from './clock.js';
-import { open, sighted, weightAt } from './everyone.js';
+import { within } from './cut.js';
 import { fadesAt } from './fade.js';
 import { meet, origin } from './held.js';
 import { copyHeld, last, lastWithin } from './history.js';
-import { markOf, voiceMarks } from './marks.js';
 import { Mixer } from './mixer.js';
-import { move } from './move.js';
 import { heldByInput, ownerReading, relink } from './owner.js';
-import { pin, place } from './place.js';
 import { reading } from './reading.js';
 import { record } from './record.js';
 import { recount } from './roster.js';
 import { copyStanding, stands } from './standing.js';
-import { hostAhead, hostAt, replay } from './tape.js';
-import { Transport, within } from './transport.js';
+import { hostAhead, hostAt } from './tape.js';
+import { Transport } from './transport.js';
 import { cover, coverFrame } from './unpage.js';
-import { unreached } from './unreached.js';
 /**
  * Every mix on a transport read at mix time `t`, through copies of them on a transport of their
  * own, moved together so an anchor across mixes answers as it would live. Ahead, they stop at each
@@ -75,6 +72,7 @@ export function projectAll(transport, at) {
         }, null);
         copy.slot = mix.slot;
         copy.projecting = true;
+        copy.places = mix.places;
         copies.set(mix, copy);
         if (ahead)
             copyAhead(mix, copy);
@@ -91,15 +89,18 @@ export function projectAll(transport, at) {
         earlier = new Map();
         stood = playAhead(transport, c, copies, t, earlier);
     }
+    const back = !ahead && kept ? cut : null;
     const read = (f) => {
         reading.live = false;
         reading.ahead = stood.ahead.size > 0 ? stood.ahead : null;
+        reading.back = back;
         try {
             return f();
         }
         finally {
             reading.live = true;
             reading.ahead = null;
+            reading.back = null;
         }
     };
     return {
@@ -136,168 +137,6 @@ export function projectAll(transport, at) {
         },
     };
 }
-/**
- * Moves a read ahead's copies to mix time `t`, making the calls the tape holds on the way as a seek
- * there makes them on the mixes. While a voice could carry state across it, it stops at each known
- * event: a call, and every mark of a voice or announced. At each stop the copies are kept for
- * subjects to be read there and copied on, so `copies` ends holding those at `t`. Answers the
- * transport they stand on, and puts the tape back where it stood.
- */
-function playAhead(transport, c, copies, t, earlier) {
-    const tape = transport.tape;
-    const depth = tape?.undoDepth() ?? 0;
-    let played = false;
-    try {
-        for (;;) {
-            const e = nextEvent(tape, c, t);
-            if (!(e < t))
-                break;
-            played = playTo(transport, c, copies, e) || played;
-            if (!carries(c))
-                continue;
-            // Placed now, as the next move would place them, while a target that has just left is here.
-            for (const m of c.members)
-                if (m.anchored > 0)
-                    place(m);
-            const next = restage(c);
-            for (const [mix, copy] of copies) {
-                const on = new Mixer(copy.kit, { ...copy.opts, transport: next }, null);
-                on.slot = copy.slot;
-                on.projecting = true;
-                copyAhead(copy, on);
-                const stages = earlier.get(mix);
-                if (stages === undefined)
-                    earlier.set(mix, { at: [copy], met: new Set() });
-                else
-                    stages.at.push(copy);
-                copies.set(mix, on);
-            }
-            c = next;
-        }
-        played = playTo(transport, c, copies, t) || played;
-    }
-    finally {
-        if (played)
-            tape?.goto(depth);
-    }
-    return c;
-}
-/**
- * Whether a voice on a read ahead's copies could carry state from one known event to the next: a
- * patch that steps, or a weight given by a signal, which may keep state. Where none could, a read
- * crosses the events in one go, as fast as one with none.
- */
-function carries(c) {
-    for (const m of c.members)
-        for (const v of m.cued)
-            if (v.state !== 'done' && (v.patch.step !== undefined || typeof v.spec.weight === 'function'))
-                return true;
-    return false;
-}
-/**
- * The earliest known event a read ahead's copies have yet to reach before `t`, mix time: the next
- * call the tape holds, and while a voice could carry state across one, a mark of a voice or one
- * announced. Infinity where there is none.
- */
-function nextEvent(tape, c, t) {
-    const now = c.now;
-    let e = Number.POSITIVE_INFINITY;
-    const call = tape?.timestampAt(tape.undoDepth());
-    if (call !== undefined)
-        e = c.pace === null ? call : c.pace.reading(call);
-    if (!carries(c))
-        return e < t ? e : Number.POSITIVE_INFINITY;
-    for (const m of c.members)
-        for (const v of m.cued) {
-            if (v.state === 'done')
-                continue;
-            for (const mark of voiceMarks) {
-                const at = markOf(m, v, mark);
-                if (at !== undefined && at > now && at < e)
-                    e = at;
-            }
-            const inner = v.spec.marks;
-            if (inner !== undefined)
-                for (const mark of Object.keys(inner)) {
-                    const at = markOf(m, v, mark);
-                    if (at !== undefined && at > now && at < e)
-                        e = at;
-                }
-        }
-    for (const a of c.announced) {
-        const at = c.pace === null ? a.at : c.pace.at(a.at, c.u);
-        if (at > now && at < e)
-            e = at;
-    }
-    return e < t ? e : Number.POSITIVE_INFINITY;
-}
-/**
- * Makes the calls the tape holds up to mix time `to` on a read ahead's copies and moves them
- * there. Answers whether it moved the tape.
- */
-function playTo(transport, c, copies, to) {
-    const tape = transport.tape;
-    const due = (at) => (c.pace === null ? at : c.pace.reading(at)) <= to;
-    const next = tape?.timestampAt(tape.undoDepth());
-    c.u = hostAhead(c, to);
-    let played = false;
-    if (next !== undefined && due(next)) {
-        // A call may write what a copy shares with the voice it was copied from.
-        for (const copy of c.members)
-            for (const v of copy.cued) {
-                if (v.parts !== null)
-                    v.parts = new Map(v.parts);
-                if (v.parted !== null)
-                    v.parted = new Map(v.parted);
-            }
-        played = true;
-        const last = replay(transport, due, c, {
-            transport: () => c,
-            mix: (of) => copies.get(of),
-        });
-        c.u = Math.max(last, hostAhead(c, to));
-    }
-    // A call played at `to` itself moved the copies there before it, as a sync does.
-    if (!(c.now >= to))
-        for (const copy of c.members)
-            move(copy, to);
-    return played;
-}
-/** A transport for a read ahead's copies to go on from where those on `c` stand. */
-function restage(c) {
-    const next = new Transport(undefined, true);
-    next.offset = c.offset;
-    next.u = c.u;
-    next.nextId = c.nextId;
-    next.now = c.now;
-    next.pace = c.pace === null ? null : c.pace.until(Number.POSITIVE_INFINITY);
-    next.announced = c.announced.map((a) => ({ ...a }));
-    // The retargets and pushes the tape made carry their times, so every stop shares one list.
-    next.ahead = c.ahead;
-    return next;
-}
-/**
- * A mix's copy for a read ahead: its voices as they stand, each subject carried from the live one,
- * or from the copy at the known event before.
- */
-function copyAhead(mix, c) {
-    mirror(mix, c);
-    c.cued = mix.cued
-        .filter((v) => v.state !== 'done')
-        .map((v) => {
-        const copy = v.copy((subject) => carry(mix, v, subject, c, copy), undefined, true);
-        const at = mix.pins?.get(v);
-        if (at !== undefined)
-            pin(c, copy, at);
-        return copy;
-    });
-    c.waking = mix.waking;
-    ownBlends(c.cued);
-    // A copy keeps no list of owners, so the one before says only by its voices.
-    if (mix.owners !== null || (mix.projecting && c.cued.some((v) => v.holding !== null)))
-        relink(c.cued);
-    recount(c);
-}
 /** A mix's copy for a read back to `t`, cut at `cut`: its voices then, from the controls and copies kept. */
 function copyBack(mix, c, t, cut) {
     mirror(mix, c);
@@ -352,48 +191,6 @@ export function stateAt(c, t) {
                     ? 'frozen'
                     : 'live';
 }
-/** Gives a projection's copy what it reads of the live mix as it is, before its voices are copied. */
-export function mirror(mix, c) {
-    c.pose = mix.pose;
-    c.wantsPose = mix.wantsPose;
-    c.reducedNow = mix.reducedNow;
-}
-/** A voice's record of a subject, the one it shares among those it does not reach included. */
-function recordOf(mix, voice, subject) {
-    // A voice sharing one record has that for every subject a chain has asked it about, pointed at
-    // the subject for the caller to copy from.
-    if (voice.sharing) {
-        const slot = headOf(mix, subject)?.slot ?? -1;
-        if (!sighted(voice, slot))
-            return undefined;
-        const all = voice.everyone;
-        open(voice, all, slot);
-        all.weight = weightAt(voice, slot);
-        return all;
-    }
-    const held = voice.subjects.get(subject);
-    if (held !== undefined || voice.unreachedBits === null)
-        return held;
-    return unreached(voice, headOf(mix, subject)?.slot ?? -1)
-        ? voice.unreached
-        : undefined;
-}
-/**
- * A projection ahead starts each subject from where the live mix holds it, its `since` worked out
- * again where it was still ahead, since the copy's clock may have moved it.
- */
-function carry(mix, voice, subject, c, copy) {
-    const live = recordOf(mix, voice, subject);
-    if (live === undefined)
-        return undefined;
-    const h = copyHeld(voice, live);
-    if (h.reaches && !(h.since <= mix.now)) {
-        h.since = c.sinceOf(copy, h.delay);
-        h.shown = c.shownOf(copy, h.since);
-    }
-    h.from = h.stepped;
-    return h;
-}
 /**
  * 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.

package/dist/pull.js

@@ -18,12 +18,10 @@ function writeValue(c, v, n) {
 }
 /** After a probe, keeps the pose a retarget from `'current'` reads as the subject's last. */
 export function keep(subject, pose, out) {
-    // Keeping last frame's pose is free when the mix allocated it; a host sampling into its own
-    // object only pays for the copy once something in the mix has asked to retarget from it.
+    // A pose handed back without `out` is the host's to edit, so it is copied too. A host sampling
+    // into its own object only pays for the copy once something has asked to retarget from it.
     let kept;
-    if (out === undefined)
-        kept = pose;
-    else if (this.wantsPose) {
+    if (out === undefined || this.wantsPose) {
         kept = {};
         for (const key of this.names) {
             const v = pose[key];
@@ -32,9 +30,14 @@ export function keep(subject, pose, out) {
         }
     }
     if (kept !== undefined) {
-        const rec = this.pose.get(subject);
+        const rec = this.lastPoses.get(subject);
         if (rec === undefined)
-            this.pose.set(subject, { pose: kept, at: this.now, prev: undefined, prevAt: Number.NaN });
+            this.lastPoses.set(subject, {
+                pose: kept,
+                at: this.now,
+                prev: undefined,
+                prevAt: Number.NaN,
+            });
         else if (rec.at === this.now)
             rec.pose = kept;
         else {
@@ -50,7 +53,7 @@ export function pull(mix, subjects, into) {
     const lanes = mix.lanes;
     const now = mix.now;
     if (mix.scratch === undefined)
-        mix.scratch = {};
+        mix.scratch = mix.pose();
     let room = Number.POSITIVE_INFINITY;
     let tightest = '';
     for (const c of columns) {