@msb235/blits 0.6.0 → 0.7.1

package/dist/gather.js

@@ -171,6 +171,8 @@ export function foldInto(ch, slot, value, w) {
         gatherInto(this, this.into, ch, slot, value, w);
         return;
     }
+    if (ch.op === 'last' && !this.gate(ch, w))
+        return;
     const values = ch.values;
     if (ch.scalar) {
         values[slot] = foldNumber(ch.op, values[slot], value, w);
@@ -184,3 +186,19 @@ export function foldInto(ch, slot, value, w) {
         values[base + a] = foldNumber(ch.op, values[base + a], v, w);
     }
 }
+/**
+ * Whether a rest-less channel's contribution passes the band, for the record `one` is folding: the
+ * general path's `apply` decides it from the same band state on the same record, so a subject
+ * moving between the paths carries it.
+ */
+export function gate(ch, w) {
+    const lane = this.folding;
+    const rec = this.rec;
+    const i = lane.chans.indexOf(ch);
+    const bands = rec.bands ?? new Uint8Array(lane.chans.length);
+    rec.bands = bands;
+    const band = bands[i];
+    const on = this.host.passes(band === 0 ? undefined : band === 1, w);
+    bands[i] = on ? 1 : 2;
+    return on;
+}

package/dist/gone.d.ts

@@ -0,0 +1,32 @@
+import type { Mixer } from './mixer.js';
+import { Store } from './store.js';
+import type { Voice } from './voice.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export declare class GoneIndex<I, O> {
+    /** The `gone` list it was built over, and how much of it. */
+    of: readonly Voice<I, O>[] | null;
+    count: number;
+    general: Voice<I, O>[];
+    named: Store<I, Voice<I, O>[]>;
+    /** The latest `doneAt` in `of`, and how far any voice finished before one listed ahead of it. */
+    latest: number;
+    slack: number;
+}
+/** The index caught up with `mix.gone`. */
+export declare function goneIndex<I, O>(mix: Mixer<I, O>): GoneIndex<I, O>;
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export declare function keepGone<I, O>(mix: Mixer<I, O>, keep: (v: Voice<I, O>) => boolean): void;
+/**
+ * Lets go of the gone voices that finished before `reach`. Voices go in about the order they
+ * finish, so only the front can hold one: past the point where a voice finished `slack` after
+ * `reach`, none behind it finished before `reach`.
+ */
+export declare function expireGone<I, O>(mix: Mixer<I, O>, reach: number): void;

package/dist/gone.js

@@ -0,0 +1,134 @@
+import { scoredCut } from './scored.js';
+import { Store } from './store.js';
+/**
+ * A mix's gone voices as `drop` and a freed slot look for them: those over every subject, and the
+ * rest by each subject they name. Kept in step with `gone`, which only grows by push and is
+ * otherwise replaced whole, so it catches up lazily and rebuilds only on a replacement it did not
+ * make itself. Under history a churning mix holds thousands, too many to walk per subject dropped.
+ */
+export class GoneIndex {
+    /** The `gone` list it was built over, and how much of it. */
+    of = null;
+    count = 0;
+    general = [];
+    named = new Store();
+    /** The latest `doneAt` in `of`, and how far any voice finished 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);
+    else
+        ix.latest = voice.doneAt;
+    if (voice.named === null) {
+        ix.general.push(voice);
+        return;
+    }
+    for (const subject of voice.named) {
+        const list = ix.named.get(subject);
+        if (list === undefined)
+            ix.named.set(subject, [voice]);
+        else
+            list.push(voice);
+    }
+}
+function remove(ix, out) {
+    let general = false;
+    for (const v of out) {
+        if (v.named === null) {
+            general = true;
+            continue;
+        }
+        for (const subject of v.named) {
+            const named = ix.named.get(subject);
+            if (named === undefined)
+                continue;
+            const at = named.indexOf(v);
+            if (at >= 0)
+                named.splice(at, 1);
+            if (named.length === 0)
+                ix.named.delete(subject);
+        }
+    }
+    if (general) {
+        const leaving = new Set(out);
+        ix.general = ix.general.filter((v) => !leaving.has(v));
+    }
+}
+/** The index caught up with `mix.gone`. */
+export function goneIndex(mix) {
+    const ix = mix.goneIx;
+    const list = mix.gone;
+    if (ix.of !== list || ix.count > list.length) {
+        ix.general = [];
+        ix.named = new Store();
+        ix.count = 0;
+        ix.of = list;
+        ix.latest = Number.NEGATIVE_INFINITY;
+        ix.slack = 0;
+    }
+    for (let i = ix.count; i < list.length; i++)
+        add(ix, list[i]);
+    ix.count = list.length;
+    return ix;
+}
+/**
+ * Keeps the gone voices `keep` says yes to, asking it once each, and takes the rest out of the
+ * index one by one. Leaves `gone` as it was when every one stays.
+ */
+export function keepGone(mix, keep) {
+    const ix = goneIndex(mix);
+    const list = mix.gone;
+    let i = 0;
+    while (i < list.length && keep(list[i]))
+        i++;
+    if (i === list.length)
+        return;
+    const kept = list.slice(0, i);
+    const out = [list[i]];
+    for (i++; i < list.length; i++) {
+        const v = list[i];
+        (keep(v) ? kept : out).push(v);
+    }
+    remove(ix, out);
+    mix.gone = kept;
+    scoredCut(mix, list, out);
+    ix.of = kept;
+    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`.
+ */
+export function expireGone(mix, reach) {
+    const ix = goneIndex(mix);
+    if (!Number.isFinite(ix.slack)) {
+        keepGone(mix, (v) => v.doneAt >= reach);
+        return;
+    }
+    const list = mix.gone;
+    const edge = reach + ix.slack;
+    let end = 0;
+    let any = false;
+    for (let seen = Number.NEGATIVE_INFINITY; end < list.length && seen < edge; end++) {
+        const done = list[end].doneAt;
+        if (done < reach)
+            any = true;
+        if (done > seen)
+            seen = done;
+    }
+    if (!any)
+        return;
+    const kept = [];
+    const out = [];
+    for (let i = 0; i < end; i++) {
+        const v = list[i];
+        (v.doneAt < reach ? out : kept).push(v);
+    }
+    list.splice(0, end, ...kept);
+    remove(ix, out);
+    scoredCut(mix, list, out);
+    ix.count = list.length;
+}

package/dist/handle.d.ts

@@ -1,4 +1,4 @@
-import type { FadeOptions, Handle } from './types.js';
+import type { FadeOptions, FitResult, Handle } from './types.js';
 import type { Voice } from './voice.js';
 /** What a voice's handle asks of the mix that cued it: one per mix, shared by every handle. */
 export interface HandleHost<I, O> {
@@ -9,17 +9,39 @@ export interface HandleHost<I, O> {
     /** The voice's clock jumped: for an owner, so did every clock it holds. */
     sought(voice: Voice<I, O>): void;
     fade(voice: Voice<I, O>, opts: FadeOptions<I> | undefined): void;
+    rise(voice: Voice<I, O>, opts: {
+        over?: number;
+    } | undefined): void;
     weightOf(voice: Voice<I, O>, subject: I): number;
+    /** Records a write the host made, which `again` makes once more where a seek replays it. */
+    record(label: string, again: () => void): void;
 }
-/** A voice's handle: the host's only way to control a voice once cued. */
+/** What a handle answers for a voice a history store paged out, which left long ago. */
+export interface Gone {
+    weight: number;
+    played: boolean;
+}
+/**
+ * A voice's handle: the host's only way to control a voice once cued. A voice a history store
+ * pages out is let go of here too, so the handle answers as a gone voice's does, and a seek that
+ * revives it puts the revived voice behind the same handle.
+ */
 export declare class VoiceHandle<I, O> implements Handle<I> {
     #private;
     readonly id: number;
     constructor(voice: Voice<I, O>, host: HandleHost<I, O>);
+    /** The voice behind a handle; null while a history store holds it. */
+    static voiceOf<I, O>(h: VoiceHandle<I, O>): Voice<I, O> | null;
+    /** Lets go of a voice a history store paged out. */
+    static page<I, O>(h: VoiceHandle<I, O>, gone: Gone): void;
+    /** Puts a voice revived from a history store behind the handle it had. */
+    static rehome<I, O>(h: VoiceHandle<I, O>, voice: Voice<I, O>): void;
     get state(): Handle<I>['state'];
     get owner(): Handle<I> | undefined;
     get played(): Promise<boolean>;
     get done(): Promise<void>;
+    /** How a span's children were last fitted; undefined for any voice but a span. */
+    get result(): FitResult | undefined;
     get weight(): number;
     set weight(w: number);
     get rate(): number;
@@ -27,5 +49,8 @@ export declare class VoiceHandle<I, O> implements Handle<I> {
     ramp(r: number, over: number): void;
     seek(elapsed: number): void;
     fade(opts?: FadeOptions<I>): void;
+    rise(opts?: {
+        over?: number;
+    }): void;
     weightOf(subject: I): number;
 }

package/dist/handle.js

@@ -1,56 +1,105 @@
 import { retime } from './clock.js';
-/** A voice's handle: the host's only way to control a voice once cued. */
+/**
+ * A voice's handle: the host's only way to control a voice once cued. A voice a history store
+ * pages out is let go of here too, so the handle answers as a gone voice's does, and a seek that
+ * revives it puts the revived voice behind the same handle.
+ */
 export class VoiceHandle {
     id;
     #voice;
+    #gone = null;
     #host;
     constructor(voice, host) {
         this.id = voice.id;
         this.#voice = voice;
         this.#host = host;
     }
+    /** The voice behind a handle; null while a history store holds it. */
+    static voiceOf(h) {
+        return h.#voice;
+    }
+    /** Lets go of a voice a history store paged out. */
+    static page(h, gone) {
+        h.#voice = null;
+        h.#gone = gone;
+    }
+    /** Puts a voice revived from a history store behind the handle it had. */
+    static rehome(h, voice) {
+        h.#voice = voice;
+        h.#gone = null;
+    }
     get state() {
-        return this.#voice.state;
+        return this.#voice?.state ?? 'done';
     }
     get owner() {
-        return this.#voice.owner?.handle ?? undefined;
+        return this.#voice?.owner?.handle ?? undefined;
     }
     get played() {
-        return this.#voice.played;
+        return this.#voice?.played ?? Promise.resolve(this.#gone?.played ?? false);
     }
     get done() {
-        return this.#voice.done;
+        return this.#voice?.done ?? Promise.resolve();
+    }
+    /** How a span's children were last fitted; undefined for any voice but a span. */
+    get result() {
+        return this.#voice?.fitting?.report;
     }
     get weight() {
-        return this.#voice.weight;
+        return this.#voice?.weight ?? this.#gone?.weight ?? 0;
     }
+    // A write to a paged voice changes nothing: it had left when the host made it, as it has on replay.
     set weight(w) {
-        this.#voice.weight = w;
-        this.#host.changed(this.#voice);
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        voice.weight = w;
+        this.#host.changed(voice);
+        this.#host.record('weight', () => {
+            this.weight = w;
+        });
     }
     get rate() {
-        return this.#voice.rateAt(this.#host.nowFor(this.#voice));
+        const voice = this.#voice;
+        return voice === null ? 0 : voice.rateAt(this.#host.nowFor(voice));
     }
     set rate(r) {
         this.ramp(r, 0);
     }
     ramp(r, over) {
         const voice = this.#voice;
+        if (voice === null)
+            return;
         retime(voice, this.#host.nowFor(voice), r, over);
         this.#host.changed(voice);
+        this.#host.record('rate', () => this.ramp(r, over));
     }
     seek(elapsed) {
         const voice = this.#voice;
+        if (voice === null)
+            return;
         voice.rebase(this.#host.nowFor(voice));
         voice.anchorElapsed = elapsed;
         voice.seeks++;
         this.#host.sought(voice);
         this.#host.changed(voice);
+        this.#host.record('seek', () => this.seek(elapsed));
     }
     fade(opts) {
-        this.#host.fade(this.#voice, opts);
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        this.#host.fade(voice, opts);
+        this.#host.record('fade', () => this.fade(opts));
+    }
+    rise(opts) {
+        const voice = this.#voice;
+        if (voice === null)
+            return;
+        this.#host.rise(voice, opts);
+        this.#host.record('rise', () => this.rise(opts));
     }
     weightOf(subject) {
-        return this.#host.weightOf(this.#voice, subject);
+        const voice = this.#voice;
+        return voice === null ? 0 : this.#host.weightOf(voice, subject);
     }
 }

package/dist/held.js

@@ -49,6 +49,10 @@ export function held(voice, subject, now, slot) {
             voice.subjects.set(subject, none);
         return none;
     }
+    if (this.keys !== null) {
+        voice.keyed ??= new Set();
+        voice.keyed.add(this.keys.key(subject));
+    }
     const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
     const since = this.sinceOf(voice, delay);
     held = {

package/dist/history.d.ts

@@ -17,6 +17,19 @@ export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>):
 /** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
 export declare function recordHost<I, O>(mix: Mixer<I, O>, now: number): void;
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
-export declare function record<I, O>(mix: Mixer<I, O>, held: Subject<unknown>, value: number): void;
+export declare function record<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>, value: number): void;
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
-export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>): void;
+export declare function remember<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown>): void;
+/**
+ * Under history, keeps the record a subject had when it left a voice, faded out of it or dropped,
+ * for a seek or a read back to before then; without history, keeps nothing.
+ */
+export declare function leave<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, subject: I, held: Subject<unknown> | undefined): void;
+/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
+export declare function leftAt<I>(left: readonly {
+    subject: I;
+    at: number;
+    held: Subject<unknown>;
+}[] | null, subject: I, t: number): Subject<unknown> | undefined;
+/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
+export declare function releasing<I, O>(mix: Mixer<I, O>): [at?: number, reach?: number];

package/dist/history.js

@@ -1,6 +1,9 @@
 import { elapsedWith } from './clock.js';
 import { clone } from './clone.js';
 import { schedule } from './due.js';
+import { packHeld } from './pack.js';
+import { pageOut } from './paging.js';
+import { scoreTouched } from './scored.js';
 import { none } from './voice.js';
 /**
  * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
@@ -50,6 +53,7 @@ function ownerThen(mix, owner, t) {
 }
 /** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
 export function noted(mix, voice) {
+    scoreTouched(mix, voice, true);
     mix.stir();
     schedule(mix, voice);
     const log = voice.log;
@@ -61,7 +65,15 @@ export function noted(mix, voice) {
     while (drop + 1 < log.length && log[drop + 1].at <= reach)
         drop++;
     if (drop > 0)
-        log.splice(0, drop);
+        pageOut(mix, 'controls', voice.id, undefined, log.splice(0, drop), copied, reach);
+}
+const copied = (e) => ({ ...e });
+/** Takes off the front of a list kept by time what a read back to `reach` no longer needs. */
+function older(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) {
@@ -77,6 +89,7 @@ export function copyHeld(voice, h) {
         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,
@@ -107,11 +120,10 @@ export function recordHost(mix, now) {
         return;
     log.push({ at: now, fields });
     const reach = now - mix.opts.history.ms;
-    while (log.length > 1 && log[1].at <= reach)
-        log.shift();
+    pageOut(mix, 'host', undefined, undefined, older(log, reach), (e) => e.fields, reach);
 }
 /** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
-export function record(mix, held, value) {
+export function record(mix, voice, subject, held, value) {
     const history = mix.opts.history;
     if (!history?.inputs || mix.projecting)
         return;
@@ -125,11 +137,12 @@ export function record(mix, held, value) {
     }
     inputs.push({ at: mix.now, value });
     const reach = mix.now - history.ms;
-    while (inputs.length > 1 && inputs[1].at <= reach)
-        inputs.shift();
+    const out = older(inputs, reach);
+    if (out.length > 0)
+        pageOut(mix, 'input', voice.id, mix.keys?.key(subject), out, (e) => e.value, reach);
 }
 /** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
-export function remember(mix, voice, held) {
+export function remember(mix, voice, subject, held) {
     const history = mix.opts.history;
     if (!history || mix.projecting)
         return;
@@ -144,6 +157,40 @@ export function remember(mix, voice, held) {
         return;
     snaps.push({ at: mix.now, held: copyHeld(voice, held) });
     const reach = mix.now - history.ms;
-    while (snaps.length > 1 && snaps[1].at <= reach)
-        snaps.shift();
+    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);
+}
+/**
+ * Under history, keeps the record a subject had when it left a voice, faded out of it or dropped,
+ * for a seek or a read back to before then; without history, keeps nothing.
+ */
+export function leave(mix, voice, subject, held) {
+    const history = mix.opts.history;
+    if (history === undefined || held === undefined)
+        return;
+    const reach = mix.now - history.ms;
+    const left = [];
+    for (const e of voice.left ?? [])
+        if (e.at >= reach)
+            left.push(e);
+        else if (mix.keys !== null)
+            pageOut(mix, 'left', voice.id, mix.keys.key(e.subject), [e], (x) => packHeld(voice, x.held), reach);
+    left.push({ subject, at: Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, held });
+    voice.left = left;
+}
+/** The record a subject had at mix time `t` and left a voice with after it, if it left after `t`. */
+export function leftAt(left, subject, t) {
+    let found;
+    for (const e of left ?? [])
+        if (e.at > t && Object.is(e.subject, subject) && (found === undefined || e.at < found.at))
+            found = e;
+    return found?.held;
+}
+/** The mix time a motion patch keeps a released subject from, and how far back, under history. */
+export function releasing(mix) {
+    const history = mix.opts.history;
+    if (history === undefined || Number.isNaN(mix.now))
+        return [];
+    return [mix.now, mix.now - history.ms];
 }

package/dist/hosts.d.ts

@@ -7,8 +7,8 @@ export declare function laneHost<I, O>(mix: Mixer<I, O>): LaneHost<I, O>;
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
- * one that starts keeping partway through may advance that state once for one subject not
- * probed on the frame it starts, which declaring `state` avoids.
+ * one that starts keeping partway through may advance that state once for one subject probed the
+ * frame before it starts and not on that frame, which declaring `state` avoids.
  */
 export declare function fits<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): boolean;
 /** A voice's patch kept state on a record: it is stateful from now on. */

package/dist/hosts.js

@@ -1,6 +1,9 @@
 import { Book } from './book.js';
+import { numericOf } from './channels.js';
+import { crowdable } from './crowd.js';
 import { schedule } from './due.js';
-import { beginFade, fadeSubject } from './fade.js';
+import { beginFade, beginRise, fadeAt, fadeSubject } from './fade.js';
+import { goneIndex } from './gone.js';
 import { VoiceHandle } from './handle.js';
 import { noted, remember } from './history.js';
 import { hostOf, listed, markOf, readingAt } from './marks.js';
@@ -8,6 +11,7 @@ import { nextFrame } from './move.js';
 import { descendants, ownWeight, signalled } from './owner.js';
 import { localNow } from './place.js';
 import { reading } from './reading.js';
+import { record } from './tape.js';
 import { unreach } from './unreached.js';
 export function book(mix, opts) {
     if (mix.projecting)
@@ -42,6 +46,7 @@ export function laneHost(mix) {
         },
         channels: mix.channels,
         names: mix.names,
+        clock: mix,
         fits: (voice) => fits(mix, voice),
         meet: (voice, subject, head, slot) => {
             for (let held = head; held !== null; held = held.next)
@@ -53,9 +58,10 @@ export function laneHost(mix) {
             // Only a voice over every subject keeps bits, and one gone may still be read back.
             for (const voice of mix.general)
                 unreach(voice, slot, false);
-            for (const voice of mix.gone)
+            for (const voice of goneIndex(mix).general)
                 unreach(voice, slot, false);
         },
+        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,
         envelope: (voice, since) => voice.owner === null
@@ -84,15 +90,15 @@ export function laneHost(mix) {
             reading.horizon = mix.horizonFor(voice, delay, mix.now);
         },
         keeps: mix.opts.history !== undefined,
-        after: (voice, held) => remember(mix, voice, held),
+        after: (voice, subject, held) => remember(mix, voice, subject, held),
         kept: (voice) => stateful(mix, voice),
     };
 }
 /**
  * Whether a voice's patch and spec can run on a lane, its channels aside. A voice whose patch has
  * kept state on a record through `setting.keep` is stateful from then on, and leaves its lane;
- * one that starts keeping partway through may advance that state once for one subject not
- * probed on the frame it starts, which declaring `state` avoids.
+ * one that starts keeping partway through may advance that state once for one subject probed the
+ * frame before it starts and not on that frame, which declaring `state` avoids.
  */
 export function fits(mix, voice) {
     const spec = voice.spec;
@@ -112,6 +118,10 @@ export function fits(mix, voice) {
         return false;
     if (spec.from === 'current')
         return false;
+    // A rest-less channel's band is read on the record `one` folds; crowds, motions and loci fold elsewhere.
+    if ((voice.motion !== undefined || spec.locus !== undefined || crowdable(voice)) &&
+        voice.slots.some((s) => numericOf(mix.channels[s])?.op === 'last'))
+        return false;
     if (voice.out?.rest)
         return false;
     if (patch.state !== undefined || patch.step !== undefined)
@@ -159,9 +169,12 @@ function handleHost(mix) {
                 throw new Error('blits: an owner fades as a whole, not by subject or at rest');
             if (opts !== undefined && 'subject' in opts)
                 fadeSubject(mix, voice, opts.subject, opts.over);
+            else if (typeof opts?.at === 'number')
+                fadeAt(mix, voice, opts.at, opts.over);
             else
-                beginFade(mix, voice, opts ?? {});
+                beginFade(mix, voice, (opts ?? {}));
         },
+        rise: (voice, opts) => beginRise(mix, voice, opts ?? {}),
         weightOf: (voice, subject) => {
             if (voice.state === 'done')
                 return 0;
@@ -174,5 +187,6 @@ function handleHost(mix) {
             }
             return voice.subjects.get(subject)?.weight ?? 0;
         },
+        record: (label, again) => record(mix, label, again),
     };
 }

package/dist/index.d.ts

@@ -1,11 +1,17 @@
 export type { NumberOptions } from './channels.js';
-export { hex, kit, last, max, mixHex, mul, sum, vec } from './channels.js';
+export { kit, last, max, mul, sum, vec } from './channels.js';
+export type { ColorOptions } from './color.js';
+export { color, css, hex, mixHex, oklab, toHex } from './color.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';
 export type { Motion, Moving, PerSubject, Value } from './motion.js';
 export { glide, spring, tween } from './motion.js';
+export { HistoryMiss } from './paging.js';
 export type { KeysOptions, PatchOptions } from './patch.js';
 export { keys, patch } from './patch.js';
 export { gate, lag, level, peak, slew } from './signals.js';
 export type { Ticked, Ticker, TickerOptions } from './ticker.js';
 export { ticker } from './ticker.js';
-export type { Anchor, BookedHit, Booker, BookOptions, Channel, Columns, Doubt, Easing, Engine, FadeOptions, FadeSpec, Handle, Hit, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, OwnerSpec, Patch, Placement, Projection, Query, Sent, Setting, Signal, VoiceSpec, } from './types.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, Sent, Setting, Signal, SpanHandle, SpanHints, SpanSpec, Tape, TapeBranch, TapeMaker, TapeOp, Transport, TransportOptions, TransportProjection, VoiceSpec, } from './types.js';

package/dist/index.js

@@ -1,6 +1,10 @@
-export { hex, kit, last, max, mixHex, mul, sum, vec } from './channels.js';
+export { kit, last, max, mul, sum, vec } from './channels.js';
+export { color, css, hex, mixHex, oklab, toHex } from './color.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 { gate, lag, level, peak, slew } from './signals.js';
 export { ticker } from './ticker.js';
+export { transport } from './transport.js';

package/dist/lane.d.ts

@@ -1,5 +1,5 @@
 import type { Numeric } from './channels.js';
-import { type Motions } from './motion.js';
+import type { Motions } from './motions.js';
 import type { Scratch } from './patch.js';
 import type { Subject, Voice } from './voice.js';
 /** One laned channel: its arithmetic, and every numbered subject's folded value, `axes` per subject. */