@msb235/blits 0.4.0 → 0.6.0

package/dist/handle.d.ts

@@ -0,0 +1,31 @@
+import type { FadeOptions, 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> {
+    /** The mix clock, or the voice's start before the first sync. */
+    nowFor(voice: Voice<I, O>): number;
+    /** A handle write changed the voice: reschedule it, and refill the lanes. */
+    changed(voice: Voice<I, O>): void;
+    /** 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;
+    weightOf(voice: Voice<I, O>, subject: I): number;
+}
+/** A voice's handle: the host's only way to control a voice once cued. */
+export declare class VoiceHandle<I, O> implements Handle<I> {
+    #private;
+    readonly id: number;
+    constructor(voice: Voice<I, O>, host: HandleHost<I, O>);
+    get state(): Handle<I>['state'];
+    get owner(): Handle<I> | undefined;
+    get played(): Promise<boolean>;
+    get done(): Promise<void>;
+    get weight(): number;
+    set weight(w: number);
+    get rate(): number;
+    set rate(r: number);
+    ramp(r: number, over: number): void;
+    seek(elapsed: number): void;
+    fade(opts?: FadeOptions<I>): void;
+    weightOf(subject: I): number;
+}

package/dist/handle.js

@@ -0,0 +1,56 @@
+import { retime } from './clock.js';
+/** A voice's handle: the host's only way to control a voice once cued. */
+export class VoiceHandle {
+    id;
+    #voice;
+    #host;
+    constructor(voice, host) {
+        this.id = voice.id;
+        this.#voice = voice;
+        this.#host = host;
+    }
+    get state() {
+        return this.#voice.state;
+    }
+    get owner() {
+        return this.#voice.owner?.handle ?? undefined;
+    }
+    get played() {
+        return this.#voice.played;
+    }
+    get done() {
+        return this.#voice.done;
+    }
+    get weight() {
+        return this.#voice.weight;
+    }
+    set weight(w) {
+        this.#voice.weight = w;
+        this.#host.changed(this.#voice);
+    }
+    get rate() {
+        return this.#voice.rateAt(this.#host.nowFor(this.#voice));
+    }
+    set rate(r) {
+        this.ramp(r, 0);
+    }
+    ramp(r, over) {
+        const voice = this.#voice;
+        retime(voice, this.#host.nowFor(voice), r, over);
+        this.#host.changed(voice);
+    }
+    seek(elapsed) {
+        const voice = this.#voice;
+        voice.rebase(this.#host.nowFor(voice));
+        voice.anchorElapsed = elapsed;
+        voice.seeks++;
+        this.#host.sought(voice);
+        this.#host.changed(voice);
+    }
+    fade(opts) {
+        this.#host.fade(this.#voice, opts);
+    }
+    weightOf(subject) {
+        return this.#host.weightOf(this.#voice, subject);
+    }
+}

package/dist/held.d.ts

@@ -0,0 +1,14 @@
+import type { Mixer } from './mixer.js';
+import type { Subject, Voice } from './voice.js';
+/** The record a voice gives every subject it does not reach. */
+export declare function unreachedOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number): Subject<unknown>;
+/** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
+export declare function held<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, slot: number): Subject<unknown>;
+/**
+ * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
+ * the rate it is ramping to.
+ */
+export declare function sinceOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, delay: number): number;
+export declare function shownOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, since: number): number;
+/** A voice has gone live: the records it made while pending count from where it started. */
+export declare function started<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;

package/dist/held.js

@@ -0,0 +1,117 @@
+import { schedule } from './due.js';
+import { mixTime } from './owner.js';
+import { unreach, unreached } from './unreached.js';
+/** The record a voice gives every subject it does not reach. */
+export function unreachedOf(voice, now) {
+    const since = this.sinceOf(voice, 0);
+    const none = {
+        reaches: false,
+        delay: 0,
+        since,
+        shown: this.shownOf(voice, since),
+        weight: 0,
+        rested: false,
+        bands: null,
+        state: undefined,
+        stepped: now,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        kept: null,
+        voice,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+    };
+    voice.unreached = none;
+    return none;
+}
+/** What this voice holds for this subject, made on first sight with `target` and `stagger` asked once. */
+export function held(voice, subject, now, slot) {
+    if (unreached(voice, slot))
+        return voice.unreached;
+    let held = voice.subjects.get(subject);
+    if (held !== undefined)
+        return held;
+    const reaches = this.aims(voice, subject);
+    if (!reaches) {
+        // Nothing is kept for a subject the voice does not reach, so one record stands for them all:
+        // a voice per subject reached by `target` held one per subject it was asked about. Where lanes
+        // number the subject, a bit by its number says so, where a map entry each grew with voices
+        // times subjects.
+        const none = voice.unreached ?? this.unreachedOf(voice, now);
+        if (slot >= 0 && voice.named === null)
+            unreach(voice, slot, true);
+        else
+            voice.subjects.set(subject, none);
+        return none;
+    }
+    const delay = voice.spec.stagger ? voice.spec.stagger(subject) : 0;
+    const since = this.sinceOf(voice, delay);
+    held = {
+        reaches: true,
+        delay,
+        since,
+        shown: this.shownOf(voice, since),
+        weight: 0,
+        rested: false,
+        bands: null,
+        state: voice.patch.state ? voice.patch.state(subject) : undefined,
+        stepped: this.backward && since < now ? since : now,
+        ticks: 0,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        kept: null,
+        voice,
+        next: null,
+        version: Number.NaN,
+        loci: null,
+        slot: -1,
+    };
+    if (this.projecting) {
+        held.from = held.stepped;
+        held.unknown = this.backward && voice.spec.from === 'current';
+    }
+    voice.subjects.set(subject, held);
+    if (voice.state === 'pending') {
+        voice.early ??= [];
+        voice.early.push(held);
+    }
+    voice.seen++;
+    if (delay > voice.latest) {
+        voice.latest = delay;
+        // A later end can take a frozen voice live again.
+        if (voice.state === 'frozen')
+            schedule(this, voice);
+    }
+    return held;
+}
+/**
+ * When the voice clock reads `delay`, from where it is anchored now; during a ramp this assumes
+ * the rate it is ramping to.
+ */
+export function sinceOf(voice, delay) {
+    const t = voice.rate > 0
+        ? voice.anchorNow + (delay - voice.anchorElapsed) / voice.rate
+        : voice.start + delay;
+    return voice.owner === null ? t : mixTime(voice.owner, t);
+}
+export function shownOf(voice, since) {
+    return voice.freezesBefore && voice.opened < since ? voice.opened : since;
+}
+/** A voice has gone live: the records it made while pending count from where it started. */
+export function started(mix, voice) {
+    const early = voice.early;
+    if (early === null)
+        return;
+    voice.early = null;
+    for (const held of early) {
+        held.since = mix.sinceOf(voice, held.delay);
+        held.shown = mix.shownOf(voice, held.since);
+    }
+}

package/dist/history.d.ts

@@ -0,0 +1,22 @@
+import type { Mixer } from './mixer.js';
+import { type Subject, type Voice } from './voice.js';
+/**
+ * The last entry taken before `t`, or at it where `inclusive` says so, as it does for a change a
+ * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
+ * it did live.
+ */
+export declare function last<T extends {
+    at: number;
+}>(list: readonly T[], t: number, inclusive: boolean | ((e: T) => boolean)): T | undefined;
+/** A voice's elapsed at an earlier mix time, by the controls it had then. */
+export declare function elapsedThen<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>, t: number): number;
+/** Records a change to a voice's controls under `history`, and lets go of what it no longer reaches. */
+export declare function noted<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+/** A copy of a subject's record that shares nothing a read could change. */
+export declare function copyHeld<I, O>(voice: Voice<I, O>, h: Subject<unknown>): 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;
+/** 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;

package/dist/history.js

@@ -0,0 +1,149 @@
+import { elapsedWith } from './clock.js';
+import { clone } from './clone.js';
+import { schedule } from './due.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
+ * sync made. A host's change between frames is taken strictly: it shows from the next frame on, as
+ * it did live.
+ */
+export function last(list, t, inclusive) {
+    let lo = 0;
+    let hi = list.length - 1;
+    let found;
+    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;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return found;
+}
+/** Deep equality over plain data, for telling whether a host field changed. */
+function same(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    for (const k of ka)
+        if (!same(a[k], b[k]))
+            return false;
+    return true;
+}
+/** A voice's elapsed at an earlier mix time, by the controls it had then. */
+export function elapsedThen(mix, voice, t) {
+    const log = voice.log;
+    const c = log === null ? undefined : last(log, t, true);
+    return elapsedWith(c ?? voice, voice.owner === null ? t : ownerThen(mix, voice.owner, t));
+}
+/** What an owner's clock read at an earlier mix time; apart, so `elapsedThen` stays small. */
+function ownerThen(mix, owner, t) {
+    return elapsedThen(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) {
+    mix.stir();
+    schedule(mix, voice);
+    const log = voice.log;
+    if (log === null)
+        return;
+    voice.note(Number.isNaN(mix.now) ? Number.NEGATIVE_INFINITY : mix.now, mix.moving);
+    const reach = mix.now - mix.opts.history.ms;
+    let drop = 0;
+    while (drop + 1 < log.length && log[drop + 1].at <= reach)
+        drop++;
+    if (drop > 0)
+        log.splice(0, drop);
+}
+/** 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));
+    }
+    const patch = voice.patch;
+    return {
+        ...h,
+        bands: h.bands === null ? null : h.bands.slice(),
+        state: h.state === undefined ? undefined : patch.clone ? patch.clone(h.state) : clone(h.state),
+        kept,
+        probed: Number.NaN,
+        delta: null,
+        phase: 0,
+        seeks: 0,
+        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,
+    };
+}
+/** Under `history` with `inputs`, copies the host fields any voice reads, once a frame, when they changed. */
+export function recordHost(mix, now) {
+    const log = mix.hostLog;
+    const prev = log[log.length - 1];
+    if (prev !== undefined && prev.at === now)
+        return;
+    const host = mix.opts.host;
+    const fields = {};
+    for (const v of mix.cued)
+        for (const f of v.patch.reads ?? none)
+            if (!(f in fields))
+                fields[f] = clone(host[f]);
+    if (prev !== undefined && same(prev.fields, fields))
+        return;
+    log.push({ at: now, fields });
+    const reach = now - mix.opts.history.ms;
+    while (log.length > 1 && log[1].at <= reach)
+        log.shift();
+}
+/** Under `history` with `inputs`, keeps what an input signal read, each time it changes. */
+export function record(mix, held, value) {
+    const history = mix.opts.history;
+    if (!history?.inputs || mix.projecting)
+        return;
+    const inputs = held.inputs ?? [];
+    held.inputs = inputs;
+    const prev = inputs[inputs.length - 1];
+    if (prev !== undefined && (prev.value === value || prev.at === mix.now)) {
+        if (prev.at === mix.now)
+            prev.value = value;
+        return;
+    }
+    inputs.push({ at: mix.now, value });
+    const reach = mix.now - history.ms;
+    while (inputs.length > 1 && inputs[1].at <= reach)
+        inputs.shift();
+}
+/** Under `history`, keeps a copy of a stateful voice's record for this subject every so often. */
+export function remember(mix, voice, held) {
+    const history = mix.opts.history;
+    if (!history || mix.projecting)
+        return;
+    if (voice.patch.step === undefined &&
+        (held.kept === null || held.kept.size === 0) &&
+        held.base === undefined)
+        return;
+    const snaps = held.snaps ?? [];
+    held.snaps = snaps;
+    const prev = snaps[snaps.length - 1];
+    if (prev !== undefined && mix.now - prev.at < (history.every ?? 200))
+        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();
+}

package/dist/hosts.d.ts

@@ -0,0 +1,16 @@
+import type { LaneHost } from './lanes.js';
+import type { Mixer } from './mixer.js';
+import type { Booker, BookOptions, Handle } from './types.js';
+import type { Voice } from './voice.js';
+export declare function book<I, O>(mix: Mixer<I, O>, opts: BookOptions): Booker;
+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.
+ */
+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. */
+export declare function stateful<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): void;
+export declare function handle<I, O>(mix: Mixer<I, O>, voice: Voice<I, O>): Handle<I>;

package/dist/hosts.js

@@ -0,0 +1,178 @@
+import { Book } from './book.js';
+import { schedule } from './due.js';
+import { beginFade, fadeSubject } from './fade.js';
+import { VoiceHandle } from './handle.js';
+import { noted, remember } from './history.js';
+import { hostOf, listed, markOf, readingAt } from './marks.js';
+import { nextFrame } from './move.js';
+import { descendants, ownWeight, signalled } from './owner.js';
+import { localNow } from './place.js';
+import { reading } from './reading.js';
+import { unreach } from './unreached.js';
+export function book(mix, opts) {
+    if (mix.projecting)
+        throw new Error('blits: a projection books nothing');
+    const host = {
+        get voices() {
+            return mix.cued;
+        },
+        get timestamp() {
+            return mix.last;
+        },
+        get now() {
+            return mix.now;
+        },
+        hostOf: (t) => hostOf(mix, t),
+        readingAt: (timestamp) => readingAt(mix, timestamp - mix.offset),
+        endOf: (voice) => markOf(mix, voice, 'end'),
+        marks: (from, to) => listed(mix, from, to),
+        unhook: (b) => {
+            const left = (mix.bookers ?? []).filter((x) => x !== b);
+            mix.bookers = left.length === 0 ? null : left;
+        },
+    };
+    const b = new Book(host, opts);
+    mix.bookers = [...(mix.bookers ?? []), b];
+    return b;
+}
+export function laneHost(mix) {
+    return {
+        get voices() {
+            return mix.cued;
+        },
+        channels: mix.channels,
+        names: mix.names,
+        fits: (voice) => fits(mix, voice),
+        meet: (voice, subject, head, slot) => {
+            for (let held = head; held !== null; held = held.next)
+                if (held.voice === voice)
+                    return held;
+            return mix.held(voice, subject, mix.now, slot);
+        },
+        forgot: (slot) => {
+            // 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)
+                unreach(voice, slot, false);
+        },
+        naming: (subject) => (mix.naming === 0 ? undefined : mix.named.get(subject)),
+        slotOf: (subject) => mix.chains.get(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;
+            mix.sending.voice = voice;
+            mix.sending.subject = subject;
+        },
+        signal: (voice, subject, held, elapsed, pass, slot) => {
+            // 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);
+            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;
+        },
+        horizon: (voice, delay) => {
+            reading.horizon = mix.horizonFor(voice, delay, mix.now);
+        },
+        keeps: mix.opts.history !== undefined,
+        after: (voice, held) => remember(mix, voice, 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.
+ */
+export function fits(mix, voice) {
+    const spec = voice.spec;
+    const patch = voice.patch;
+    if (voice.keeping)
+        return false;
+    if (voice.state === 'pending' && voice.freezesBefore)
+        return false;
+    // A fill weighs a voice's owners once for every subject, which a signal on one would not be.
+    if (voice.owner !== null && signalled(voice))
+        return false;
+    // A signal reading host input records it per probe under history, which a fill cannot.
+    if (typeof spec.weight === 'function' && spec.weight.input && mix.opts.history?.inputs)
+        return false;
+    // A locus on lanes gathers keys and fn members; a motion member keeps it on the general path.
+    if (spec.locus !== undefined && voice.motion !== undefined)
+        return false;
+    if (spec.from === 'current')
+        return false;
+    if (voice.out?.rest)
+        return false;
+    if (patch.state !== undefined || patch.step !== undefined)
+        return false;
+    if (mix.opts.history?.inputs && patch.reads !== undefined && patch.reads.length > 0)
+        return false;
+    const built = voice.built;
+    return (built === null ||
+        built.tracks.every((t, i) => t.lerp === undefined || t.lerp === voice.lerps[i]));
+}
+/** A voice's patch kept state on a record: it is stateful from now on. */
+export function stateful(mix, voice) {
+    if (voice.keeping)
+        return;
+    voice.keeping = true;
+    mix.lanes?.invalidate();
+}
+export function handle(mix, voice) {
+    mix.handles ??= handleHost(mix);
+    return new VoiceHandle(voice, mix.handles);
+}
+function handleHost(mix) {
+    return {
+        nowFor: (voice) => {
+            if (Number.isNaN(mix.now))
+                return voice.start;
+            const local = localNow(mix, voice);
+            return Number.isFinite(local) ? local : voice.start;
+        },
+        changed: (voice) => {
+            mix.frame = nextFrame();
+            noted(mix, voice);
+            mix.lanes?.refill();
+        },
+        // A delta read before an owner's seek, or a hit booked, is not taken as standing after it.
+        sought: (voice) => {
+            if (voice.holding !== null)
+                descendants(voice, (v) => {
+                    v.seeks++;
+                    schedule(mix, v);
+                });
+        },
+        fade: (voice, opts) => {
+            if (voice.holding !== null && opts !== undefined && ('subject' in opts || opts.at === 'rest'))
+                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
+                beginFade(mix, voice, opts ?? {});
+        },
+        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));
+            if (voice.laned && mix.lanes !== null) {
+                const w = mix.lanes.weightOf(voice.id, mix.chains.get(subject)?.slot ?? -1);
+                if (w !== undefined)
+                    return w;
+            }
+            return voice.subjects.get(subject)?.weight ?? 0;
+        },
+    };
+}

package/dist/index.d.ts

@@ -6,4 +6,6 @@ export { glide, spring, tween } from './motion.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 { Anchor, Channel, Columns, Doubt, Easing, Engine, FadeOptions, FadeSpec, Handle, Keyframe, Kit, Mark, Marked, Mix, MixOptions, MotionSpec, Patch, Placement, Projection, Query, Sent, Setting, Signal, VoiceSpec, } from './types.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';

package/dist/index.js

@@ -3,3 +3,4 @@ export { mix, mixer } from './mixer.js';
 export { glide, spring, tween } from './motion.js';
 export { keys, patch } from './patch.js';
 export { gate, lag, level, peak, slew } from './signals.js';
+export { ticker } from './ticker.js';

package/dist/keyrows.d.ts

@@ -0,0 +1,36 @@
+import { type Numeric } from './channels.js';
+import type { Curve } from './easing.js';
+import { type Built } from './patch.js';
+/** What a keys row folds into: a laned channel's arithmetic, axes, rest and values. */
+export interface KeyChannel {
+    scalar: boolean;
+    op: Numeric['op'];
+    rest: number;
+    axes: number;
+    values: Float64Array;
+}
+/**
+ * The stops of a crowd's `keys` rows, copied into one array as a row joins, so a fill reads each
+ * row's stops in place rather than through its voice, its built tracks and every stop's own array.
+ * Per row: its header, then per track its stop count, its delay, and per stop its phase and its
+ * value on each of the channel's axes, a missing axis read as rest as `vec`'s lerp reads it. Each
+ * stop's easing is in `eases`.
+ */
+export declare class KeyRows {
+    data: Float64Array<ArrayBuffer>;
+    used: number;
+    eases: (Curve | undefined)[];
+    /**
+     * Copies a voice's stops for channels `chans` and returns the row's offset; -1 where a stop's
+     * value is not one a lane folds as a number per axis, so the row reads its voice's stops instead.
+     */
+    add(built: Built, chans: readonly KeyChannel[]): number;
+    /** Copies another pool's row at `off` into this one, returning its offset here. */
+    copy(from: KeyRows, off: number): number;
+    /**
+     * Folds the row at `off` at `phase` into subject `slot`'s values at weight `w`: what `segment`
+     * and the stock lerp and fold give for each track, read from this pool.
+     */
+    fold(off: number, phase: number, chans: readonly KeyChannel[], slot: number, w: number): void;
+    private reserve;
+}