@libraz/libsonare 1.7.2 → 1.8.1

package/dist/mixer.d.ts

@@ -0,0 +1,464 @@
+import type { AutomationCurve, GoniometerPoint, MeterTap, MixerProcessResult, MixMeterSnapshot, PanLawInput, PanMode, SendTiming, SurroundPan } from './public_types';
+/**
+ * One master-output meter reading. All dB fields are finite and floored at
+ * -120; `truePeakDb*` is an inter-sample peak from the ITU-R BS.1770-4
+ * polyphase reconstruction at 4x, not a sample peak. That reconstruction is a
+ * streaming measurement: its centered stencil needs a few future samples a
+ * realtime path does not have, so each block's last samples read marginally low
+ * (about 0.1 dB across 64..8192-sample blocks on a near-Nyquist tone, always
+ * under-reading). Use `meteringTruePeakDb` over the whole signal for an exact
+ * dBTP number.
+ */
+export interface MixerMeterSnapshot {
+    peakDbL: number;
+    peakDbR: number;
+    rmsDbL: number;
+    rmsDbR: number;
+    correlation: number;
+    truePeakDbL: number;
+    truePeakDbR: number;
+}
+/**
+ * Meter configuration for a strip added with {@link Mixer.addStrip}.
+ *
+ * The field names and defaults are the scene document's `strips[].metering`
+ * object, so a strip added imperatively and one declared in a scene describe the
+ * same thing. A strip's meters size their buffers when the strip is built, so
+ * this is the only place the configuration can be chosen — there is no setter.
+ * A full meter costs about 646 KB at 48 kHz and a strip carries two of them.
+ */
+export interface StripMeteringOptions {
+    /** Both meters; `false` drops them (about 145 KB for the strip instead of 1.4 MB). Default `true`. */
+    enabled?: boolean;
+    /** LUFS measurement; `false` takes one meter to about 83 KB. Default `true`. */
+    lufs?: boolean;
+    /** Inter-sample (true) peak measurement. Default `true`. */
+    truePeak?: boolean;
+    /**
+     * Requested true-peak oversampling factor in `[0, 16]`; the meter resolves it
+     * to the nearest of 2x / 4x / 8x. `0` selects the library default (4x).
+     */
+    truePeakOversample?: number;
+}
+export interface MixerRealtimeBuffer {
+    leftInputs: Float32Array[];
+    rightInputs: Float32Array[];
+    outLeft: Float32Array;
+    outRight: Float32Array;
+    process: (numSamples?: number) => void;
+}
+/**
+ * Persistent, scene-based stereo mixer.
+ *
+ * Build one from a scene JSON string (e.g. {@link mixingScenePresetJson} or a
+ * hand-authored scene), then feed per-strip stereo blocks through
+ * {@link processStereo} to get the routed stereo master. Strips, sends, buses,
+ * and inserts are described entirely by the scene; the routing graph is
+ * compiled lazily on the first {@link processStereo} call (or eagerly via
+ * {@link compile}).
+ *
+ * Call {@link delete} (or use a `try/finally`) to release the underlying WASM
+ * object — the embind handle is not garbage-collected automatically.
+ *
+ * @example
+ * ```typescript
+ * const mixer = Mixer.fromSceneJson(mixingScenePresetJson('vocalReverbSend'), 48000, 512);
+ * try {
+ *   const out = mixer.processStereo([stripL], [stripR]);
+ * } finally {
+ *   mixer.delete();
+ * }
+ * ```
+ */
+export declare class Mixer {
+    private mixer;
+    private released;
+    private readonly blockSize;
+    private constructor();
+    /**
+     * Build a mixer from a scene JSON string.
+     *
+     * A strip's meters are sized when the strip is built, so this is where their
+     * configuration is chosen: an optional `metering` object on the strip
+     * (`enabled` / `lufs` / `truePeak` / `truePeakOversample`) selects it, and
+     * leaving it out keeps the full default (LUFS + true peak at 4x, about 1.4 MB
+     * per strip at 48 kHz). `{"enabled": false}` drops both meters for a strip
+     * whose snapshots are never read.
+     *
+     * @param json - Scene JSON (strips, buses, sends, connections, inserts)
+     * @param sampleRate - Sample rate in Hz (default: 48000)
+     * @param blockSize - Maximum block size per {@link processStereo} call (default: 512)
+     */
+    static fromSceneJson(json: string, sampleRate?: number, blockSize?: number): Mixer;
+    /**
+     * Rebuild and compile the routing graph without resetting its absolute
+     * automation sample position or queued strip automation.
+     */
+    compile(): void;
+    /**
+     * Non-fatal warnings captured when this mixer was built from scene JSON: one
+     * entry per channel-strip insert that was handed param keys it does not read
+     * (a likely typo, or a key meant for a different processor). The scene still
+     * loaded; these keys simply took no effect. Empty when every key was consumed.
+     * Use {@link masteringInsertParamNames} to discover the keys an insert accepts.
+     */
+    sceneWarnings(): string[];
+    /**
+     * Mix one block of per-strip stereo audio into the stereo master.
+     *
+     * @param leftChannels - `leftChannels[i]` is the left channel of strip `i`
+     * @param rightChannels - `rightChannels[i]` is the right channel of strip `i`
+     * @returns Mixed stereo master (`left`, `right`, `sampleRate`)
+     */
+    processStereo(leftChannels: Float32Array[], rightChannels: Float32Array[]): MixerProcessResult;
+    /**
+     * Mix one block into caller-owned output arrays.
+     *
+     * This avoids allocating the result object and result `Float32Array`s. It is
+     * intended for realtime bridges such as AudioWorklet; the input channel count
+     * must match the scene strip count and all arrays must have the same length.
+     */
+    processStereoInto(leftChannels: Float32Array[], rightChannels: Float32Array[], outLeft: Float32Array, outRight: Float32Array): void;
+    /**
+     * Create reusable WASM-heap input/output views for realtime-style processing.
+     *
+     * Fill `leftInputs[i]` / `rightInputs[i]`, call `process()`, then read
+     * `outLeft` / `outRight`. The views are owned by this mixer and become invalid
+     * after {@link delete}.
+     */
+    createRealtimeBuffer(): MixerRealtimeBuffer;
+    /**
+     * Turn the master-output meter on or off.
+     *
+     * While on, every {@link MixerRealtimeBuffer.process} call meters the stereo
+     * master it just produced, so a caller reads {@link meterSnapshot} instead of
+     * copying the output and measuring it again. `truePeakDb*` is an inter-sample
+     * peak taken after oversampling (ITU-R BS.1770-4 Annex 2 requires at least
+     * 4x), which is a different and higher quantity than the sample peak.
+     *
+     * Enabling resets the meter, so a reading never mixes in audio from a period
+     * when metering was off.
+     *
+     * @param enabled - Whether to meter the master output.
+     * @param truePeakOversample - 0 (= 4x) or a power of two in [1, 16].
+     */
+    configureMeter(enabled: boolean, truePeakOversample?: number): void;
+    /**
+     * Latest master-output meter reading, describing the most recently metered
+     * block. All dB fields are finite and floored at -120.
+     *
+     * @throws When the meter has never been enabled.
+     */
+    meterSnapshot(): MixerMeterSnapshot;
+    /**
+     * Latch the latest meter reading into the mixer's internal scratch so
+     * {@link meterScratchValue} can read it back one number at a time.
+     *
+     * This is the allocation-free form of {@link meterSnapshot}, for an audio
+     * render callback that must not create a JS object per interval. It returns
+     * `false` instead of throwing when the meter has never been enabled.
+     *
+     * @returns Whether a reading was latched.
+     */
+    latchMeterSnapshot(): boolean;
+    /**
+     * Read one field of the snapshot latched by {@link latchMeterSnapshot}.
+     *
+     * @param field - `0` peakDbL, `1` peakDbR, `2` rmsDbL, `3` rmsDbR,
+     *   `4` correlation, `5` truePeakDbL, `6` truePeakDbR. Any other index
+     *   reads `0`.
+     */
+    meterScratchValue(field: number): number;
+    /** Number of strips in the mixer (e.g. strips loaded from the scene). */
+    stripCount(): number;
+    /**
+     * Schedule sample-accurate insert-parameter automation on a strip's insert.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param insertIndex - Index into the strip's combined insert sequence
+     *   (`[pre-inserts... post-inserts...]`)
+     * @param paramId - Processor-specific parameter id
+     * @param samplePos - Absolute samples from the start of processing (the mixer
+     *   advances an internal position from 0 on the first {@link processStereo}
+     *   call; recompiling resets it to 0)
+     * @param value - Target parameter value
+     * @param curve - Interpolation curve (default: `'linear'`)
+     * @throws If the strip index is out of range or the schedule call fails
+     *   (unknown curve, out-of-range insert index, or full event lane)
+     */
+    scheduleInsertAutomation(stripIndex: number, insertIndex: number, paramId: number, samplePos: number, value: number, curve?: AutomationCurve): void;
+    /**
+     * Resolve a strip's index in `[0, stripCount())` from its scene id, or `null`
+     * when no strip with that id exists (matches the Node binding's `number | null`).
+     */
+    stripById(id: string): number | null;
+    /**
+     * Add a channel strip to the mixer topology. `metering` configures the strip's
+     * pre/post taps; omitting it keeps the full default (LUFS + true peak at 4x,
+     * about 1.4 MB per strip at 48 kHz). Marks the routing graph dirty; call
+     * {@link compile} (or {@link processStereo}) to rebuild.
+     *
+     * @throws If the id is already taken, or `truePeakOversample` is outside `[0, 16]`
+     */
+    addStrip(id: string, metering?: StripMeteringOptions): void;
+    /**
+     * Add a bus to the mixer topology. `role` is one of `'master'`, `'aux'`, or
+     * `'submix'` (defaults to `'aux'`). Marks the routing graph dirty; call
+     * {@link compile} (or {@link processStereo}) to rebuild.
+     */
+    addBus(id: string, role?: string): void;
+    /** Remove a bus by id. Marks the routing graph dirty. */
+    removeBus(id: string): void;
+    /** Number of buses in the mixer topology. */
+    busCount(): number;
+    /**
+     * Add a VCA group with the given gain offset (dB). `members` is a list of
+     * strip ids governed by the group (may be empty).
+     */
+    addVcaGroup(id: string, gainDb?: number, members?: string[]): void;
+    /** Set an existing VCA group's gain in dB. */
+    setVcaGroupGainDb(id: string, gainDb: number): void;
+    /** Replace an existing VCA group's strip membership. */
+    setVcaGroupMembers(id: string, members: string[]): void;
+    /** Remove a VCA group by id. */
+    removeVcaGroup(id: string): void;
+    /** Number of VCA groups in the mixer topology. */
+    vcaGroupCount(): number;
+    /** Set the strip's input trim in dB. */
+    setInputTrimDb(stripIndex: number, db: number): void;
+    /** Set the strip's fader level in dB. */
+    setFaderDb(stripIndex: number, db: number): void;
+    /**
+     * Set the strip's pan position.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param pan - Pan position in `[-1, 1]`
+     * @param panMode - Optional pan mode. When omitted the strip's current pan
+     *   mode is kept (passes `SONARE_PAN_MODE_KEEP`), so a plain pan nudge does
+     *   not reset a scene-defined `'stereoPan'` / `'dualPan'` mode back to
+     *   balance. Pass `'balance'` (or `0`) explicitly to force balance mode.
+     */
+    setPan(stripIndex: number, pan: number, panMode?: PanMode | number): void;
+    /** Set the strip's stereo width. */
+    setWidth(stripIndex: number, width: number): void;
+    /**
+     * Snap the strip's input-trim, fader, pan and width smoothers to the values
+     * already set on it, so the next processed block opens at those values
+     * instead of gliding to them over the smoothing window (~5 ms).
+     *
+     * Call it after configuring a strip and before rendering a finite buffer: a
+     * strip is smoothed for a live fader, and an offline render that does not
+     * settle carries that glide as a level and image sweep across the head of
+     * its output. Unlike a reset it clears nothing — automation, meters and
+     * insert state are untouched.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     *
+     * @example
+     * ```typescript
+     * mixer.setFaderDb(0, -3);
+     * mixer.setPan(0, 0.3);
+     * mixer.settle(0);
+     * const { left, right } = mixer.processStereo([dryLeft], [dryRight]);
+     * ```
+     */
+    settle(stripIndex: number): void;
+    /** Set the strip's mute state. */
+    setMuted(stripIndex: number, muted: boolean): void;
+    /**
+     * Set a strip's solo state. Takes effect on the next process without a
+     * graph recompile.
+     */
+    setSoloed(stripIndex: number, soloed: boolean): void;
+    /**
+     * Mark a strip solo-safe so it is never implied-muted by another strip's
+     * solo. Takes effect on the next process without a graph recompile.
+     */
+    setSoloSafe(stripIndex: number, soloSafe: boolean): void;
+    /** Invert the polarity of the left and/or right channel of a strip. */
+    setPolarityInvert(stripIndex: number, invertLeft: boolean, invertRight: boolean): void;
+    /** Set the strip's pan law (a {@link PanLawName} alias or raw C ABI ordinal). */
+    setPanLaw(stripIndex: number, panLaw: PanLawInput): void;
+    /**
+     * Set a per-strip channel delay in samples. This changes the strip's reported
+     * latency; recompile to re-run latency compensation.
+     */
+    setChannelDelaySamples(stripIndex: number, delaySamples: number): void;
+    /** Set the strip's live VCA gain offset in dB (not persisted to the scene). */
+    setVcaOffsetDb(stripIndex: number, offsetDb: number): void;
+    /** Set independent left/right pan positions (dual-pan mode). */
+    setDualPan(stripIndex: number, leftPan: number, rightPan: number): void;
+    /**
+     * Set the strip's surround pan position, used when it feeds a >2-channel bus.
+     *
+     * Applied when the engine's track mixer renders this strip's lane into a
+     * destination with more than two channels. This stereo-only mixer's own
+     * block entry points ignore it.
+     */
+    setSurroundPan(stripIndex: number, pan: SurroundPan): void;
+    /**
+     * Add a send to a strip after construction.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param id - Send id
+     * @param destinationBusId - Destination bus id
+     * @param sendDb - Initial send level in dB
+     * @param timing - `'preFader'` or `'postFader'` (default: `'postFader'`)
+     * @returns The new send's index
+     */
+    addSend(stripIndex: number, id: string, destinationBusId: string, sendDb?: number, timing?: SendTiming | number): number;
+    /** Set the send level (in dB) for an existing send by index. */
+    setSendDb(stripIndex: number, sendIndex: number, sendDb: number): void;
+    /**
+     * Remove an existing send from a strip by index.
+     *
+     * Sends are addressed in add order. After removal, sends with a higher index
+     * than `sendIndex` shift down by one. Recompile (or process) before reading
+     * results so the routing graph rebuilds.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param sendIndex - Send index in add order
+     */
+    removeSend(stripIndex: number, sendIndex: number): void;
+    /**
+     * Read a strip's meter snapshot at the given tap point.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param tap - `'preFader'` or `'postFader'` (default: `'postFader'`)
+     */
+    meterTap(stripIndex: number, tap?: MeterTap): MixMeterSnapshot;
+    /**
+     * Read a strip's meter snapshot.
+     *
+     * With no `tap` argument this reads the strip's own (post-fader) meter,
+     * matching the Node/Python tap-less `stripMeter` contract. Pass an optional
+     * `tap` (`'preFader'` / `'postFader'`) to read the tap-selectable snapshot
+     * instead — the same backing call as {@link meterTap}.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param tap - Optional tap point (`'preFader'` / `'postFader'`); when omitted
+     *   the tap-less post-fader strip meter is read.
+     */
+    stripMeter(stripIndex: number, tap?: MeterTap | number): MixMeterSnapshot;
+    /** Read the post-insert meter for a compiled bus, including master. */
+    busMeter(busId: string): MixMeterSnapshot;
+    /**
+     * Number of blocks in which the strip discarded recursive state because a
+     * non-finite value had reached it.
+     *
+     * Advisory telemetry, and the only thing that separates a degraded strip
+     * from a clean one. A discard returns the affected state to its
+     * post-reset value, so the strip recovers in silence and the output stays
+     * finite and in range while carrying samples unrelated to the input;
+     * nothing else reports that this happened.
+     *
+     * The count covers the strip's own state, its EQ, every insert it owns and
+     * both of its meters. None of those is separately addressable here, so a
+     * discard inside one is observable only through this number -- and a
+     * meter that loses its loudness window then reports the floor, which is
+     * exactly what a genuinely silent strip reports, so nothing else
+     * distinguishes the two.
+     *
+     * A meter's own discard lags by one block: it checks its loudness state at
+     * the top of a block, before consuming that block's samples, so the block
+     * that corrupts it is not the block the count moves on -- read this again
+     * after one more block has processed. The EQ and inserts have no such lag;
+     * they discard at the end of their own process, in the same block that
+     * carried the poison.
+     *
+     * Cumulative since the strip was created and never cleared, so two
+     * readings bracket a span of audio. The unit is one processed block, never
+     * a channel, so a stereo block that discards on both channels adds one and
+     * the number does not depend on a dimension the caller did not choose.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     */
+    stripNonFiniteDiscardCount(stripIndex: number): number;
+    /**
+     * Number of blocks in which a bus discarded recursive state because a
+     * non-finite value had reached it. Same contract as
+     * {@link stripNonFiniteDiscardCount}, for a bus: covers every insert the
+     * bus owns and its meter, neither separately addressable, so a discard
+     * inside one is observable only here. Cumulative across graph recompiles
+     * -- the count lives with the bus, not the compiled node, so an unrelated
+     * edit elsewhere in the mixer does not reset it.
+     *
+     * A bus's DSP record is created by the first {@link compile}. Throws for a
+     * bus that has been declared with {@link addBus} but never compiled --
+     * reading zero there would read as clean, and it is not. Also throws for
+     * an unknown bus id.
+     *
+     * @param busId - Bus id, as passed to {@link addBus} or declared in scene JSON
+     */
+    busNonFiniteDiscardCount(busId: string): number;
+    /**
+     * Schedule sample-accurate fader automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param faderDb - Target fader level in dB
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleFaderAutomation(stripIndex: number, samplePos: number, faderDb: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate pan automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param pan - Target pan position
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    schedulePanAutomation(stripIndex: number, samplePos: number, pan: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate width automation on a strip.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param samplePos - Absolute samples from the start of processing
+     * @param width - Target stereo width
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleWidthAutomation(stripIndex: number, samplePos: number, width: number, curve?: AutomationCurve): void;
+    /**
+     * Schedule sample-accurate send-level automation on a strip's send.
+     *
+     * @param stripIndex - Strip index in `[0, stripCount())`
+     * @param sendIndex - Send index in the strip's add order
+     * @param samplePos - Absolute samples from the start of processing
+     * @param db - Target send level in dB
+     * @param curve - Interpolation curve (default: `'linear'`)
+     */
+    scheduleSendAutomation(stripIndex: number, sendIndex: number, samplePos: number, db: number, curve?: AutomationCurve): void;
+    /**
+     * Read up to `maxPoints` of a strip's most recent goniometer samples
+     * (oldest to newest).
+     *
+     * `maxPoints` must be a finite non-negative integer; anything else throws an
+     * `InvalidParameter` error. It is a request rather than an allocation size —
+     * a value beyond the strip's goniometer ring simply returns every point the
+     * ring holds.
+     */
+    readGoniometerLatest(stripIndex: number, maxPoints: number): GoniometerPoint[];
+    /** Serialize the current scene (strips, buses, sends, connections) to JSON. */
+    toSceneJson(): string;
+    /**
+     * Longest audible serial processor-tail path to the master, in samples. Lazily
+     * compiles the routing graph if the topology is dirty.
+     */
+    tailSamples(): number;
+    /**
+     * Reported latency (samples) of the compiled mixer graph, for aligning
+     * dry/wet material. Lazily compiles the routing graph if the topology is dirty.
+     */
+    latencySamples(): number;
+    /**
+     * Drain delayed / tail audio by processing a zero-input block of `numSamples`
+     * frames after the host stops feeding strip inputs. Returns the mixed stereo
+     * master (`left`, `right`, `sampleRate`).
+     */
+    drainTailStereo(numSamples: number): MixerProcessResult;
+    /** Release the underlying WASM object. Idempotent, as the Node facade is. */
+    delete(): void;
+    /** Alias for {@link delete}, provided for cross-binding (Node) compatibility. */
+    destroy(): void;
+}
+//# sourceMappingURL=mixer.d.ts.map

package/dist/mixer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixer.d.ts","sourceRoot":"","sources":["../src/mixer.ts"],"names":[],"mappings":"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"}

package/dist/mixing_assistant.d.ts

@@ -0,0 +1,62 @@
+import type { MixAssistantOptions, MixAssistantResult, MixAssistantTrack } from './public_types';
+/** Inputs for the {@link suggestMixScene} / {@link suggestMixSceneJson} facades. */
+export interface SuggestMixSceneRequest {
+    /** Tracks to mix, in the order their profiles are reported. */
+    tracks: MixAssistantTrack[];
+    /**
+     * Shared sample rate in Hz for every track. Required: every band edge,
+     * high-pass corner, sibilance band and alignment lag is derived from it, so a
+     * guessed rate would silently misread 44.1 kHz material by 8.8% and report
+     * `channelDelaySamples` and `durationSec` wrong with it.
+     */
+    sampleRate: number;
+    /** Assistant tunables; every field falls back to the core default. */
+    options?: MixAssistantOptions;
+}
+/**
+ * Analyze a set of tracks and suggest a mixer scene.
+ *
+ * Offline only: the pipeline runs an STFT per track and evaluates every track
+ * pair, so it is measured in milliseconds per track and must never be called
+ * from an audio callback.
+ *
+ * The assistant suggests, it does not apply. Nothing is processed and no audio
+ * is returned; realizing the suggestion means handing the scene to
+ * {@link Mixer.fromSceneJson} as an explicit second step, for which
+ * {@link suggestMixSceneJson} returns the scene already serialized.
+ *
+ * Degenerate input is not an error: no tracks, all-silent tracks or tracks too
+ * short to measure yield an empty scene and an empty `explanation`.
+ *
+ * @param request - Tracks, shared sample rate and assistant options
+ * @returns The suggested scene, per-track profiles, cross-track measurements
+ *   and the explanation behind each change
+ */
+export declare function suggestMixScene(request: SuggestMixSceneRequest): MixAssistantResult;
+/**
+ * Suggest a mixer scene and return only the scene, as JSON.
+ *
+ * The same analysis as {@link suggestMixScene}, serialized in the schema
+ * {@link Mixer.fromSceneJson} reads, so a caller that only wants to apply the
+ * suggestion neither digs the scene out of the fuller result nor re-serializes
+ * it.
+ *
+ * @param request - Tracks, shared sample rate and assistant options
+ * @returns Scene JSON string
+ */
+export declare function suggestMixSceneJson(request: SuggestMixSceneRequest): string;
+/**
+ * Source-class identifiers the assistant can report, in enum order.
+ *
+ * The index of a name in this list is the value
+ * {@link mixSourceClassFromName} resolves it to.
+ */
+export declare function mixSourceClassNames(): string[];
+/**
+ * Resolve a source-class identifier to its index in {@link mixSourceClassNames}.
+ *
+ * @param name - Source-class identifier, e.g. `"kick"`
+ * @returns The index, or -1 when the name is unknown
+ */
+export declare function mixSourceClassFromName(name: string): number;
+//# sourceMappingURL=mixing_assistant.d.ts.map

package/dist/mixing_assistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixing_assistant.d.ts","sourceRoot":"","sources":["../src/mixing_assistant.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAOjG,oFAAoF;AACpF,MAAM,WAAW,sBAAsB;IACrC,+DAA+D;IAC/D,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B;AA4DD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,kBAAkB,CAEnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAE3E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/mixing_oneshot.d.ts

@@ -0,0 +1,40 @@
+import type { MixOptions, MixResult } from './public_types';
+export declare function mixingScenePresetNames(): string[];
+/**
+ * Get a built-in mixing scene preset serialized as JSON. This is the canonical
+ * name shared with the Node and Python bindings; the returned JSON loads
+ * directly into a {@link Mixer} via {@link Mixer.fromSceneJson}.
+ *
+ * @param presetName - Preset name (see {@link mixingScenePresetNames})
+ * @returns Scene JSON string
+ */
+export declare function mixingScenePresetJson(presetName: string): string;
+/** Inputs for the one-shot {@link mixStereo} facade. */
+export interface MixStereoRequest extends MixOptions {
+    leftChannels: Float32Array[];
+    rightChannels: Float32Array[];
+    sampleRate?: number;
+}
+/**
+ * One-shot stereo mix of multiple strips through the routing graph + master bus.
+ *
+ * Each returned per-strip meter reflects only this single one-shot block. The
+ * LUFS fields (`momentaryLufs`, `shortTermLufs`, `integratedLufs`) are
+ * integrators whose windows that block does not fill, so they read the -120 dB
+ * floor sentinel; drive a streaming {@link Mixer} block-by-block if you need
+ * meaningful loudness.
+ *
+ * The true-peak fields are not integrators and need no streaming: each is a
+ * max-hold over the block just processed and is valid from the first one,
+ * flooring only on silence. This facade mixes the whole input as a single block,
+ * which is the whole-signal case, so the block-edge under-read documented on
+ * `MixMeterSnapshot.truePeakDbL` does not apply to the reading here.
+ *
+ * @param leftChannels - Per-strip left input buffers (all the same length)
+ * @param rightChannels - Per-strip right input buffers (all the same length)
+ * @param sampleRate - Sample rate in Hz
+ * @param options - Per-strip mix options (trim, fader, pan, width, mute)
+ */
+export declare function mixStereo(request: MixStereoRequest): MixResult;
+export declare function mixStereo(leftChannels: Float32Array[], rightChannels: Float32Array[], sampleRate?: number, options?: MixOptions): MixResult;
+//# sourceMappingURL=mixing_oneshot.d.ts.map

package/dist/mixing_oneshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixing_oneshot.d.ts","sourceRoot":"","sources":["../src/mixing_oneshot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAM5D,wBAAgB,sBAAsB,IAAI,MAAM,EAAE,CAEjD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wDAAwD;AACxD,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC;AAChE,wBAAgB,SAAS,CACvB,YAAY,EAAE,YAAY,EAAE,EAC5B,aAAa,EAAE,YAAY,EAAE,EAC7B,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,UAAU,GACnB,SAAS,CAAC"}

package/dist/module_state.d.ts

@@ -0,0 +1,15 @@
+import type { SonareModule } from './sonare.js';
+/**
+ * Recover the native exception-object pointer from a value thrown across the
+ * WASM boundary. emscripten surfaces a C++ throw in two shapes depending on the
+ * toolchain/exception mode:
+ *   - a raw pointer number (older / classic surfacing), or
+ *   - a `CppException` object exposing the pointer as `excPtr` (emscripten with
+ *     `-fexceptions`).
+ * Returns null when the thrown value is neither (a genuine JS error), so the
+ * caller rethrows it unchanged.
+ */
+export declare function nativeExceptionPtr(error: unknown): number | null;
+export declare function setSonareModule(module: SonareModule): void;
+export declare function getSonareModule(): SonareModule;
+//# sourceMappingURL=module_state.d.ts.map

package/dist/module_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module_state.d.ts","sourceRoot":"","sources":["../src/module_state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAahD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAWhE;AAsKD,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE1D;AAED,wBAAgB,eAAe,IAAI,YAAY,CAK9C"}

package/dist/opfs_clip_pages.d.ts

@@ -0,0 +1,28 @@
+import type { ClipPageProvider, ClipPageRequest, RealtimeEngine } from './realtime_engine';
+export interface OpfsClipPageProviderOptions {
+    path: string;
+    numChannels: number;
+    numSamples: number;
+    pageFrames: number;
+    dataOffsetBytes?: number;
+    worker?: Worker;
+    terminateWorkerOnClose?: boolean;
+    /** Internal bridge hook used to mirror a supplied page into an AudioWorklet. */
+    onPageSupplied?: (pageIndex: number, channels: Float32Array[]) => void;
+    /** Internal bridge hook used to mirror an eviction into an AudioWorklet. */
+    onPageCleared?: (pageIndex: number) => void;
+    /** Internal bridge hook called after the local provider is destroyed. */
+    onClose?: () => void;
+}
+export interface OpfsClipPageProviderBinding {
+    provider: ClipPageProvider;
+    supplyPage(pageIndex: number): Promise<boolean>;
+    supplyRequest(request: ClipPageRequest): Promise<boolean>;
+    /** Evict one resident page from every configured consumer. */
+    clearPage?(pageIndex: number): void;
+    close(): void;
+}
+export declare const opfsClipPageWorkerSource = "\nconst sonareClipPageReadQueues = new Map();\n\nfunction sonareEnqueueClipPageRead(key, task) {\n  const previous = sonareClipPageReadQueues.get(key) || Promise.resolve();\n  const next = previous.catch(() => undefined).then(task);\n  const queued = next.finally(() => {\n    if (sonareClipPageReadQueues.get(key) === queued) {\n      sonareClipPageReadQueues.delete(key);\n    }\n  });\n  sonareClipPageReadQueues.set(key, queued);\n  return next;\n}\n\nself.onmessage = async (event) => {\n  const message = event.data;\n  if (!message || message.type !== 'sonare:read-clip-page') return;\n  const { requestId, path, pageIndex, numChannels, numSamples, pageFrames, dataOffsetBytes = 0 } = message;\n  await sonareEnqueueClipPageRead(String(path), async () => {\n  try {\n    if (pageIndex < 0) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const startFrame = pageIndex * pageFrames;\n    if (startFrame >= numSamples) {\n      self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n      return;\n    }\n    const root = await self.navigator.storage.getDirectory();\n    let dir = root;\n    const parts = String(path).split('/').filter(Boolean);\n    for (let i = 0; i < parts.length - 1; ++i) {\n      dir = await dir.getDirectoryHandle(parts[i]);\n    }\n    const fileHandle = await dir.getFileHandle(parts[parts.length - 1]);\n    const access = await fileHandle.createSyncAccessHandle();\n    try {\n      const frames = Math.min(pageFrames, numSamples - startFrame);\n      const frameBytes = numChannels * 4;\n      const bytes = new Uint8Array(frames * frameBytes);\n      let bytesReadTotal = 0;\n      const readOffset = dataOffsetBytes + startFrame * frameBytes;\n      while (bytesReadTotal < bytes.byteLength) {\n        const bytesRead = access.read(bytes.subarray(bytesReadTotal), {\n          at: readOffset + bytesReadTotal,\n        });\n        if (bytesRead <= 0) {\n          break;\n        }\n        bytesReadTotal += bytesRead;\n      }\n      if (bytesReadTotal !== bytes.byteLength || bytesReadTotal % frameBytes !== 0) {\n        self.postMessage({ type: 'sonare:clip-page', requestId, pageIndex, ok: false });\n        return;\n      }\n      const framesRead = bytesReadTotal / frameBytes;\n      const view = new DataView(bytes.buffer, 0, framesRead * frameBytes);\n      const channelBuffers = Array.from({ length: numChannels }, () => new ArrayBuffer(framesRead * 4));\n      for (let ch = 0; ch < numChannels; ++ch) {\n        const channel = new Float32Array(channelBuffers[ch]);\n        for (let frame = 0; frame < framesRead; ++frame) {\n          channel[frame] = view.getFloat32((frame * numChannels + ch) * 4, true);\n        }\n      }\n      self.postMessage(\n        { type: 'sonare:clip-page', requestId, pageIndex, ok: true, frames: framesRead, channelBuffers },\n        channelBuffers,\n      );\n    } finally {\n      access.close();\n    }\n  } catch (error) {\n    self.postMessage({\n      type: 'sonare:clip-page',\n      requestId,\n      pageIndex,\n      ok: false,\n      error: error instanceof Error ? error.message : String(error),\n    });\n  }\n  });\n};\n";
+export declare function createOpfsClipPageWorker(): Worker;
+export declare function createOpfsClipPageProvider(engine: RealtimeEngine, options: OpfsClipPageProviderOptions): OpfsClipPageProviderBinding;
+//# sourceMappingURL=opfs_clip_pages.d.ts.map

package/dist/opfs_clip_pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opfs_clip_pages.d.ts","sourceRoot":"","sources":["../src/opfs_clip_pages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE3F,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,gFAAgF;IAChF,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,IAAI,CAAC;IACvE,4EAA4E;IAC5E,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,yEAAyE;IACzE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChD,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,8DAA8D;IAC9D,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,KAAK,IAAI,IAAI,CAAC;CACf;AAaD,eAAO,MAAM,wBAAwB,2pGAoFpC,CAAC;AAEF,wBAAgB,wBAAwB,IAAI,MAAM,CAWjD;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,2BAA2B,GACnC,2BAA2B,CAyH7B"}