@msb235/blits 0.3.0 → 0.5.0

package/dist/voice.d.ts

@@ -0,0 +1,240 @@
+import type { Blend } from './blend.js';
+import { type Clock } from './clock.js';
+import { type Curve } from './easing.js';
+import { type Motions } from './motion.js';
+import { Named } from './named.js';
+import { Holding } from './owner.js';
+import { type Built, intosOf, type Scratch } from './patch.js';
+import { Store } from './store.js';
+import type { Channel, FadeSpec, Handle, Patch, Setting, VoiceSpec } from './types.js';
+export declare const none: readonly string[];
+/** Everything one voice holds for one subject, chained through the next voice that reaches it. */
+export interface Subject<S> {
+    /** The voice's `target` answer, fixed on first sight. */
+    reaches: boolean;
+    /** The voice's `stagger` answer in voice ms, fixed on first sight. */
+    delay: number;
+    /** The mix timestamp this subject's delay ran out at, which its step grid counts from. */
+    since: number;
+    /** The mix timestamp its fade in counts from: `since`, or earlier for a voice holding before. */
+    shown: number;
+    /** The weight this voice gave this subject the last frame it was probed, 0 where it gave none. */
+    weight: number;
+    /** Left at rest during a handover, so it stops contributing. */
+    rested: boolean;
+    /**
+     * Per written channel, whether a rest-less influence is on: 0 unknown, 1 on, 2 off; null until
+     * a rest-less channel asks.
+     */
+    bands: Uint8Array | null;
+    state: S;
+    /** The `now` this subject last caught up to, for this voice. */
+    stepped: number;
+    /** Under `stepMs`, how many intervals have run since `since`; `stepped` is where that lands. */
+    ticks: number;
+    /** The `now` this subject was last probed at, so twelve probes in a frame step once. */
+    probed: number;
+    /** The last delta computed this frame, handed back to a repeat probe unchanged. */
+    delta: Record<string, unknown> | null;
+    /** The phase `delta` was read at, to read it again once its voice's scratch has moved on. */
+    phase: number;
+    /** The voice's `seeks` when `delta` was read, so a seek later in the frame reads it again. */
+    seeks: number;
+    /** Stop 0 for a `from: 'current'` voice, taken the first frame this subject is seen. */
+    base?: Record<string, unknown>;
+    /** The pose's velocity per channel at that moment, units per ms, so the first segment leaves at it. */
+    slope?: Record<string, unknown>;
+    /** What `setting.keep` holds for this voice and subject, by owner; null until it holds any. */
+    kept: Map<object, unknown> | null;
+    /** Under `history`, copies of this record by the mix time they were taken, oldest first. */
+    snaps?: {
+        at: number;
+        held: Subject<S>;
+    }[];
+    /** In a projection: where this record started from, and whether nothing known could be. */
+    from?: number;
+    unknown?: boolean;
+    /** Under `history` with `inputs`, what an input weight signal read for this subject, when it changed. */
+    inputs?: {
+        at: number;
+        value: number;
+    }[];
+    /** In a projection reading back: that record, to read in place of the signal. */
+    replay?: {
+        at: number;
+        value: number;
+    }[];
+    /** The voice this is the record of; null on a subject's stub. */
+    voice: object | null;
+    /** The next voice's record for this subject, in voice order, among those that reach it. */
+    next: Subject<unknown> | null;
+    /**
+     * On the first record, which the mix keeps per subject so a probe makes one lookup: the `version`
+     * the chain was linked at, and per locus, by channel slot, whether a rest-less influence is on:
+     * 0 never decided, 1 on, 2 off.
+     */
+    version: number;
+    loci: Map<string, Uint8Array> | null;
+    /** On the first record: the number lanes index this subject by, -1 without one. */
+    slot: number;
+}
+/** A voice's clock, weight and fade from one mix time on, kept under `history`. */
+export interface Controls extends Clock {
+    at: number;
+    weight: number;
+    out: Ramp | null;
+    /** Where its anchors had placed it then: start, and the start of an anchored fade out. */
+    start: number;
+    outAt: number;
+    /** Made by a sync, so it shows in that frame; a host's change between frames shows from the next. */
+    sync: boolean;
+}
+export interface Ramp {
+    from: number;
+    at: number;
+    over: number;
+    rest: boolean;
+    deadline?: number;
+}
+export declare class Voice<I, O> {
+    readonly id: number;
+    readonly spec: VoiceSpec<I, O>;
+    readonly patch: Patch<I, O, unknown>;
+    readonly fade: FadeSpec;
+    start: number;
+    /** The owner whose clock it runs on, its start included; null for one on the mix clock. */
+    owner: Voice<I, O> | null;
+    state: 'pending' | 'live' | 'held' | 'fading' | 'done';
+    rate: number;
+    weight: number;
+    /**
+     * elapsed = anchorElapsed + the rate integrated from anchorNow, rebased on a rate change or a seek.
+     * Without a ramp the rate is constant; with one it moves linearly from `from` to `to` over `over`
+     * mix ms starting at the anchor, and holds `to` after.
+     */
+    anchorNow: number;
+    anchorElapsed: number;
+    ramp: {
+        from: number;
+        to: number;
+        over: number;
+    } | null;
+    out: Ramp | null;
+    readonly subjects: Store<I, Subject<unknown>>;
+    /** The subjects its spec names, or null where it names none. */
+    readonly named: Named<I> | null;
+    /** Kit slot of each channel the patch writes, in `writes` order. */
+    readonly slots: number[];
+    /** The stops built ahead of time, for a `keys` patch. */
+    readonly built: Built | null;
+    /** The kit's `lerp` for each channel the patch writes, which keyed stops interpolate through. */
+    readonly lerps: Channel<unknown>['lerp'][];
+    /** Per keyed channel, the in-place form of the lerp its stops take, where it has one. */
+    readonly intos: ReturnType<typeof intosOf> | undefined;
+    /**
+     * The arrays keyed reads interpolate into: one set for the voice, not one per subject, since 10k
+     * subjects' worth of long-lived arrays costs more in cache misses than allocating them did.
+     */
+    scratch: Scratch;
+    /** The record whose delta holds `scratch`'s arrays; any other's must be read again to be handed out. */
+    holder: Subject<unknown> | null;
+    /** Whether its channels run as lanes this frame, so the general fold passes it by. */
+    laned: boolean;
+    /** How many times it has been sought, so a delta read before a seek is not handed out after it. */
+    seeks: number;
+    /** Whether its patch has kept state on a record through `setting.keep`, which makes it stateful. */
+    keeping: boolean;
+    /** Subjects fading out of this voice alone, by the ramp each started; null while none are. */
+    parts: Map<I, {
+        at: number;
+        over: number;
+    }> | null;
+    /** Subjects faded out of this voice, by the mix time each left at; null while none have. */
+    parted: Map<I, number> | null;
+    readonly ease: Curve | undefined;
+    /** How many passes its `loop` plays, worked out once. */
+    readonly passes: number;
+    readonly duration: number;
+    /** Voice ms its passes last, Infinity for a patch with no passes or a loop for good. */
+    readonly span: number;
+    /** The state behind a motion patch, undefined for any other. */
+    readonly motion: Motions<I> | undefined;
+    /** Its `hold`, for a patch it applies to: motion holds its target already. */
+    readonly holdsBefore: boolean;
+    readonly holdsAfter: boolean;
+    /** The mix time it first showed: when it was cued, or the first sync after. */
+    opened: number;
+    /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */
+    dueToken: number;
+    /** Records made while it was pending, whose `since` its start may since have moved. */
+    early: Subject<unknown>[] | null;
+    /** Reused for every call this voice makes, so it is valid only during the call. */
+    readonly setting: Setting<unknown>;
+    /** Every subject this voice has been asked about, so a handover knows when it is finished. */
+    seen: number;
+    /** The longest stagger of any subject seen, so a finite loop waits for the last of them. */
+    latest: number;
+    restedCount: number;
+    /** The mix time it was cued at; -Infinity before the first sync. */
+    cuedAt: number;
+    /** The mix time it left at. */
+    doneAt: number;
+    /** Under `history`, its controls after each change, oldest first. */
+    log: Controls[] | null;
+    /** Where an anchored `out` or `end` puts its fade's start, mix time; Infinity until known. */
+    outAt: number;
+    /** Whether its start is still to be fixed by an anchor, so it waits pending. */
+    placing: boolean;
+    /** The record `setting.keep` writes to: the one its patch or signal is being called for. */
+    keepOn: Subject<unknown> | null;
+    /** What `setting.keep` holds when called before any record is. */
+    ownKept: Map<object, unknown> | null;
+    /** The blend it is a member of, and which. */
+    blend: {
+        of: Blend<I, O>;
+        i: number;
+    } | null;
+    /** The one record of every subject it does not reach. */
+    unreached: Subject<unknown> | null;
+    /** By subject number, a bit set where `unreached` stands for the subject; null until one is. */
+    unreachedBits: Uint32Array | null;
+    /** The handle `cue` returned, which `voices` hands back too. */
+    handle: Handle<I> | null;
+    /** For an owner, the voices it holds; null for any other voice. */
+    holding: Holding<Voice<I, O>> | null;
+    /**
+     * `done` and `played`, made when first asked for, already settled if the voice is: most hosts
+     * never await either, and a mix may hold tens of thousands of voices.
+     */
+    private finished;
+    private playedAs;
+    private donePromise;
+    private doneSettle;
+    private playedPromise;
+    private playedSettle;
+    /** A projection's copy, which settles nothing. */
+    private quiet;
+    get done(): Promise<void>;
+    get played(): Promise<boolean>;
+    /** The voice has left: `done` resolves. */
+    resolve(): void;
+    /** Its finite loop ended (true) or it left first (false), whichever comes first: `played` resolves. */
+    play(played: boolean): void;
+    constructor(id: number, spec: VoiceSpec<I, O>, patch: Patch<I, O, unknown>, fade: FadeSpec, now: number, start: number, slotOf: Map<string, number>, channels: readonly Channel<unknown>[], host: unknown, send: (event: unknown) => void, 
+    /** The owner whose clock it runs on, its start included; null for one on the mix clock. */
+    owner: Voice<I, O> | null);
+    /** What its clock reads at mix time `now`, through its owners' clocks. */
+    elapsedAt(now: number): number;
+    /** The mix time its clock reads `elapsed`, inverting `elapsedAt`; Infinity where it never will. */
+    timeAt(elapsed: number): number;
+    /** Records this voice's controls as they stand, from mix time `at`. */
+    note(at: number, sync?: boolean): void;
+    /**
+     * A copy for a projection: its own setting, which sends nothing, and its own per-subject records,
+     * filled from `fill`. With `controls` it takes those, as the voice stood at an earlier time.
+     */
+    copy(fill: (subject: I) => Subject<unknown> | undefined, controls?: Controls): Voice<I, O>;
+    rateAt(now: number): number;
+    /** Moves the anchor to `now`, carrying what is left of a ramp. */
+    rebase(now: number): void;
+}

package/dist/voice.js

@@ -0,0 +1,322 @@
+import { elapsedWith, passesOf, rateWith, rebaseWith, timeWith } from './clock.js';
+import { curve } from './easing.js';
+import { motionOf } from './motion.js';
+import { Named } from './named.js';
+import { childPlayed, Holding, mixTime, ownedElapsed, ownerPatch } from './owner.js';
+import { builtOf, durationOf, intosOf } from './patch.js';
+import { reading } from './reading.js';
+import { Store } from './store.js';
+export const none = Object.freeze([]);
+/**
+ * A voice's `setting.keep`, one per voice: a setting is valid only during its call, so the state
+ * goes on the record of the subject being called for, `keepOn`, or on the voice before any is.
+ */
+function keeping(voice) {
+    return function keep(owner, init) {
+        const held = voice.keepOn;
+        let kept = held === null ? voice.ownKept : held.kept;
+        if (kept === null) {
+            kept = new Map();
+            if (held === null)
+                voice.ownKept = kept;
+            else
+                held.kept = kept;
+        }
+        if (kept.has(owner))
+            return kept.get(owner);
+        const made = init();
+        kept.set(owner, made);
+        reading.kept++;
+        return made;
+    };
+}
+/**
+ * A voice's setting. `keep` is made on first read: most patches keep no state, and a closure and
+ * its context per voice cost a one-subject tween voice about 100 bytes.
+ */
+class VoiceSetting {
+    host;
+    send;
+    voice;
+    timestamp = 0;
+    dt = 0;
+    elapsed = 0;
+    pass = 0;
+    weight = 0;
+    state = undefined;
+    kept = null;
+    constructor(host, send, voice) {
+        this.host = host;
+        this.send = send;
+        this.voice = voice;
+    }
+    get keep() {
+        if (this.kept === null)
+            this.kept = keeping(this.voice);
+        return this.kept;
+    }
+}
+/** A store that fills a missing entry from `make` on first ask. */
+class Filled extends Store {
+    make;
+    constructor(make) {
+        super();
+        this.make = make;
+    }
+    get(key) {
+        let v = super.get(key);
+        if (v === undefined) {
+            v = this.make(key);
+            if (v !== undefined)
+                super.set(key, v);
+        }
+        return v;
+    }
+}
+const noSend = () => { };
+export class Voice {
+    id;
+    spec;
+    patch;
+    fade;
+    start;
+    owner;
+    state = 'pending';
+    rate;
+    weight;
+    /**
+     * elapsed = anchorElapsed + the rate integrated from anchorNow, rebased on a rate change or a seek.
+     * Without a ramp the rate is constant; with one it moves linearly from `from` to `to` over `over`
+     * mix ms starting at the anchor, and holds `to` after.
+     */
+    anchorNow;
+    anchorElapsed = 0;
+    ramp = null;
+    out = null;
+    subjects = new Store();
+    /** The subjects its spec names, or null where it names none. */
+    named;
+    /** Kit slot of each channel the patch writes, in `writes` order. */
+    slots;
+    /** The stops built ahead of time, for a `keys` patch. */
+    built;
+    /** The kit's `lerp` for each channel the patch writes, which keyed stops interpolate through. */
+    lerps;
+    /** Per keyed channel, the in-place form of the lerp its stops take, where it has one. */
+    intos;
+    /**
+     * The arrays keyed reads interpolate into: one set for the voice, not one per subject, since 10k
+     * subjects' worth of long-lived arrays costs more in cache misses than allocating them did.
+     */
+    scratch = [];
+    /** The record whose delta holds `scratch`'s arrays; any other's must be read again to be handed out. */
+    holder = null;
+    /** Whether its channels run as lanes this frame, so the general fold passes it by. */
+    laned = false;
+    /** How many times it has been sought, so a delta read before a seek is not handed out after it. */
+    seeks = 0;
+    /** Whether its patch has kept state on a record through `setting.keep`, which makes it stateful. */
+    keeping = false;
+    /** Subjects fading out of this voice alone, by the ramp each started; null while none are. */
+    parts = null;
+    /** Subjects faded out of this voice, by the mix time each left at; null while none have. */
+    parted = null;
+    ease;
+    /** How many passes its `loop` plays, worked out once. */
+    passes;
+    duration;
+    /** Voice ms its passes last, Infinity for a patch with no passes or a loop for good. */
+    span;
+    /** The state behind a motion patch, undefined for any other. */
+    motion;
+    /** Its `hold`, for a patch it applies to: motion holds its target already. */
+    holdsBefore;
+    holdsAfter;
+    /** The mix time it first showed: when it was cued, or the first sync after. */
+    opened = Number.NaN;
+    /** Which of its entries in the mix's due queue is current; older ones are skipped when popped. */
+    dueToken = 0;
+    /** Records made while it was pending, whose `since` its start may since have moved. */
+    early = null;
+    /** Reused for every call this voice makes, so it is valid only during the call. */
+    setting;
+    /** Every subject this voice has been asked about, so a handover knows when it is finished. */
+    seen = 0;
+    /** The longest stagger of any subject seen, so a finite loop waits for the last of them. */
+    latest = 0;
+    restedCount = 0;
+    /** The mix time it was cued at; -Infinity before the first sync. */
+    cuedAt = Number.NEGATIVE_INFINITY;
+    /** The mix time it left at. */
+    doneAt = Number.POSITIVE_INFINITY;
+    /** Under `history`, its controls after each change, oldest first. */
+    log = null;
+    /** Where an anchored `out` or `end` puts its fade's start, mix time; Infinity until known. */
+    outAt = Number.POSITIVE_INFINITY;
+    /** Whether its start is still to be fixed by an anchor, so it waits pending. */
+    placing = false;
+    /** The record `setting.keep` writes to: the one its patch or signal is being called for. */
+    keepOn = null;
+    /** What `setting.keep` holds when called before any record is. */
+    ownKept = null;
+    /** The blend it is a member of, and which. */
+    blend = null;
+    /** The one record of every subject it does not reach. */
+    unreached = null;
+    /** By subject number, a bit set where `unreached` stands for the subject; null until one is. */
+    unreachedBits = null;
+    /** The handle `cue` returned, which `voices` hands back too. */
+    handle = null;
+    /** For an owner, the voices it holds; null for any other voice. */
+    holding;
+    /**
+     * `done` and `played`, made when first asked for, already settled if the voice is: most hosts
+     * never await either, and a mix may hold tens of thousands of voices.
+     */
+    finished = false;
+    playedAs = undefined;
+    donePromise = null;
+    doneSettle = null;
+    playedPromise = null;
+    playedSettle = null;
+    /** A projection's copy, which settles nothing. */
+    quiet = false;
+    get done() {
+        if (this.donePromise === null)
+            this.donePromise = this.finished
+                ? Promise.resolve()
+                : new Promise((r) => {
+                    this.doneSettle = r;
+                });
+        return this.donePromise;
+    }
+    get played() {
+        if (this.playedPromise === null) {
+            const as = this.playedAs;
+            this.playedPromise =
+                as !== undefined
+                    ? Promise.resolve(as)
+                    : new Promise((r) => {
+                        this.playedSettle = r;
+                    });
+        }
+        return this.playedPromise;
+    }
+    /** The voice has left: `done` resolves. */
+    resolve() {
+        if (this.quiet || this.finished)
+            return;
+        this.finished = true;
+        this.doneSettle?.();
+    }
+    /** Its finite loop ended (true) or it left first (false), whichever comes first: `played` resolves. */
+    play(played) {
+        if (this.quiet || this.playedAs !== undefined)
+            return;
+        this.playedAs = played;
+        this.playedSettle?.(played);
+        if (played && this.owner !== null)
+            childPlayed(this.owner);
+    }
+    constructor(id, spec, patch, fade, now, start, slotOf, channels, host, send, 
+    /** The owner whose clock it runs on, its start included; null for one on the mix clock. */
+    owner) {
+        this.id = id;
+        this.spec = spec;
+        this.patch = patch;
+        this.fade = fade;
+        this.start = start;
+        this.owner = owner;
+        this.holding = patch === ownerPatch ? new Holding() : null;
+        this.slots = patch.writes.map((k) => slotOf.get(k));
+        this.named = spec.subjects ? new Named(spec.subjects) : null;
+        this.built = patch.form === 'keys' && patch.keys ? builtOf(patch) : null;
+        this.lerps = this.slots.map((slot) => channels[slot].lerp);
+        this.intos = this.built
+            ? intosOf(this.built, this.slots.map((slot) => channels[slot]))
+            : undefined;
+        this.ease = fade.ease === undefined ? undefined : curve(fade.ease);
+        this.passes = passesOf(spec.loop);
+        this.duration = durationOf(patch);
+        this.span =
+            this.duration > 0 && Number.isFinite(this.passes)
+                ? this.duration * this.passes
+                : Number.POSITIVE_INFINITY;
+        this.motion = motionOf(patch);
+        const holds = this.motion === undefined ? spec.hold : undefined;
+        // A voice with no hold of its own takes its owner's.
+        const inherits = holds === undefined && this.motion === undefined && owner !== null;
+        this.holdsBefore = inherits ? owner.holdsBefore : holds === 'before' || holds === 'both';
+        this.holdsAfter = inherits ? owner.holdsAfter : holds === 'after' || holds === 'both';
+        this.setting = new VoiceSetting(host, send, this);
+        this.rate = spec.rate ?? 1;
+        this.weight = typeof spec.weight === 'number' ? spec.weight : 1;
+        this.anchorNow = start;
+        if (now >= start)
+            this.state = 'live';
+    }
+    /** What its clock reads at mix time `now`, through its owners' clocks. */
+    elapsedAt(now) {
+        return this.owner === null ? elapsedWith(this, now) : ownedElapsed(this, this.owner, now);
+    }
+    /** The mix time its clock reads `elapsed`, inverting `elapsedAt`; Infinity where it never will. */
+    timeAt(elapsed) {
+        const t = timeWith(this, elapsed);
+        return this.owner === null ? t : mixTime(this.owner, t);
+    }
+    /** Records this voice's controls as they stand, from mix time `at`. */
+    note(at, sync = false) {
+        this.log?.push({
+            at,
+            sync,
+            anchorNow: this.anchorNow,
+            anchorElapsed: this.anchorElapsed,
+            rate: this.rate,
+            ramp: this.ramp,
+            weight: this.weight,
+            out: this.out,
+            start: this.start,
+            outAt: this.outAt,
+        });
+    }
+    /**
+     * A copy for a projection: its own setting, which sends nothing, and its own per-subject records,
+     * filled from `fill`. With `controls` it takes those, as the voice stood at an earlier time.
+     */
+    copy(fill, controls) {
+        // A literal keeps the copy in fast mode, where `Object.assign` left it a dictionary that every
+        // read in a projection looked up by name.
+        const v = { __proto__: Voice.prototype, ...this };
+        const w = v;
+        w.subjects = new Filled(fill);
+        w.setting = { ...this.setting, keep: keeping(v), send: noSend };
+        v.keepOn = null;
+        v.ownKept = null;
+        v.scratch = [];
+        v.holder = null;
+        v.laned = false;
+        v.log = null;
+        v.early = null;
+        if (controls) {
+            v.anchorNow = controls.anchorNow;
+            v.anchorElapsed = controls.anchorElapsed;
+            v.rate = controls.rate;
+            v.ramp = controls.ramp;
+            v.weight = controls.weight;
+            v.out = controls.out;
+            v.start = controls.start;
+            v.outAt = controls.outAt;
+        }
+        v.quiet = true;
+        v.unreached = null;
+        v.unreachedBits = null;
+        return v;
+    }
+    rateAt(now) {
+        return rateWith(this, now);
+    }
+    /** Moves the anchor to `now`, carrying what is left of a ramp. */
+    rebase(now) {
+        rebaseWith(this, now);
+    }
+}

package/dist/weigh.d.ts

@@ -0,0 +1,26 @@
+import type { Mixer } from './mixer.js';
+import type { Subject, Voice } from './voice.js';
+/** Fills a voice's setting for a call to its patch, the weight aside. */
+export declare function prime<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, held: Subject<unknown>, now: number, elapsed: number, pass: number): void;
+/** A gap as a `dt`: Infinity under reduced motion, and no more than `maxDt`. */
+export declare function capped<I, O>(this: Mixer<I, O>, gap: number): number;
+/** The earliest voice time a read may still ask for, for a subject delayed `delay`. */
+export declare function horizonFor<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, delay: number, now: number): number;
+/** The ramp a voice's own fade envelope applies this frame, 0..1. */
+export declare function fadeOf<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, now: number, since: number): number;
+/** What every owner above a voice multiplies into its weight for a subject this frame. */
+export declare function ownedBy<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I): number;
+/**
+ * An owner's signal read for a subject, once a frame: kept on the owner's record for it, which
+ * no fold links, in `phase`, with the frame it was read in `probed`.
+ */
+export declare function ownerBase<I, O>(this: Mixer<I, O>, owner: Voice<I, O>, subject: I): number;
+/** The weight a voice gives a subject this frame, with the setting already filled in. */
+export declare function weigh<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): number;
+/** `weigh` for a voice an owner holds, its owners' weight folded into its fade. */
+export declare function weighOwned<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>): number;
+/**
+ * A voice's weight for a subject before its fade and ramp: its signal's, or its own number.
+ * `slot` is the subject's number when lanes ask.
+ */
+export declare function base<I, O>(this: Mixer<I, O>, voice: Voice<I, O>, subject: I, now: number, held: Subject<unknown>, slot?: number): number;

package/dist/weigh.js

@@ -0,0 +1,89 @@
+import { envelope, weighed } from './clock.js';
+import { elapsedThen, last, record } from './history.js';
+import { ownersWeight } from './owner.js';
+import { reading } from './reading.js';
+/** Fills a voice's setting for a call to its patch, the weight aside. */
+export function prime(voice, held, now, elapsed, pass) {
+    const setting = voice.setting;
+    setting.timestamp = now;
+    setting.dt = this.capped(now - held.stepped);
+    setting.elapsed = elapsed;
+    setting.pass = pass;
+    setting.weight = 0;
+    setting.state = held.state;
+    voice.keepOn = held;
+}
+/** A gap as a `dt`: Infinity under reduced motion, and no more than `maxDt`. */
+export function capped(gap) {
+    const cap = this.opts.maxDt;
+    return this.reducedNow ? Number.POSITIVE_INFINITY : cap !== undefined && gap > cap ? cap : gap;
+}
+/** The earliest voice time a read may still ask for, for a subject delayed `delay`. */
+export function horizonFor(voice, delay, now) {
+    const history = this.opts.history;
+    return history === undefined
+        ? Number.POSITIVE_INFINITY
+        : elapsedThen(this, voice, now - history.ms) - delay;
+}
+/** The ramp a voice's own fade envelope applies this frame, 0..1. */
+export function fadeOf(voice, now, since) {
+    return envelope(voice.fade.in ?? 0, voice.out, voice.ease, this.reducedNow, now, since);
+}
+/** What every owner above a voice multiplies into its weight for a subject this frame. */
+export function ownedBy(voice, subject) {
+    return ownersWeight(voice, this.now, this.reducedNow, (o) => this.ownerBase(o, subject));
+}
+/**
+ * An owner's signal read for a subject, once a frame: kept on the owner's record for it, which
+ * no fold links, in `phase`, with the frame it was read in `probed`.
+ */
+export function ownerBase(owner, subject) {
+    const now = this.now;
+    const held = this.held(owner, subject, now, -1);
+    if (held.probed === this.frame)
+        return held.phase;
+    const kept = reading.kept;
+    this.prime(owner, held, now, owner.elapsedAt(now), 0);
+    const base = this.base(owner, subject, now, held);
+    reading.kept = kept;
+    held.stepped = now;
+    held.probed = this.frame;
+    held.phase = base;
+    return base;
+}
+/** The weight a voice gives a subject this frame, with the setting already filled in. */
+export function weigh(voice, subject, now, held) {
+    if (voice.owner !== null)
+        return this.weighOwned(voice, subject, now, held);
+    const base = this.base(voice, subject, now, held);
+    const fade = this.envelope(voice, now, held.shown);
+    return weighed(base, fade, voice.parts === null ? 1 : this.parting(voice, subject, now));
+}
+/** `weigh` for a voice an owner holds, its owners' weight folded into its fade. */
+export function weighOwned(voice, subject, now, held) {
+    // Its owners first, since a signal on one takes over the setting `base` leaves for the patch.
+    const owned = this.ownedBy(voice, subject);
+    const base = this.base(voice, subject, now, held);
+    const fade = this.envelope(voice, now, held.shown) * owned;
+    return weighed(base, fade, voice.parts === null ? 1 : this.parting(voice, subject, now));
+}
+/**
+ * A voice's weight for a subject before its fade and ramp: its signal's, or its own number.
+ * `slot` is the subject's number when lanes ask.
+ */
+export function base(voice, subject, now, held, slot = -1) {
+    this.sending.voice = voice;
+    this.sending.subject = subject;
+    const signal = typeof voice.spec.weight === 'function' ? voice.spec.weight : null;
+    if (signal === null)
+        return voice.weight;
+    const was = held.replay && last(held.replay, now, true);
+    const base = was
+        ? was.value
+        : voice.blend === null
+            ? signal(subject, voice.setting)
+            : this.blended(voice, subject, held, slot);
+    if (signal.input && !was)
+        record(this, held, base);
+    return base;
+}