@msb235/blits 0.10.0 → 0.12.0

package/dist/history.js

@@ -9,14 +9,18 @@ import { within } from './transport.js';
 import { none } from './voice.js';
 /** The last entry taken before `t`, or at it where `inclusive` says so. */
 export function last(list, t, inclusive) {
+    return list[lastIndex(list, t, inclusive)];
+}
+/** Where `last` finds its entry in the list, -1 where it finds none. */
+export function lastIndex(list, t, inclusive) {
     let lo = 0;
     let hi = list.length - 1;
-    let found;
+    let found = -1;
     while (lo <= hi) {
         const mid = (lo + hi) >> 1;
         const e = list[mid];
         if (e.at < t || (e.at === t && (typeof inclusive === 'function' ? inclusive(e) : inclusive))) {
-            found = e;
+            found = mid;
             lo = mid + 1;
         }
         else
@@ -86,41 +90,125 @@ export function noted(mix, voice) {
         pageOut(mix, 'controls', voice.id, undefined, log.splice(0, drop), copied, reach);
 }
 const copied = (e) => ({ ...e });
+const nothing = Object.freeze([]);
 /** Takes off the front of a list kept by time what a read back to `reach` no longer needs. */
 function older(list, reach) {
+    const n = past(list, reach);
+    return n === 0 ? nothing : list.splice(0, n);
+}
+/** How many entries at the front of a list kept by time a read back to `reach` no longer needs. */
+function past(list, reach) {
     let n = 0;
     while (n + 1 < list.length && list[n + 1].at <= reach)
         n++;
-    return n === 0 ? [] : list.splice(0, n);
-}
-/** A copy of a subject's record that shares nothing a read could change. */
-export function copyHeld(voice, h) {
-    let kept = null;
-    if (h.kept !== null) {
-        kept = new Map();
-        for (const [owner, value] of h.kept)
-            kept.set(owner, clone(value));
-    }
+    return n;
+}
+/** A copy of the state a voice's patch keeps for a subject. */
+export function copyState(voice, state) {
     const patch = voice.patch;
-    return {
-        ...h,
+    return patch.clone ? patch.clone(state) : clone(state);
+}
+/**
+ * A copy of a subject's record that shares nothing a read could change; with `shared`, its state is
+ * the record's own, for a copy that takes one of its own before it steps.
+ */
+export function copyHeld(voice, h, shared = false) {
+    const kept = keptOf(h);
+    // Every field in `record`'s order, written out: a spread with fields after it costs a third more.
+    return unread({
+        reaches: h.reaches,
+        delay: h.delay,
+        since: h.since,
+        shown: h.shown,
+        weight: h.weight,
+        rested: h.rested,
         bands: h.bands === null ? null : h.bands.slice(),
-        state: h.state === undefined ? undefined : patch.clone ? patch.clone(h.state) : clone(h.state),
-        kept,
-        unkept: h.unkept?.map(clone),
-        probed: Number.NaN,
-        delta: null,
-        phase: 0,
-        seeks: 0,
+        state: h.state === undefined || shared ? h.state : copyState(voice, h.state),
+        stepped: h.stepped,
+        ticks: h.ticks,
+        probed: h.probed,
+        delta: h.delta,
+        phase: h.phase,
+        seeks: h.seeks,
+        rebuilt: h.rebuilt,
+        copied: h.copied,
         base: h.base === undefined ? undefined : clone(h.base),
         slope: h.slope === undefined ? undefined : clone(h.slope),
-        snaps: undefined,
-        inputs: undefined,
-        next: null,
-        version: Number.NaN,
-        loci: null,
-        slot: -1,
-    };
+        kept,
+        unkept: h.unkept?.map(clone),
+        snaps: h.snaps,
+        from: h.from,
+        unknown: h.unknown,
+        inputs: h.inputs,
+        replay: h.replay,
+        voice: h.voice,
+        next: h.next,
+        version: h.version,
+        loci: h.loci,
+        slot: h.slot,
+        run: h.run,
+        freed: h.freed,
+        // In no store, so stamped by none: a store trusts its stamp to say a record is still its own.
+        restored: null,
+    });
+}
+/** A copy of what a record keeps through `setting.keep`. */
+function keptOf(h) {
+    if (h.kept === null)
+        return null;
+    const kept = new Map();
+    for (const [owner, value] of h.kept)
+        kept.set(owner, clone(value));
+    return kept;
+}
+/**
+ * As `copyHeld`, written over `into`, a record nothing else holds, so a copy made in its place
+ * leaves nothing new to collect. test/history.test.ts holds this to `copyHeld` field by field.
+ */
+export function copyHeldInto(voice, h, into, shared = false) {
+    into.reaches = h.reaches;
+    into.delay = h.delay;
+    into.since = h.since;
+    into.shown = h.shown;
+    into.weight = h.weight;
+    into.rested = h.rested;
+    into.bands = h.bands === null ? null : h.bands.slice();
+    into.state = h.state === undefined || shared ? h.state : copyState(voice, h.state);
+    into.stepped = h.stepped;
+    into.ticks = h.ticks;
+    into.rebuilt = h.rebuilt;
+    into.copied = h.copied;
+    into.base = h.base === undefined ? undefined : clone(h.base);
+    into.slope = h.slope === undefined ? undefined : clone(h.slope);
+    into.kept = keptOf(h);
+    into.unkept = h.unkept?.map(clone);
+    into.from = h.from;
+    into.unknown = h.unknown;
+    into.replay = h.replay;
+    into.voice = h.voice;
+    into.slot = h.slot;
+    into.run = h.run;
+    into.freed = h.freed;
+    into.restored = null;
+    // `probed`, `delta`, `phase`, `seeks`, `snaps`, `inputs`, `next`, `version` and `loci` as
+    // `unread` leaves them.
+    return unread(into);
+}
+/**
+ * Lets go of what a record holds from its last probe and its place in a chain, as a copy of it
+ * starts: a seek puts back a record nothing else holds this way, in place of a copy.
+ */
+export function unread(h) {
+    h.probed = Number.NaN;
+    h.delta = null;
+    h.phase = 0;
+    h.seeks = 0;
+    h.snaps = undefined;
+    h.inputs = undefined;
+    h.next = null;
+    h.version = Number.NaN;
+    h.loci = null;
+    return h;
 }
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
 export function recordHost(mix, now) {
@@ -160,6 +248,23 @@ export function record(mix, voice, subject, held, value) {
     if (out.length > 0)
         pageOut(mix, 'input', voice.id, mix.keys?.key(subject), out, (e) => e.value, reach);
 }
+/** How far apart, in mix ms, a record's copies are kept. */
+export function apart(history) {
+    return history.every ?? 200;
+}
+/**
+ * A copy of a record to keep now, written over a spare the latest seek back cut, or one just let go
+ * of, where it has one.
+ */
+function snapOf(mix, voice, held, gone) {
+    const spare = voice.spares?.pop() ?? gone;
+    if (spare === undefined)
+        return { at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) };
+    spare.at = mix.now;
+    spare.seq = mix.transport.seq;
+    copyHeldInto(voice, held, spare.held);
+    return spare;
+}
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
 export function remember(mix, voice, subject, held) {
     const history = mix.opts.history;
@@ -172,13 +277,34 @@ export function remember(mix, voice, subject, held) {
     const snaps = held.snaps ?? [];
     held.snaps = snaps;
     const prev = snaps[snaps.length - 1];
-    if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
+    if (prev !== undefined && mix.now - prev.at < apart(history))
         return;
-    snaps.push({ at: mix.now, seq: mix.transport.seq, held: copyHeld(voice, held) });
+    // What falls out is the same before the push as after it, since the copy pushed is newer.
     const reach = mix.now - history.ms;
-    const out = older(snaps, reach);
-    if (out.length > 0)
-        pageOut(mix, 'snap', voice.id, mix.keys?.key(subject), out, (e) => packHeld(voice, e.held), reach);
+    const n = past(snaps, reach);
+    let gone;
+    if (n > 0) {
+        if (mix.transport.pager !== null)
+            pageOut(mix, 'snap', voice.id, mix.keys?.key(subject), snaps.slice(0, n), (e) => packHeld(voice, e.held), reach);
+        gone = reusable(snaps, n);
+        // `shift` moves the list's start where `splice` copies what it keeps and allocates what it cuts.
+        if (n === 1)
+            snaps.shift();
+        else
+            snaps.splice(0, n);
+    }
+    snaps.push(snapOf(mix, voice, held, gone));
+}
+/** The first of a list's first `n` copies no other record's list holds, made ready to be written over. */
+function reusable(snaps, n) {
+    for (let i = 0; i < n; i++) {
+        const snap = snaps[i];
+        if (snap.shared)
+            continue;
+        snap.ahead = undefined;
+        return snap;
+    }
+    return undefined;
 }
 /**
  * Under history, keeps the record a subject had when it left a voice, faded out of it or dropped,
@@ -194,13 +320,15 @@ export function leave(mix, voice, subject, held) {
     const keys = mix.keys;
     left.expire(reach, keys === null
         ? null
-        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync], reach));
+        : (e) => pageOut(mix, 'left', voice.id, keys.key(e.subject), [e], (x) => [packHeld(voice, x.held), x.sync, x.ramp, x.parted], reach));
     left.push({
         subject,
         at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now,
         seq: mix.transport.seq,
-        sync: mix.syncing,
+        sync: mix.syncing || !mix.looked,
         held,
+        ramp: voice.parts?.get(subject) ?? null,
+        parted: voice.parted?.get(subject) ?? null,
     });
 }
 /**

package/dist/hosts.js

@@ -1,5 +1,8 @@
+import { release } from './arcs.js';
 import { Book } from './book.js';
+import { headOf } from './chain.js';
 import { numericOf } from './channels.js';
+import { stepOf } from './clock.js';
 import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
 import { unshare, unsight, weightAt } from './everyone.js';
@@ -14,6 +17,7 @@ import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
 import { heard } from './signals.js';
+import { cuedById } from './strays.js';
 import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
@@ -69,31 +73,44 @@ export function laneHost(mix) {
         },
         passes: (was, w) => mix.passes(was, w),
         naming: (subject) => (mix.naming === 0 ? undefined : mix.named.get(subject)),
-        slotOf: (subject) => mix.chains.get(subject)?.slot ?? -1,
+        slotOf: (subject) => headOf(mix, subject)?.slot ?? -1,
         envelope: (voice, since) => voice.owner === null
             ? mix.envelope(voice, mix.now, since)
             : mix.envelope(voice, mix.now, since) * mix.ownedBy(voice, undefined),
         parting: (voice, subject) => mix.parting(voice, subject, mix.now),
-        ready: (voice, subject, held, elapsed, pass, weight) => {
-            mix.prime(voice, held, mix.now, elapsed, pass);
-            voice.setting.weight = weight;
+        ready: (voice, subject, held) => {
+            const arg = mix.lanes.arg;
+            const primed = mix.primed;
+            primed[0 /* Primed.NOW */] = mix.now;
+            primed[1 /* Primed.ELAPSED */] = arg[1 /* Arg.ELAPSED */];
+            primed[2 /* Primed.PASS */] = arg[3 /* Arg.PASS */];
+            mix.prime(voice, held);
+            voice.setting.weight = arg[0 /* Arg.WEIGHT */];
             mix.sending.voice = voice;
             mix.sending.subject = subject;
         },
-        signal: (voice, subject, held, elapsed, pass, slot) => {
+        signal: (voice, subject, held, slot) => {
+            const arg = mix.lanes.arg;
             // A blend member after the first takes the read already made, with no setting to fill.
             const read = voice.blend === null ? Number.NaN : mix.laneRead(voice, slot);
-            if (!Number.isNaN(read))
-                return read;
-            mix.prime(voice, held, mix.now, elapsed, pass);
+            if (!Number.isNaN(read)) {
+                arg[0 /* Arg.WEIGHT */] = read;
+                return;
+            }
+            const primed = mix.primed;
+            primed[0 /* Primed.NOW */] = mix.now;
+            primed[1 /* Primed.ELAPSED */] = arg[1 /* Arg.ELAPSED */];
+            primed[2 /* Primed.PASS */] = arg[3 /* Arg.PASS */];
+            mix.prime(voice, held);
             const kept = reading.kept;
             const base = mix.base(voice, subject, mix.now, held, slot);
             if (reading.kept !== kept && !voice.keeping)
                 stateful(mix, voice);
-            return base;
+            arg[0 /* Arg.WEIGHT */] = base;
         },
         horizon: (voice, delay) => {
-            reading.horizon = mix.horizonFor(voice, delay, mix.now);
+            if (voice.motion !== undefined)
+                reading.horizon = mix.horizonFor(voice, delay, mix.now);
         },
         keeps: mix.opts.history !== undefined,
         after: (voice, subject, held) => remember(mix, voice, subject, held),
@@ -161,8 +178,7 @@ function seekDoubt(mix, voice, rebuild) {
         return 'stepped';
     if (patch.step === undefined)
         return 'exact';
-    const tick = mix.opts.stepMs;
-    const fixed = tick !== undefined && tick > 0 && !mix.reducedNow && mix.opts.maxDt === undefined;
+    const fixed = stepOf(mix, voice) !== undefined && mix.opts.maxDt === undefined;
     return fixed ? 'exact' : 'stepped';
 }
 /** A voice's patch kept state on a record: it is stateful from now on. */
@@ -223,21 +239,33 @@ function handleHost(mix) {
                 beginFade(mix, voice, (opts ?? {}));
         },
         rise: (voice, opts) => beginRise(mix, voice, opts ?? {}),
+        release: (voice) => release(mix, voice),
         weightOf: (voice, subject) => {
             if (voice.state === 'done')
                 return 0;
             if (voice.holding !== null)
                 return ownWeight(voice, mix.now, mix.reducedNow, (o) => mix.ownerBase(o, subject));
-            const slot = mix.lanes === null ? -1 : (mix.chains.get(subject)?.slot ?? -1);
+            const slot = mix.lanes === null ? -1 : (headOf(mix, subject)?.slot ?? -1);
             if (voice.laned && mix.lanes !== null) {
                 const w = mix.lanes.weightOf(voice.id, slot);
                 if (w !== undefined)
                     return w;
             }
-            if (voice.sharing)
-                return weightAt(voice, slot);
-            return voice.subjects.get(subject)?.weight ?? 0;
+            const held = voice.sharing
+                ? undefined
+                : voice.subjects.get(subject);
+            // A voice that stopped sharing makes a subject's record at its next read, from what it kept.
+            return held !== undefined ? held.weight : weightAt(voice, slot);
         },
-        record: (label, again) => record(mix, label, again),
+        record: (h, label, again) => record(mix, label, (stage) => {
+            const to = stage.mix(mix);
+            if (to === mix)
+                again(h);
+            else if (to !== undefined) {
+                const voice = cuedById(to, h.id);
+                if (voice !== undefined)
+                    again(handle(to, voice));
+            }
+        }),
     };
 }

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export type { NumberOptions, Vec } from './channels.js';
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export type { ColorOptions } from './color.js';
 export { color, css, mixHex, oklab, toHex } from './color.js';
+export type { Curve } from './easing.js';
+export { curve } from './easing.js';
 export type { Claim, Fit, FitPlan, Order, SpanClaim, Strength } from './fit.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';
@@ -12,11 +14,12 @@ export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
 export type { AngleOptions } from './rotation.js';
 export { angle, quat } from './rotation.js';
-export { gate, input, lag, level, peak, slew } from './signals.js';
+export { gate, input, lag, level, peak, share, slew } from './signals.js';
 export { fold } from './stack.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
-export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';
+export type { Anchor, ArcHandle, ArcPart, ArcSpec, ArcVoice, BlendMember, BookedHit, Booker, BookOptions, Channel, Columns, Described, Doubt, Easing, Engine, FadeOptions, FadeSpec, FitResult, Handle, HistoryOptions, HistoryStore, Hit, Hold, Keyframe, Kit, Mark, Marked, MarkName, Mix, MixOptions, MotionSpec, OwnerSpec, Paged, PagedStream, Patch, Placement, Projection, Query, Registry, SeekOptions, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, Watched, WatchedFrame, } from './types.js';
+export { watched } from './watch.js';
 export type { WaveOptions, WaveShape } from './wave.js';
 export { wave, waveAt } from './wave.js';

package/dist/index.js

@@ -1,13 +1,15 @@
 export { kit, last, max, mul, sum, vec } from './channels.js';
 export { color, css, mixHex, oklab, toHex } from './color.js';
+export { curve } from './easing.js';
 export { conclude, condense, lax, layout, overrun, pipe, plain, shed, } from './fit.js';
 export { mix, mixer } from './mixer.js';
 export { glide, spring, tween } from './motion.js';
 export { HistoryMiss } from './paging.js';
 export { keys, patch } from './patch.js';
 export { angle, quat } from './rotation.js';
-export { gate, input, lag, level, peak, slew } from './signals.js';
+export { gate, input, lag, level, peak, share, slew } from './signals.js';
 export { fold } from './stack.js';
 export { ticker } from './ticker.js';
 export { transport } from './transport.js';
+export { watched } from './watch.js';
 export { wave, waveAt } from './wave.js';

package/dist/keyfill.js

@@ -23,6 +23,7 @@ export function runKeys(lanes, lane) {
     const before = voice.freezesBefore;
     const after = voice.freezesAfter;
     const span = voice.span;
+    const hides = voice.hidesPast;
     const flat = lane.flat;
     const parts = voice.parts !== null;
     const whole = clampWeight(voice.weight);
@@ -42,7 +43,8 @@ export function runKeys(lanes, lane) {
             data[o + 3 /* Row.PROBED */] = data[o + 2 /* Row.WEIGHT */];
         if (lately >= 0 && lanes.unread(slot))
             continue;
-        const elapsed = frozenTime(elapsedNow - data[o + 0 /* Row.DELAY */], before, after, span);
+        const raw = elapsedNow - data[o + 0 /* Row.DELAY */];
+        const elapsed = raw > span && hides ? Number.NaN : frozenTime(raw, before, after, span);
         if (!(elapsed >= 0)) {
             data[o + 2 /* Row.WEIGHT */] = 0;
             unband(records[p]);

package/dist/lane.d.ts

@@ -235,6 +235,6 @@ export declare class Lane<I, O> implements Positions<I, O> {
 }
 /**
  * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing.
+ * of its passes after, and NaN where it shows nothing, as past its end running back.
  */
 export declare function frozenAt<I, O>(voice: Voice<I, O>, elapsed: number): number;

package/dist/lane.js

@@ -185,8 +185,10 @@ export class Lane {
 }
 /**
  * A subject's voice time once its voice's freezes apply: frozen at 0 before it starts and at the end
- * of its passes after, and NaN where it shows nothing.
+ * of its passes after, and NaN where it shows nothing, as past its end running back.
  */
 export function frozenAt(voice, elapsed) {
+    if (elapsed > voice.span && voice.hidesPast)
+        return Number.NaN;
     return frozenTime(elapsed, voice.freezesBefore, voice.freezesAfter, voice.span);
 }

package/dist/lanes.d.ts

@@ -7,6 +7,7 @@ import { type Lane, type Laned, type Locus } from './lane.js';
 import type { Watcher } from './motions.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
+import { Placed } from './placed.js';
 import type { Channel } from './types.js';
 import type { Subject, Voice } from './voice.js';
 /** What a lane fill asks of the mix it belongs to. */
@@ -32,14 +33,18 @@ export interface LaneHost<I, O> {
     envelope(voice: Voice<I, O>, since: number): number;
     /** What a subject's own ramp out of the voice leaves of its weight, 0..1. */
     parting(voice: Voice<I, O>, subject: I): number;
-    /** Fills the voice's setting and the send target for a call to its patch. */
-    ready(voice: Voice<I, O>, subject: I, held: Subject<unknown>, elapsed: number, pass: number, weight: number): void;
     /**
-     * A voice with a signal weight: the signal's value for a subject the general path has met, before
-     * the fade and ramp `weighed` applies, with the setting filled in for the call; makes the voice
-     * stateful if the signal keeps state. `slot` is the subject's number.
+     * Fills the voice's setting and the send target for a call to its patch, at the voice time, pass
+     * and weight in `Arg.ELAPSED`, `Arg.PASS` and `Arg.WEIGHT`.
      */
-    signal(voice: Voice<I, O>, subject: I, held: Subject<unknown>, elapsed: number, pass: number, slot: number): number;
+    ready(voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
+    /**
+     * A voice with a signal weight: the signal's value for a subject the general path has met, at the
+     * voice time and pass in `Arg.ELAPSED` and `Arg.PASS`, left in `Arg.WEIGHT` before the fade and
+     * ramp `weighed` applies, with the setting filled in for the call; makes the voice stateful if the
+     * signal keeps state. `slot` is the subject's number.
+     */
+    signal(voice: Voice<I, O>, subject: I, held: Subject<unknown>, slot: number): void;
     /** Whether a rest-less channel's contribution passes the band, as the general path decides it. */
     passes(was: boolean | undefined, w: number): boolean;
     /** Sets `reading.horizon` for the voice and a subject delayed `delay` voice ms. */
@@ -65,6 +70,13 @@ export declare class Lanes<I, O> implements Watcher {
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds: Crowd<I, O>[];
     readonly crowdOf: Map<number, Crowd<I, O>>;
+    /** Which crowd voices' rows are placed on each subject. */
+    readonly placed: Placed;
+    /**
+     * By subject number, the mix's `relinks` when the subject's chain was last made stale by itself,
+     * so `pull` tells a head it remembers is stale without reading the head.
+     */
+    unlinked: Float64Array<ArrayBuffer>;
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap: boolean;
     /** The loci whose voices are on lanes, every member of each on one. */
@@ -168,7 +180,12 @@ export declare class Lanes<I, O> implements Watcher {
     lately: number;
     filledVersion: number;
     qualifiedVersion: number;
-    constructor(host: LaneHost<I, O>);
+    /**
+     * With `from`, the lanes a seek replaces: their subject numbers carry over, each met as newly
+     * numbered when its chain is next linked (`renew`), so a seek makes no new weak reference per
+     * subject.
+     */
+    constructor(host: LaneHost<I, O>, from?: Lanes<I, O>);
     /** A change that may move a voice on or off its lane: qualify again, then fill again. */
     invalidate(): void;
     /** A change to a laned voice's weight or clock between probes: fill again. */
@@ -181,6 +198,13 @@ export declare class Lanes<I, O> implements Watcher {
     /** Numbers a subject the mix sees for the first time. */
     number(subject: I): number;
     release(slot: number): void;
+    /** Whether `slot` is a number a seek carried over whose chain has not been linked since. */
+    sought(slot: number): boolean;
+    /**
+     * A chain is being linked for the subject at `slot`: one a seek carried over is from now on as
+     * `number` leaves a subject it numbers. Says whether it was one.
+     */
+    renew(slot: number): boolean;
     /** A voice faded a subject out of itself alone: its lane lets the subject's position go. */
     part(id: number, slot: number): void;
     /** A voice brought a subject back: its next probe meets every lane again, as it met them first. */

package/dist/lanes.js

@@ -5,6 +5,7 @@ import { fold, foldDelta, foldInto, foldRun, gate, gather, unplain } from './gat
 import { meet, reach } from './meet.js';
 import { absent, Numbers } from './numbers.js';
 import { Owed } from './owed.js';
+import { Placed } from './placed.js';
 import { requalify, retouch } from './qualify.js';
 import { reading } from './reading.js';
 import { reportedRow, unplace } from './rows.js';
@@ -23,6 +24,13 @@ export class Lanes {
     /** The crowds of single-subject voices, one per list of channels, and which holds each voice. */
     crowds = [];
     crowdOf = new Map();
+    /** Which crowd voices' rows are placed on each subject. */
+    placed = new Placed();
+    /**
+     * By subject number, the mix's `relinks` when the subject's chain was last made stale by itself,
+     * so `pull` tells a head it remembers is stale without reading the head.
+     */
+    unlinked = new Float64Array(0);
     /** Whether two crowds share a channel, so their rows must interleave in voice order. */
     overlap = false;
     /** The loci whose voices are on lanes, every member of each on one. */
@@ -126,9 +134,27 @@ export class Lanes {
     lately = -1;
     filledVersion = Number.NaN;
     qualifiedVersion = Number.NaN;
-    constructor(host) {
+    /**
+     * With `from`, the lanes a seek replaces: their subject numbers carry over, each met as newly
+     * numbered when its chain is next linked (`renew`), so a seek makes no new weak reference per
+     * subject.
+     */
+    constructor(host, from) {
         this.host = host;
-        this.numbers = new Numbers(this);
+        if (from === undefined) {
+            this.numbers = new Numbers(this);
+            return;
+        }
+        this.numbers = from.numbers;
+        this.numbers.adopt(this);
+        this.live = from.live;
+        const size = this.numbers.size;
+        this.grow(size);
+        const per = this.per;
+        for (let slot = 0; slot < size; slot++) {
+            per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = Number.NaN;
+            per[slot * 6 /* Per.SLOT */ + 1 /* Per.SEEN */] = -1;
+        }
     }
     /** A change that may move a voice on or off its lane: qualify again, then fill again. */
     invalidate() {
@@ -165,6 +191,22 @@ export class Lanes {
     release(slot) {
         this.numbers.release(slot);
     }
+    /** Whether `slot` is a number a seek carried over whose chain has not been linked since. */
+    sought(slot) {
+        return Number.isNaN(this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */]);
+    }
+    /**
+     * A chain is being linked for the subject at `slot`: one a seek carried over is from now on as
+     * `number` leaves a subject it numbers. Says whether it was one.
+     */
+    renew(slot) {
+        if (!this.sought(slot))
+            return false;
+        this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
+        if (this.filling)
+            this.late.push(slot);
+        return true;
+    }
     /** A voice faded a subject out of itself alone: its lane lets the subject's position go. */
     part(id, slot) {
         const lane = this.byId.get(id);
@@ -374,10 +416,15 @@ export class Lanes {
         this.live--;
         for (const lane of this.lanes)
             lane.remove(slot);
-        for (const c of this.crowds)
-            for (let p = 0; p < c.size; p++)
-                if (c.list[p] === slot)
-                    unplace(this, c, p);
+        const placed = this.placed;
+        for (let id = placed.any(slot); id !== 0; id = placed.any(slot)) {
+            const c = this.crowdOf.get(id);
+            const p = c?.rowOf.get(id);
+            if (c !== undefined && p !== undefined && c.list[p] === slot)
+                unplace(this, c, p);
+            else
+                placed.remove(slot, id);
+        }
         if (slot < this.cap)
             this.per[slot * 6 /* Per.SLOT */ + 0 /* Per.FILLED */] = this.fills;
         this.subjects[slot] = undefined;
@@ -390,6 +437,10 @@ export class Lanes {
         per.set(this.per);
         this.per = per;
         this.owed.grow(cap);
+        this.placed.grow(cap);
+        const unlinked = new Float64Array(cap);
+        unlinked.set(this.unlinked);
+        this.unlinked = unlinked;
         for (const ch of this.laned) {
             const values = new Float64Array(cap * ch.axes);
             values.set(ch.values);

package/dist/lean.d.ts

@@ -0,0 +1,15 @@
+import type { Engine, Kit, Mix, MixOptions } from './types.js';
+export * from './index.js';
+/**
+ * The stock engine without lanes: every voice folds subject by subject, to the same values, and a
+ * bundle that takes `mix` from here leaves the lanes' code out. `lanes: true` is refused.
+ *
+ * @category engine
+ */
+export declare const lean: Engine;
+/**
+ * Makes a mix over a kit, on the engine the options name or the lean one.
+ *
+ * @category mix
+ */
+export declare function mix<I, O, H = unknown>(kit: Kit<O>, opts?: MixOptions<H>): Mix<I, O, H>;