@libraz/libsonare 1.3.1 → 1.3.3

package/README.md

@@ -21,6 +21,11 @@ no model weights.
 > If you need to read WAV/MP3/M4A files directly in Node, use the native
 > N-API package [`@libraz/libsonare-native`](https://github.com/libraz/libsonare/tree/main/bindings/node) instead.
 
+> **Platform constraints:** the WebAssembly build is single-threaded (analysis
+> runs to completion on the calling thread — there is no non-blocking variant),
+> has no host filesystem access, and expects pre-decoded `Float32Array` sample
+> buffers. Drive long-running calls from a Web Worker to keep the UI responsive.
+
 ## Installation
 
 ```bash
@@ -124,6 +129,54 @@ const room = analyzeImpulseResponse(irSamples, sampleRate);
 console.log(blind.rt60, room.c50);
 ```
 
+Acoustic simulation adds `synthesizeRir` (synthesize a shoebox-room impulse
+response from geometry), `estimateRoom` (recover an equivalent room from a
+recording or IR), and `roomMorph` (creatively re-reverberate audio toward a
+target room — not dereverberation).
+
+```typescript
+import { init, synthesizeRir, estimateRoom, roomMorph } from '@libraz/libsonare';
+
+await init();
+
+const { rir, hasError } = synthesizeRir({
+  lengthM: 6,
+  widthM: 4,
+  heightM: 3,
+  absorption: 0.2,
+  sampleRate: 48000,
+});
+
+const room = estimateRoom(samples, 48000); // { volume, length, width, height, ... }
+const morphed = roomMorph(samples, sampleRate, { lengthM: 12, widthM: 9, wet: 0.5 });
+```
+
+### Error handling
+
+Native (C++) failures are thrown as a `SonareError` carrying a numeric `code`
+(an `ErrorCode` value) and its canonical `codeName`, so you can branch on the
+cause instead of matching message text. Use the `isSonareError` type guard in a
+`catch`:
+
+```typescript
+import { init, analyze, ErrorCode, isSonareError } from '@libraz/libsonare';
+
+await init();
+
+try {
+  const result = analyze(samples, sampleRate);
+} catch (error) {
+  if (isSonareError(error)) {
+    console.error(`${error.codeName} (${error.code}): ${error.message}`);
+    if (error.code === ErrorCode.InvalidParameter) {
+      // recover...
+    }
+  } else {
+    throw error;
+  }
+}
+```
+
 ### Decoding files in the browser
 
 ```typescript
@@ -331,6 +384,149 @@ try {
 }
 ```
 
+#### Clip warp
+
+A clip can be time-warped during an offline `bounce`. `setClipWarpMode` selects
+the playback mode (`ProjectWarpMode`: `'off'` | `'repitch'` | `'tempo-sync'`),
+`setClipWarpRef` binds it to a warp map, and `setWarpMap` registers a first-class
+warp map (anchors mapping warp-timeline samples to source samples).
+
+```typescript
+project.setWarpMap({
+  id: 1,
+  name: 'main',
+  anchors: [
+    { warpSample: 0, sourceSample: 0 },
+    { warpSample: 48000, sourceSample: 24000 },
+  ],
+});
+project.setClipWarpRef(clipId, 1);
+project.setClipWarpMode(clipId, 'tempo-sync');
+```
+
+> Warp is an offline `Project.bounce` feature only. Realtime warp playback is
+> **not** available in `RealtimeEngine`.
+
+### Instruments and synthesis
+
+MIDI tracks bounce silently unless an instrument is bound. `Project` offers
+three instrument backends, each as a `bounceWith…` variant that takes a binding
+(or array of bindings) plus the usual `ProjectBounceOptions`:
+
+- `bounceWithBuiltinInstrument(binding?, options?)` — simple built-in oscillator
+  synth (`BuiltinSynthConfig` / `BuiltinSynthBinding`: waveform + ADSR + gain).
+- `bounceWithSynthInstrument(patchOrName?, options?)` — patch-driven NativeSynth
+  (`SynthPatch`, or a preset-name string like `'saw-lead'`).
+- `bounceWithSf2Instrument(config?, options?)` — GS-compatible SoundFont player
+  (`Sf2InstrumentConfig`), fed by `loadSoundFont()`.
+
+Discover NativeSynth presets with `synthPresetNames()` and fetch one as an
+editable patch with `synthPresetPatch(name)`.
+
+```typescript
+import { init, Project, synthPresetNames, synthPresetPatch } from '@libraz/libsonare';
+
+await init();
+
+const project = new Project();
+try {
+  const { clipId } = project.addMidiClip(0, 4);
+  project.setMidiEvents(clipId, [
+    Project.midiNoteOn(0, 0, 0, 60, 100),
+    Project.midiNoteOff(1, 0, 0, 60),
+  ]);
+
+  // Built-in oscillator synth.
+  const a = project.bounceWithBuiltinInstrument({ waveform: 'saw' }, { numChannels: 2 });
+
+  // NativeSynth from a named preset, tweaked.
+  const patch = synthPresetPatch(synthPresetNames()[0]);
+  patch.cutoffHz = 4000;
+  const b = project.bounceWithSynthInstrument(patch, { numChannels: 2 });
+
+  // SoundFont player (requires loadSoundFont first).
+  project.loadSoundFont(sf2Bytes);
+  const c = project.bounceWithSf2Instrument({ gain: 0.6 }, { numChannels: 2 });
+} finally {
+  project.delete();
+}
+```
+
+### Real-time engine
+
+`RealtimeEngine` is a control-thread-driven transport + render engine: it plays
+a clip/automation timeline, hosts MIDI instruments, accepts live MIDI, and
+renders blocks (or bounces offline). Bind it to an AudioWorklet for browser
+playback — see the [AudioWorklet bridge](#audioworklet-bridge) below; the engine
+is the offline/headless half, the worklet is the audio-thread half.
+
+```typescript
+import { init, RealtimeEngine } from '@libraz/libsonare';
+
+await init();
+
+const engine = new RealtimeEngine(48000, 128); // sampleRate, maxBlockSize
+try {
+  engine.setSynthInstrument('saw-lead', 0);     // patch (or name), destinationId
+  engine.play();
+  engine.pushMidiNoteOn(0, 0, 0, 60, 100);      // destination, group, channel, note, velocity
+  engine.pushMidiNoteOff(0, 0, 0, 60);
+
+  const blockL = new Float32Array(128);
+  const blockR = new Float32Array(128);
+  const out = engine.process([blockL, blockR]); // Float32Array[] per channel
+  const telemetry = engine.drainTelemetry();
+} finally {
+  engine.destroy();
+}
+```
+
+Capabilities:
+
+- **Transport**: `play` / `stop` / `seekSample` / `seekPpq` / `setTempo` /
+  `setTimeSignature` / `setLoop`, plus `getTransportState`.
+- **Instruments**: `setBuiltinInstrument` / `setSynthInstrument` /
+  `setSf2Instrument` (+ `loadSoundFont`) per MIDI destination id.
+- **Live MIDI**: `pushMidiNoteOn` / `pushMidiNoteOff` / `pushMidiCc` /
+  `pushMidiPanic`, and `bindMidiCc(channel, controller, paramId, options?)` to
+  map a CC to an automation parameter.
+- **Process / bounce**: `process` (real-time blocks), the allocation-free
+  `prepareChannels` + `getChannelBuffer` + `processPrepared` worklet path,
+  `renderOffline`, `bounceOffline`, `freezeOffline`.
+- **Clip page providers**: `createClipPageProvider` + `supplyClipPage` for
+  streaming large clip audio in pages; pair with the OPFS helpers
+  (`createOpfsClipPageProvider`).
+- **Telemetry**: `drainTelemetry` / `drainMeterTelemetry`. Inspect runtime
+  capabilities (ABI compatibility, SharedArrayBuffer/Atomics) via
+  `engineCapabilities()`.
+
+### Real-time voice changer
+
+`RealtimeVoiceChanger` runs a block-by-block voice transformation chain (retune,
+formant shaping, EQ, gate, compressor). Construct it from a preset id (see
+`realtimeVoiceChangerPresetNames()`) or a full config object, then process blocks.
+
+```typescript
+import { init, RealtimeVoiceChanger, voiceChangeRealtime } from '@libraz/libsonare';
+
+await init();
+
+const changer = new RealtimeVoiceChanger('bright-idol');
+try {
+  changer.prepare(48000, 128, 1); // sampleRate, maxBlockSize, channels
+  const out = changer.processMono(block);
+} finally {
+  changer.delete();
+}
+
+// Whole-buffer convenience wrapper (constructs/prepares/disposes internally).
+const processed = voiceChangeRealtime(samples, { preset: 'deep-narrator', sampleRate: 48000 });
+```
+
+For a simple offline pitch + formant shift without the full chain, use
+`voiceChange(samples, sampleRate, { pitchSemitones: -2, formantFactor: 1.1 })`.
+Inspect a preset with `realtimeVoiceChangerPresetJson(name)`.
+
 ### AudioWorklet bridge
 
 The package exposes an optional worklet entry that uses the same `sonare.wasm`
@@ -427,6 +623,51 @@ function readMeters() {
 }
 ```
 
+#### RealtimeEngine AudioWorklet facade
+
+For browser DAW-style playback, `SonareEngine` keeps a main-thread
+`RealtimeEngine` mirror for offline renders and synchronizes the live worklet
+engine through control messages. The default runtime target is the embind engine;
+the `sonare-rt` runtime remains a transport-focused fallback.
+
+```typescript
+import { init } from '@libraz/libsonare';
+import { init as initWorklet, SonareEngine } from '@libraz/libsonare/worklet';
+
+await init();
+await audioContext.audioWorklet.addModule('/worklet.js');
+await initWorklet();
+
+const engine = await SonareEngine.create(audioContext, { mode: 'sab' });
+engine.setTrackLanes([{ trackId: 1 }]);
+engine.setTrackStripJson(1, trackSceneJson);
+engine.addClip(1, [clipL, clipR], 0);
+engine.setTempoSegments([{ startPpq: 0, bpm: 120 }]);
+engine.setTimeSignatureSegments([{ startPpq: 0, numerator: 4, denominator: 4 }]);
+engine.transport.play();
+```
+
+| Need | Facade/API |
+|---|---|
+| Track routing, fader, pan, solo/mute | `setTrackLanes`, `setStripGain`, `setStripPan`, `setSoloMute` |
+| Track/master inserts and EQ | `setTrackStripJson`, `setMasterStripJson`, `setTrackStripEqBand`, `setMasterStripEqBand`, insert bypass methods |
+| Sends and buses | `setSends`, `setBusGain`, `setBusStripJson` |
+| MIDI clips and live MIDI | `setMidiClips`, `pushMidiNoteOn`, `pushMidiNoteOff`, `pushMidiCc`, `pushMidiPanic` |
+| Instruments | `setBuiltinInstrument`, `setSynthInstrument`, `loadSoundFont`, `setSf2Instrument` |
+| Recording and monitoring | `configureCapture` (incl. the `inputMonitor` option), `armRecord`, `punch`, `capturedAudio`, `captureStatus` |
+| Transport, tempo, markers | `getTransportState`, `cachedTransportState`, `setTempoSegments`, `setTimeSignatureSegments`, marker methods, `setLoopFromMarkers` |
+| Clip updates | `addClip`, `removeClip`; the facade sends clip deltas while the processor keeps full-sync compatibility |
+| Meters | `onMeter` messages or the meter SharedArrayBuffer ring; records include master, lane, bus, and input target ids |
+
+Studio integration notes:
+
+- If a host worklet entry filters message names before forwarding, add every
+  `sync*`, `captureRequest`, and `transportRequest` message used above to that
+  allowlist; otherwise the host may silently drop the new control messages.
+- If a host vendors built worklet bundles, regenerate and reimport
+  `worklet.js`, `worklet.d.ts`, `sonare.js`, `sonare.wasm`,
+  `sonare-rt.js`, `sonare-rt-module.js`, and `sonare-rt.wasm` together.
+
 ### Progress callback
 
 `masteringChainWithProgress` (and its stereo variant) is `masteringChain` with
@@ -476,17 +717,50 @@ chain.reset();
 chain.delete(); // release WASM memory
 ```
 
+### Streaming equalizer and retune
+
+`StreamingEqualizer` wraps the unified `EqualizerProcessor` (up to 24 bands,
+RBJ/Vicanek biquads, dynamic EQ, linear-phase FIR, mid/side, auto-gain) with
+state maintained across calls. `StreamingRetune` is a block-by-block mono voice
+retune / pitch shifter.
+
+```typescript
+import { init, StreamingEqualizer, StreamingRetune } from '@libraz/libsonare';
+
+await init();
+
+const eq = new StreamingEqualizer({ sampleRate: 48000, maxBlockSize: 512 });
+try {
+  eq.setBand(0, { type: 'HighShelf', frequencyHz: 8000, gainDb: 6, enabled: true });
+  const { left: eqL, right: eqR } = eq.processStereo(left, right);
+} finally {
+  eq.delete();
+}
+
+const retune = new StreamingRetune({ semitones: 2, mix: 1.0 });
+try {
+  retune.prepare(48000, 512); // sampleRate, maxBlockSize
+  const shifted = retune.processMono(monoBlock);
+} finally {
+  retune.delete();
+}
+```
+
 ## Features
 
-- **Detection**: BPM, key, beats, onsets, chords, sections
+- **Detection**: `detectBeats`, `detectOnsets`, `detectDownbeats`, `detectChords`, `detectKey`, `detectKeyCandidates`, `chordFunctionalAnalysis`, sections
+- **Analysis**: `analyze`, `analyzeWithProgress`, `analyzeBpm`, `analyzeRhythm`, `analyzeDynamics`, `analyzeTimbre`; `hasFfmpegSupport` capability check
 - **Effects**: HPSS, HPSS with residual, time stretch, phase vocoder, pitch shift, normalize, trim, remix
 - **Mastering**: EQ, compressor, tape/exciter, air band, stereo imaging,
   true-peak limiting, loudness optimization
 - **Features**: STFT, mel spectrogram, MFCC, chroma, CQT/VQT, spectral contrast, poly features, zero crossings
 - **Pitch**: YIN, pYIN algorithms with optional `fillNa`
 - **Decomposition & loudness**: NMF decomposition, nearest-neighbour filtering, multichannel LUFS, EBU R128 LRA
-- **Streaming**: Real-time analysis with progressive estimates
-- **Headless DAW**: `Project` arrangement model — audio/MIDI tracks & clips, undo/redo, MIDI sequencing, SMF / MIDI 2.0 Clip File I/O, deterministic JSON, offline `bounce`
+- **Streaming**: Real-time analysis with progressive estimates; streaming mastering chain, equalizer, and retune
+- **Instruments**: built-in synth, patch-driven NativeSynth, SoundFont (SF2) player — bound to `Project` bounces or the `RealtimeEngine`
+- **Real-time**: `RealtimeEngine` transport/MIDI/render, `RealtimeVoiceChanger`, AudioWorklet bridge
+- **Room acoustics**: blind RT60/EDT, impulse-response clarity metrics, RIR synthesis, room estimation, room morphing
+- **Headless DAW**: `Project` arrangement model — audio/MIDI tracks & clips, undo/redo, MIDI sequencing, clip warp, SMF / MIDI 2.0 Clip File I/O, deterministic JSON, offline `bounce`
 - **Conversions**: Hz/mel/MIDI/note, frames/time, resample
 
 ## Also available

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { A as AcousticOptions, a as AcousticResult, b as AnalysisResult, c as AnalyzeBpmOptions, d as AnalyzeDynamicsOptions, e as AnalyzeRhythmOptions, f as AnalyzeSectionsOptions, g as AnalyzeTimbreOptions, h as AnalyzerStats, i as Audio, j as AutomationCurve, B as BarChord, k as Beat, l as BindMicrophoneInputOptions, m as BindWebMidiOptions, n as BpmAnalysisResult, o as BpmCandidate, p as BrowserAudioDecodeOptions, q as BuiltinSynthBinding, r as BuiltinSynthConfig, s as BuiltinSynthWaveform, C as Chord, t as ChordAnalysisResult, u as ChordChange, v as ChordDetectionOptions, w as ChordQuality, x as ChromaResult, y as ClippingRegion, z as ClippingReport, D as CompressorDetector, E as CompressorOptions, F as CqtResult, G as DeclickOptions, H as DeclipOptions, I as DecomposeResult, J as DecrackleMode, K as DecrackleOptions, L as DehumOptions, M as DenoiseClassicalMode, N as DenoiseClassicalNoiseEstimator, O as DenoiseClassicalOptions, P as DereverbClassicalOptions, Q as DynamicRangeReport, R as Dynamics, S as DynamicsAnalysisResult, T as DynamicsResult, U as EXPECTED_ENGINE_ABI_VERSION, V as EXPECTED_PROJECT_ABI_VERSION, W as EngineAutomationPoint, X as EngineBounceOptions, Y as EngineBounceResult, Z as EngineCapabilities, _ as EngineCaptureStatus, $ as EngineClip, a0 as EngineFreezeOptions, a1 as EngineFreezeResult, a2 as EngineGraphSpec, a3 as EngineMarker, a4 as EngineMeterTelemetry, a5 as EngineMetronomeConfig, a6 as EngineParameterInfo, a7 as EngineTelemetry, a8 as EngineTransportState, a9 as EqBand, aa as EqBandPhase, ab as EqBandType, ac as EqCoeffMode, ad as EqMatchOptions, ae as EqSpectrumSnapshot, af as EqStereoPlacement, ag as FrameBuffer, ah as GateOptions, ai as GoniometerPoint, aj as HpssResult, ak as HpssWithResidualResult, al as Key, am as KeyCandidate, an as KeyDetectionOptions, ao as KeyProfile, ap as KeyProfileName, aq as LufsResult, ar as MasteringChainConfig, as as MasteringChainResult, at as MasteringOptions, au as MasteringPreset, av as MasteringProcessorParams, aw as MasteringResult, ax as MasteringStereoChainResult, ay as MasteringStereoResult, az as Matrix2dResult, aA as MelPowerResult, aB as MelSpectrogramResult, aC as MelodyOptions, aD as MelodyPoint, aE as MelodyResult, aF as MeterTap, aG as MeteringDetectClippingOptions, aH as MeteringDynamicRangeOptions, aI as MfccResult, aJ as MicrophoneInputBinding, aK as MidiCcBindOptions, aL as MidiCcLearnOptions, aM as MixMeterSnapshot, aN as MixOptions, aO as MixResult, aP as Mixer, aQ as MixerProcessResult, aR as MixerRealtimeBuffer, aS as Mode, aT as NoteStretchOptions, aU as OpfsClipPageProviderBinding, aV as OpfsClipPageProviderOptions, aW as PairAnalysis, aX as PairProcessor, aY as PanLaw, aZ as PanMode, a_ as PatternScore, a$ as PhaseScopeReport, b0 as Pitch, b0 as PitchClass, b1 as PitchResult, b2 as ProgressiveEstimate, b3 as Project, b4 as ProjectAssistSidecar, b5 as ProjectAutomationCurve, b6 as ProjectAutomationLaneDesc, b7 as ProjectAutomationPoint, b8 as ProjectBounceOptions, b9 as ProjectChordSymbol, ba as ProjectClipCompSegment, bb as ProjectClipDesc, bc as ProjectClipFade, bd as ProjectClipTake, be as ProjectCompileResult, bf as ProjectFadeCurve, bg as ProjectKeySegment, bh as ProjectLoopMode, bi as ProjectLoopRecordingDesc, bj as ProjectLoopRecordingResult, bk as ProjectMidiClipResult, bl as ProjectMidiEvent, bm as ProjectNotePairValidation, bn as ProjectTrackDesc, bo as ProjectTrackKind, bp as ProjectWarpAnchor, bq as ProjectWarpMapDesc, br as RealtimeEngine, bs as RealtimeVoiceChanger, bt as RealtimeVoiceChangerConfigInput, bu as RealtimeVoiceChangerInterleavedBuffer, bv as RealtimeVoiceChangerMonoBuffer, bw as RealtimeVoiceChangerPlanarBuffer, bx as RealtimeVoiceChangerPodConfig, by as RhythmAnalysisResult, bz as RhythmFeatures, bA as RirResult, bB as RirSynthOptions, bC as RoomEstimateOptions, bD as RoomEstimateResult, bE as RoomGeometryOptions, bF as RoomMorphOptions, bG as SYNTH_BODY_TYPES, bH as SYNTH_ENGINE_MODES, bI as SYNTH_FILTER_MODELS, bJ as SYNTH_FILTER_OUTPUTS, bK as SYNTH_MOD_DESTINATIONS, bL as SYNTH_MOD_SOURCES, bM as SYNTH_OSC_WAVEFORMS, bN as Section, bO as SectionType, bP as SendTiming, bQ as Sf2InstrumentConfig, bR as Sf2ProgramStatus, bS as SoloProcessor, bT as SourceBackend, bU as SpectrumOptions, bV as SpectrumReport, bW as StereoAnalysis, bX as StftPowerResult, bY as StftResult, bZ as StreamAnalyzer, b_ as StreamConfig, b$ as StreamConfigDefaults, c0 as StreamFramesI16, c1 as StreamFramesU8, c2 as StreamQuantizeConfig, c3 as StreamingEqualizer, c4 as StreamingEqualizerConfig, c5 as StreamingMasteringChain, c6 as StreamingMasteringChainConfig, c7 as StreamingPlatform, c8 as StreamingRetune, c9 as StreamingRetuneConfig, ca as SynthBodyType, cb as SynthEngineMode, cc as SynthEnumTables, cd as SynthFilterModel, ce as SynthFilterOutput, cf as SynthModDestination, cg as SynthModRouting, ch as SynthModSource, ci as SynthOscWaveform, cj as SynthPatch, ck as TempogramMode, cl as Timbre, cm as TimbreAnalysisResult, cn as TimbreFrame, co as TimeSignature, cp as TransientShaperOptions, cq as TrimSilenceMode, cr as TrimSilenceOptions, cs as ValidateOptions, ct as VectorscopeReport, cu as VoiceChangeOptions, cv as VoiceChangeRealtimeOptions, cw as VoicePresetId, cx as WaveformPeakPyramidOptions, cy as WaveformPeaksOptions, cz as WaveformPeaksReport, cA as WebMidiBinding, cB as WebMidiCcBinding, cC as WebMidiInputInfo, cD as amplitudeToDb, cE as analyze, cF as analyzeBpm, cG as analyzeDynamics, cH as analyzeImpulseResponse, cI as analyzeMelody, cJ as analyzeRhythm, cK as analyzeSections, cL as analyzeTimbre, cM as analyzeWithProgress, cN as bassChroma, cO as bindMicrophoneInput, cP as bindWebMidi, cQ as chordFunctionalAnalysis, cR as chroma, cS as chromaCens, cT as cqt, cU as createOpfsClipPageProvider, cV as createOpfsClipPageWorker, cW as cyclicTempogram, cX as dbToAmplitude, cY as dbToPower, cZ as decompose, c_ as decomposeWithInit, c$ as deemphasis, d0 as detectAcoustic, d1 as detectBeats, d2 as detectBpm, d3 as detectChords, d4 as detectDownbeats, d5 as detectKey, d6 as detectKeyCandidates, d7 as detectOnsets, d8 as ebur128LoudnessRange, d9 as engineAbiVersion, da as engineCapabilities, db as estimateRoom, dc as estimateTuning, dd as fixFrames, de as fixLength, df as fourierTempogram, dg as frameSignal, dh as framesToSamples, di as framesToTime, dj as harmonic, dk as hasFfmpegSupport, dl as hpss, dm as hpssWithResidual, dn as hybridCqt, dp as hzToMel, dq as hzToMidi, dr as hzToNote, init, isInitialized, ds as isWebMidiAvailable, dt as lufs, du as lufsInterleaved, dv as masterAudio, dw as masterAudioStereo, dx as masterAudioStereoWithProgress, dy as masterAudioWithProgress, dz as mastering, dA as masteringAssistantSuggest, dB as masteringAudioProfile, dC as masteringChain, dD as masteringChainStereo, dE as masteringChainStereoWithProgress, dF as masteringChainWithProgress, dG as masteringDynamicsCompressor, dH as masteringDynamicsGate, dI as masteringDynamicsTransientShaper, dJ as masteringInsertNames, dK as masteringPairAnalysisNames, dL as masteringPairAnalyze, dM as masteringPairProcess, dN as masteringPairProcessorNames, dO as masteringPresetNames, dP as masteringProcess, dQ as masteringProcessStereo, dR as masteringProcessorNames, dS as masteringRepairDeclick, dT as masteringRepairDeclip, dU as masteringRepairDecrackle, dV as masteringRepairDehum, dW as masteringRepairDenoiseClassical, dX as masteringRepairDereverbClassical, dY as masteringRepairTrimSilence, dZ as masteringStereoAnalysisNames, d_ as masteringStereoAnalyze, d$ as masteringStreamingPreview, e0 as melSpectrogram, e1 as melToAudio, e2 as melToHz, e3 as melToStft, e4 as meteringCrestFactorDb, e5 as meteringDcOffset, e6 as meteringDetectClipping, e7 as meteringDynamicRange, e8 as meteringPeakDb, e9 as meteringPhaseScope, ea as meteringPhaseScopeDecimated, eb as meteringRmsDb, ec as meteringSpectrum, ed as meteringSpectrumFrame, ee as meteringStereoCorrelation, ef as meteringStereoWidth, eg as meteringTruePeakDb, eh as meteringVectorscope, ei as meteringVectorscopeDecimated, ej as mfcc, ek as mfccToAudio, el as mfccToMel, em as midiToHz, en as mixStereo, eo as mixingScenePresetJson, ep as mixingScenePresetNames, eq as momentaryLufs, er as nnFilter, es as nnlsChroma, et as normalize, eu as noteStretch, ev as noteToHz, ew as onsetEnvelope, ex as onsetStrengthMulti, ey as opfsClipPageWorkerSource, ez as padCenter, eA as pcen, eB as peakPick, eC as percussive, eD as phaseVocoder, eE as pitchCorrectToMidi, eF as pitchCorrectToMidiTimevarying, eG as pitchPyin, eH as pitchShift, eI as pitchTuning, eJ as pitchYin, eK as plp, eL as polyFeatures, eM as powerToDb, eN as preemphasis, eO as projectAbiVersion, eP as pseudoCqt, eQ as realtimeVoiceChangerPresetConfig, eR as realtimeVoiceChangerPresetJson, eS as realtimeVoiceChangerPresetNames, eT as remix, eU as resample, eV as rmsEnergy, eW as roomMorph, eX as samplesToFrames, eY as scaleCorrectionSemitones, eZ as scalePitchClassEnabled, e_ as scaleQuantizeMidi, e$ as shortTermLufs, f0 as spectralBandwidth, f1 as spectralCentroid, f2 as spectralContrast, f3 as spectralFlatness, f4 as spectralRolloff, f5 as splitSilence, f6 as stft, f7 as stftDb, f8 as streamAnalyzerConfigDefaults, f9 as synthEnumTables, fa as synthPresetNames, fb as synthPresetPatch, fc as synthesizeRir, fd as tempogram, fe as tempogramRatio, ff as timeStretch, fg as timeToFrames, fh as tonnetz, fi as trim, fj as trimSilence, fk as validateRealtimeVoiceChangerPresetJson, fl as vectorNormalize, fm as version, fn as voiceChange, fo as voiceChangeRealtime, fp as voiceChangerAbiVersion, fq as voiceCharacterPresetId, fr as vqt, fs as waveformPeakPyramid, ft as waveformPeaks, fu as zeroCrossingRate, fv as zeroCrossings } from './worklet.js';
+export { A as AcousticOptions, a as AcousticResult, b as AnalysisResult, c as AnalyzeBpmOptions, d as AnalyzeDynamicsOptions, e as AnalyzeRhythmOptions, f as AnalyzeSectionsOptions, g as AnalyzeTimbreOptions, h as AnalyzerStats, i as Audio, j as AutomationCurve, B as BarChord, k as Beat, l as BindMicrophoneInputOptions, m as BindWebMidiOptions, n as BpmAnalysisResult, o as BpmCandidate, p as BrowserAudioDecodeOptions, q as BuiltinSynthBinding, r as BuiltinSynthConfig, s as BuiltinSynthWaveform, C as Chord, t as ChordAnalysisResult, u as ChordChange, v as ChordDetectionOptions, w as ChordQuality, x as ChromaResult, y as ClippingRegion, z as ClippingReport, D as CompressorDetector, E as CompressorOptions, F as CqtResult, G as DeclickOptions, H as DeclipOptions, I as DecomposeResult, J as DecrackleMode, K as DecrackleOptions, L as DehumOptions, M as DenoiseClassicalMode, N as DenoiseClassicalNoiseEstimator, O as DenoiseClassicalOptions, P as DereverbClassicalOptions, Q as DynamicRangeReport, R as Dynamics, S as DynamicsAnalysisResult, T as DynamicsResult, U as EXPECTED_ENGINE_ABI_VERSION, V as EXPECTED_PROJECT_ABI_VERSION, W as EngineAutomationPoint, X as EngineBounceOptions, Y as EngineBounceResult, Z as EngineBus, _ as EngineCapabilities, $ as EngineCaptureStatus, a0 as EngineClip, a1 as EngineFreezeOptions, a2 as EngineFreezeResult, a3 as EngineGraphSpec, a4 as EngineMarker, a5 as EngineMeterTelemetry, a6 as EngineMetronomeConfig, a7 as EngineMidiClipSchedule, a8 as EngineMidiEvent, a9 as EngineParameterInfo, aa as EngineTelemetry, ab as EngineTempoSegment, ac as EngineTimeSignatureSegment, ad as EngineTrackLane, ae as EngineTrackSend, af as EngineTransportState, ag as EqBand, ah as EqBandPhase, ai as EqBandType, aj as EqCoeffMode, ak as EqMatchOptions, al as EqSpectrumSnapshot, am as EqStereoPlacement, an as ErrorCode, ao as FrameBuffer, ap as GateOptions, aq as GoniometerPoint, ar as HpssResult, as as HpssWithResidualResult, at as Key, au as KeyCandidate, av as KeyDetectionOptions, aw as KeyProfile, ax as KeyProfileName, ay as LufsResult, az as MasteringChainConfig, aA as MasteringChainResult, aB as MasteringOptions, aC as MasteringPreset, aD as MasteringProcessorParams, aE as MasteringResult, aF as MasteringStereoChainResult, aG as MasteringStereoResult, aH as Matrix2dResult, aI as MelPowerResult, aJ as MelSpectrogramResult, aK as MelodyOptions, aL as MelodyPoint, aM as MelodyResult, aN as MeterTap, aO as MeteringDetectClippingOptions, aP as MeteringDynamicRangeOptions, aQ as MfccResult, aR as MicrophoneInputBinding, aS as MidiCcBindOptions, aT as MidiCcLearnOptions, aU as MixMeterSnapshot, aV as MixOptions, aW as MixResult, aX as Mixer, aY as MixerProcessResult, aZ as MixerRealtimeBuffer, a_ as Mode, a$ as NoteStretchOptions, b0 as OpfsClipPageProviderBinding, b1 as OpfsClipPageProviderOptions, b2 as PairAnalysis, b3 as PairProcessor, b4 as PanLaw, b5 as PanMode, b6 as PatternScore, b7 as PhaseScopeReport, b8 as Pitch, b8 as PitchClass, b9 as PitchResult, ba as ProgressiveEstimate, bb as Project, bc as ProjectAssistSidecar, bd as ProjectAutomationCurve, be as ProjectAutomationLaneDesc, bf as ProjectAutomationPoint, bg as ProjectBounceOptions, bh as ProjectChordSymbol, bi as ProjectClipCompSegment, bj as ProjectClipDesc, bk as ProjectClipFade, bl as ProjectClipTake, bm as ProjectCompileResult, bn as ProjectFadeCurve, bo as ProjectKeySegment, bp as ProjectLoopMode, bq as ProjectLoopRecordingDesc, br as ProjectLoopRecordingResult, bs as ProjectMidiClipResult, bt as ProjectMidiEvent, bu as ProjectNotePairValidation, bv as ProjectTrackDesc, bw as ProjectTrackKind, bx as ProjectWarpAnchor, by as ProjectWarpMapDesc, bz as RealtimeEngine, bA as RealtimeVoiceChanger, bB as RealtimeVoiceChangerConfigInput, bC as RealtimeVoiceChangerInterleavedBuffer, bD as RealtimeVoiceChangerMonoBuffer, bE as RealtimeVoiceChangerPlanarBuffer, bF as RealtimeVoiceChangerPodConfig, bG as RhythmAnalysisResult, bH as RhythmFeatures, bI as RirResult, bJ as RirSynthOptions, bK as RoomEstimateOptions, bL as RoomEstimateResult, bM as RoomGeometryOptions, bN as RoomMorphOptions, bO as SYNTH_BODY_TYPES, bP as SYNTH_ENGINE_MODES, bQ as SYNTH_FILTER_MODELS, bR as SYNTH_FILTER_OUTPUTS, bS as SYNTH_MOD_DESTINATIONS, bT as SYNTH_MOD_SOURCES, bU as SYNTH_OSC_WAVEFORMS, bV as Section, bW as SectionType, bX as SendTiming, bY as Sf2InstrumentConfig, bZ as Sf2ProgramStatus, b_ as SoloProcessor, b$ as SonareError, c0 as SourceBackend, c1 as SpectrumOptions, c2 as SpectrumReport, c3 as StereoAnalysis, c4 as StftPowerResult, c5 as StftResult, c6 as StreamAnalyzer, c7 as StreamConfig, c8 as StreamConfigDefaults, c9 as StreamFramesI16, ca as StreamFramesU8, cb as StreamQuantizeConfig, cc as StreamingEqualizer, cd as StreamingEqualizerConfig, ce as StreamingMasteringChain, cf as StreamingMasteringChainConfig, cg as StreamingPlatform, ch as StreamingRetune, ci as StreamingRetuneConfig, cj as SynthBodyType, ck as SynthEngineMode, cl as SynthEnumTables, cm as SynthFilterModel, cn as SynthFilterOutput, co as SynthModDestination, cp as SynthModRouting, cq as SynthModSource, cr as SynthOscWaveform, cs as SynthPatch, ct as TempogramMode, cu as Timbre, cv as TimbreAnalysisResult, cw as TimbreFrame, cx as TimeSignature, cy as TransientShaperOptions, cz as TrimSilenceMode, cA as TrimSilenceOptions, cB as ValidateOptions, cC as VectorscopeReport, cD as VoiceChangeOptions, cE as VoiceChangeRealtimeOptions, cF as VoicePresetId, cG as WaveformPeakPyramidOptions, cH as WaveformPeaksOptions, cI as WaveformPeaksReport, cJ as WebMidiBinding, cK as WebMidiCcBinding, cL as WebMidiInputInfo, cM as amplitudeToDb, cN as analyze, cO as analyzeBpm, cP as analyzeDynamics, cQ as analyzeImpulseResponse, cR as analyzeMelody, cS as analyzeRhythm, cT as analyzeSections, cU as analyzeTimbre, cV as analyzeWithProgress, cW as bassChroma, cX as bindMicrophoneInput, cY as bindWebMidi, cZ as chordFunctionalAnalysis, c_ as chroma, c$ as chromaCens, d0 as cqt, d1 as createOpfsClipPageProvider, d2 as createOpfsClipPageWorker, d3 as cyclicTempogram, d4 as dbToAmplitude, d5 as dbToPower, d6 as decompose, d7 as decomposeWithInit, d8 as deemphasis, d9 as detectAcoustic, da as detectBeats, db as detectBpm, dc as detectChords, dd as detectDownbeats, de as detectKey, df as detectKeyCandidates, dg as detectOnsets, dh as ebur128LoudnessRange, di as engineAbiVersion, dj as engineCapabilities, dk as estimateRoom, dl as estimateTuning, dm as fixFrames, dn as fixLength, dp as fourierTempogram, dq as frameSignal, dr as framesToSamples, ds as framesToTime, dt as harmonic, du as hasFfmpegSupport, dv as hpss, dw as hpssWithResidual, dx as hybridCqt, dy as hzToMel, dz as hzToMidi, dA as hzToNote, init, isInitialized, dB as isSonareError, dC as isWebMidiAvailable, dD as lufs, dE as lufsInterleaved, dF as masterAudio, dG as masterAudioStereo, dH as masterAudioStereoWithProgress, dI as masterAudioWithProgress, dJ as mastering, dK as masteringAssistantSuggest, dL as masteringAudioProfile, dM as masteringChain, dN as masteringChainStereo, dO as masteringChainStereoWithProgress, dP as masteringChainWithProgress, dQ as masteringDynamicsCompressor, dR as masteringDynamicsGate, dS as masteringDynamicsTransientShaper, dT as masteringInsertNames, dU as masteringInsertParamNames, dV as masteringPairAnalysisNames, dW as masteringPairAnalyze, dX as masteringPairProcess, dY as masteringPairProcessorNames, dZ as masteringPresetNames, d_ as masteringProcess, d$ as masteringProcessStereo, e0 as masteringProcessorNames, e1 as masteringRepairDeclick, e2 as masteringRepairDeclip, e3 as masteringRepairDecrackle, e4 as masteringRepairDehum, e5 as masteringRepairDenoiseClassical, e6 as masteringRepairDereverbClassical, e7 as masteringRepairTrimSilence, e8 as masteringStereoAnalysisNames, e9 as masteringStereoAnalyze, ea as masteringStreamingPreview, eb as melSpectrogram, ec as melToAudio, ed as melToHz, ee as melToStft, ef as meteringCrestFactorDb, eg as meteringDcOffset, eh as meteringDetectClipping, ei as meteringDynamicRange, ej as meteringPeakDb, ek as meteringPhaseScope, el as meteringPhaseScopeDecimated, em as meteringRmsDb, en as meteringSpectrum, eo as meteringSpectrumFrame, ep as meteringStereoCorrelation, eq as meteringStereoWidth, er as meteringTruePeakDb, es as meteringVectorscope, et as meteringVectorscopeDecimated, eu as mfcc, ev as mfccToAudio, ew as mfccToMel, ex as midiToHz, ey as mixStereo, ez as mixingScenePresetJson, eA as mixingScenePresetNames, eB as momentaryLufs, eC as nnFilter, eD as nnlsChroma, eE as normalize, eF as noteStretch, eG as noteToHz, eH as onsetEnvelope, eI as onsetStrengthMulti, eJ as opfsClipPageWorkerSource, eK as padCenter, eL as pcen, eM as peakPick, eN as percussive, eO as phaseVocoder, eP as pitchCorrectToMidi, eQ as pitchCorrectToMidiTimevarying, eR as pitchPyin, eS as pitchShift, eT as pitchTuning, eU as pitchYin, eV as plp, eW as polyFeatures, eX as powerToDb, eY as preemphasis, eZ as projectAbiVersion, e_ as pseudoCqt, e$ as realtimeVoiceChangerPresetConfig, f0 as realtimeVoiceChangerPresetJson, f1 as realtimeVoiceChangerPresetNames, f2 as remix, f3 as resample, f4 as rmsEnergy, f5 as roomMorph, f6 as samplesToFrames, f7 as scaleCorrectionSemitones, f8 as scalePitchClassEnabled, f9 as scaleQuantizeMidi, fa as shortTermLufs, fb as spectralBandwidth, fc as spectralCentroid, fd as spectralContrast, fe as spectralFlatness, ff as spectralRolloff, fg as splitSilence, fh as stft, fi as stftDb, fj as streamAnalyzerConfigDefaults, fk as synthEnumTables, fl as synthPresetNames, fm as synthPresetPatch, fn as synthesizeRir, fo as tempogram, fp as tempogramRatio, fq as timeStretch, fr as timeToFrames, fs as tonnetz, ft as trim, fu as trimSilence, fv as validateRealtimeVoiceChangerPresetJson, fw as vectorNormalize, fx as version, fy as voiceChange, fz as voiceChangeRealtime, fA as voiceChangerAbiVersion, fB as voiceCharacterPresetId, fC as vqt, fD as waveformPeakPyramid, fE as waveformPeaks, fF as zeroCrossingRate, fG as zeroCrossings } from './worklet.js';
 export { ProgressCallback } from './sonare.js';