smplr 0.21.0 → 0.23.0

package/README.md

@@ -57,7 +57,7 @@ wav.downloadWav("arpeggio.wav");
 
 See demo: https://danigb.github.io/smplr/
 
-`smplr` is approaching 1.0. The 0.21.0 release is the **1.0 candidate** — the documented surface is intended to ship unchanged into 1.0; the formal stability commitment lands when a handful of coordinated sibling tickets are in (see the 0.21.0 [CHANGELOG](https://github.com/danigb/smplr/blob/main/CHANGELOG.md) entry).
+`smplr` is approaching 1.0. The 0.22.0 release lands the final batch of pre-1.0 API work — every documented `new X(ctx, opts)` keeps working, and the documented surface is intended to ship unchanged into 1.0. The formal stability commitment lands once the narrow `loader`/`scheduler` public interfaces sibling ticket is in (see [CHANGELOG](https://github.com/danigb/smplr/blob/main/CHANGELOG.md)).
 
 > **Upgrading from an earlier 0.x?** No code changes are required — every documented `new X(ctx, opts)` keeps working. New code should drop the `new` (`X(ctx, opts)`) and prefer `await x.ready` over `await x.load`.
 
@@ -254,7 +254,7 @@ Or stop the specified one. The argument is a `stopId` — by default the same va
 
 ```js
 piano.stop("C4"); // stop the note(s) started with `note: "C4"`
-piano.stop(60);   // stop the note(s) started with `note: 60`
+piano.stop(60); // stop the note(s) started with `note: 60`
 ```
 
 #### Schedule notes
@@ -291,14 +291,42 @@ If `loop` is true but `loopStart` or `loopEnd` are not specified, 0 and total du
 
 #### Change volume
 
-Instrument `output` attribute represents the main output of the instrument. `output.setVolume` method accepts a number where 0 means no volume, and 127 is max volume without amplification:
+Instrument `output` attribute represents the main output of the instrument. The `output.volume` getter/setter accepts a number where 0 means no volume, and 127 is max volume without amplification:
 
 ```js
-piano.output.setVolume(80);
+piano.output.volume = 80;
+piano.output.volume; // => 80
 ```
 
+`output.setVolume(n)` is kept as a deprecated alias and continues to work.
+
 ⚠️ `volume` is global to the instrument, but `velocity` is specific for each note.
 
+#### MIDI CC
+
+Set and read MIDI Control Change values on the instrument:
+
+```js
+piano.setCC(64, 127); // sustain pedal on
+piano.getCC(64); // => 127
+piano.setCC(64, 0); // sustain pedal off
+```
+
+Unset CCs default to `0` (matches MIDI's "undefined controller defaults to 0" convention).
+
+#### Disposing
+
+When you're done with an instrument, call `dispose()` to stop all voices, tear down the audio graph, and stop the scheduler. The instance must not be used after this call.
+
+```js
+useEffect(() => {
+  const piano = SplendidGrandPiano(context);
+  return () => piano.dispose();
+}, []);
+```
+
+`disconnect()` is kept as a deprecated alias and continues to work.
+
 #### Events
 
 Two events are supported `onStart` and `onEnded`. Both callbacks will receive as parameter started note.
@@ -345,12 +373,14 @@ const piano = SplendidGrandPiano(context, { volume });
 piano.output.addEffect("reverb", reverb, 0.2);
 ```
 
-To change the mix level, use `output.sendEffect(name, mix)`:
+To change the mix level, use `output.setEffectMix(name, mix)`:
 
 ```js
-piano.output.sendEffect("reverb", 0.5);
+piano.output.setEffectMix("reverb", 0.5);
 ```
 
+`output.sendEffect(name, mix)` is kept as a deprecated alias and continues to work.
+
 ### Cache requests
 
 The default sample sets are hosted on GitHub Pages, which rate-limits requests per second. That can be a problem, especially in a development environment with hot reload (most React frameworks).
@@ -643,10 +673,28 @@ This will download a WAV file you can attach to your issue or pull request.
 
 ## Instruments
 
+### Available instruments
+
+Each instrument family exposes a synchronous helper that returns the names you can pass to its factory:
+
+| Factory         | Names helper                                   |
+| --------------- | ---------------------------------------------- |
+| `Soundfont`     | `getSoundfontNames(): string[]`                |
+| `ElectricPiano` | `getElectricPianoNames(): string[]`            |
+| `Mallet`        | `getMalletNames(): string[]`                   |
+| `Mellotron`     | `getMellotronNames(): string[]`                |
+| `DrumMachine`   | `getDrumMachineNames(): string[]`              |
+| `Smolken`       | `getSmolkenNames(): string[]`                  |
+| `Versilian`     | `getVersilianInstruments(): Promise<string[]>` |
+
+`getVersilianInstruments` is async because the catalog is fetched from the network on first call (cached thereafter).
+
 ### Sampler
 
 An audio buffer sampler. Pass a `buffers` object with the files to be load:
 
+#### Buffers mode
+
 ```js
 import { Sampler } from "smplr";
 
@@ -663,6 +711,37 @@ And then use the name of the buffer as note name:
 sampler.start({ note: "kick" });
 ```
 
+#### Advanced mode
+
+For advanced use cases (per-region pitch/velocity/round-robin, SFZ-like multi-sample instruments, runtime swaps), pass a `SmplrPreset` directly:
+
+```ts
+import { Sampler, type SmplrPreset } from "smplr";
+
+const kitA: SmplrPreset = {
+  samples: { baseUrl: "https://cdn.example.com/", formats: ["ogg"] },
+  groups: [
+    {
+      regions: [
+        { sample: "kick", keyRange: [60, 60], pitch: 60 },
+        { sample: "snare", keyRange: [62, 62], pitch: 62 },
+      ],
+    },
+  ],
+};
+
+const sampler = Sampler(new AudioContext(), { preset: kitA });
+await sampler.ready;
+sampler.start({ note: 60 });
+
+// Swap content at runtime
+await sampler.reload(kitB);
+```
+
+The full `SmplrPreset` schema is documented in [SMPLR_PRESET.md](./SMPLR_PRESET.md). Note: `buffers` and `preset` are mutually exclusive on construction — pass exactly one.
+
+`sampler.reload(input)` accepts either shape (flat buffers record or full `SmplrPreset`), regardless of which mode was used at construction.
+
 ### Soundfont
 
 A Soundfont player. By default it loads audio from Benjamin Gleitzman's package of

package/dist/index.d.mts

@@ -17,15 +17,20 @@ type OutputChannel = Omit<Channel, "input">;
 declare class Channel {
     #private;
     readonly context: BaseAudioContext;
+    /** @deprecated Use `output.volume = n` instead. */
     readonly setVolume: (vol: number) => void;
     readonly input: AudioNode;
     constructor(context: BaseAudioContext, options?: Partial<ChannelConfig>);
+    get volume(): number;
+    set volume(value: number);
     get pan(): number;
     set pan(value: number);
     addInsert(effect: AudioNode | AudioInsert): void;
     addEffect(name: string, effect: AudioNode | {
         input: AudioNode;
     }, mixValue: number): void;
+    setEffectMix(name: string, mix: number): void;
+    /** @deprecated Use `setEffectMix(name, mix)` instead. */
     sendEffect(name: string, mix: number): void;
     disconnect(): void;
 }
@@ -109,7 +114,9 @@ type SmplrSamples = {
 /**
  * The top-level smplr.json descriptor. Passed to the Smplr constructor.
  */
-type SmplrJson = {
+type SmplrPreset = {
+    /** Schema version. Omit for the current format. Reserved for future migrations. */
+    smplr?: "1.0";
     meta?: {
         name?: string;
         description?: string;
@@ -183,7 +190,7 @@ type VoiceParams = {
 };
 
 /**
- * Loads and caches AudioBuffers for all samples referenced in a SmplrJson.
+ * Loads and caches AudioBuffers for all samples referenced in a SmplrPreset.
  *
  * The cache is keyed by resolved URL, so the same audio file is never fetched
  * or decoded twice. Multiple Smplr instances can share one SampleLoader by
@@ -202,7 +209,7 @@ declare class SampleLoader {
      * - `buffers` in options: pre-loaded buffers — skips fetch for these names.
      * - All samples load in parallel. Failed samples are silently omitted.
      */
-    load(json: SmplrJson, onProgressOrOptions?: ((loaded: number, total: number) => void) | {
+    load(json: SmplrPreset, onProgressOrOptions?: ((loaded: number, total: number) => void) | {
         buffers?: Map<string, AudioBuffer>;
         onProgress?: (loaded: number, total: number) => void;
     }): Promise<Map<string, AudioBuffer>>;
@@ -287,6 +294,19 @@ interface Smplr {
     start(event: NoteEvent): StopFn;
     stop(target?: StopTarget): void;
     setCC(cc: number, value: number): void;
+    /**
+     * Read the latest value set via `setCC`. Returns `0` for any CC that has
+     * not been set (matches MIDI's "undefined controller defaults to 0" convention).
+     */
+    getCC(cc: number): number;
+    /**
+     * Stop all voices, dispose the output channel, and stop the scheduler.
+     * The instance must not be used after this call — subsequent `start`/`stop`/
+     * `setCC`/`getCC`/`setControlValue`/`loadInstrument` calls throw. Subsequent
+     * `dispose()` calls are no-ops.
+     */
+    dispose(): void;
+    /** @deprecated Use `dispose()` instead. */
     disconnect(): void;
 }
 /**
@@ -304,7 +324,7 @@ interface PluginSmplr extends Smplr {
      *
      * Resolves when all samples are ready.
      */
-    loadInstrument(json: SmplrJson, buffers?: Map<string, AudioBuffer>): Promise<void>;
+    loadInstrument(json: SmplrPreset, buffers?: Map<string, AudioBuffer>): Promise<void>;
 }
 /**
  * Permitted return shapes for an {@link SmplrPlugin}:
@@ -406,14 +426,16 @@ declare const DrumMachine: InstrumentFactory<Partial<DrumMachineConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, DrumMachineExtras>;
+/** Instance type returned by the {@link DrumMachine} factory. */
+type DrumMachine = ReturnType<typeof DrumMachine>;
 /**
- * Convert a DrumMachineInstrument to a SmplrJson descriptor.
+ * Convert a DrumMachineInstrument to a SmplrPreset descriptor.
  *
  * Each sample gets a sequential MIDI number starting at 36 (GM drum map base).
  * Aliases are created for both the full sample name ("kick/1") and the group
  * name ("kick") so both forms work with Smplr.start({ note: "kick" }).
  */
-declare function drumMachineToSmplrJson(instrument: DrumMachineInstrument): SmplrJson;
+declare function drumMachineToPreset(instrument: DrumMachineInstrument): SmplrPreset;
 
 /**
  * The result of an offline render. Provides the raw AudioBuffer and
@@ -482,22 +504,6 @@ declare function audioBufferToWav16(buffer: AudioBuffer): Blob;
  */
 declare function trimSilence(buffer: AudioBuffer): AudioBuffer;
 
-/**
- * Given a list of [midi, sampleName] pairs, return one entry per sample with
- * a keyRange that covers all MIDI notes closer to that sample than to any
- * neighbour. The first sample extends down to 0; the last extends up to 127.
- *
- * The boundary between two adjacent samples A and B (A < B) is placed at
- * `floor((A + B) / 2)`, matching the behaviour of the old `findNearestMidiInLayer`
- * which always resolved ties in favour of the lower sample.
- */
-type SpreadResult = {
-    keyRange: [number, number];
-    pitch: number;
-    sample: string;
-};
-declare function spreadKeyRanges(samples: [number, string][]): SpreadResult[];
-
 /**
  * TransportClock
  *
@@ -715,6 +721,8 @@ declare const ElectricPiano: InstrumentFactory<Partial<{
         level: (value: number) => void;
     }>;
 }>;
+/** Instance type returned by the {@link ElectricPiano} factory. */
+type ElectricPiano = ReturnType<typeof ElectricPiano>;
 
 declare function getVersilianInstruments(): Promise<string[]>;
 type VersilianConfig = {
@@ -739,6 +747,8 @@ declare const Versilian: InstrumentFactory<Partial<VersilianConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, {}>;
+/** Instance type returned by the {@link Versilian} factory. */
+type Versilian = ReturnType<typeof Versilian>;
 /**
  * Fetch the SFZ for a VCSL instrument and load it into `smplr`. Shared by
  * the {@link Versilian} and {@link Mallet} factories — not exported from the
@@ -746,14 +756,15 @@ declare const Versilian: InstrumentFactory<Partial<VersilianConfig & {
  */
 declare function loadVersilianInstrument(smplr: PluginSmplr, options: VersilianOptions): Promise<void>;
 
-declare function getMalletNames(): MalletName[];
+declare function getMalletNames(): string[];
 declare const Mallet: InstrumentFactory<Partial<VersilianConfig & {
     destination?: AudioNode;
     volume?: number;
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, {}>;
-type MalletName = keyof typeof NAME_TO_PATH;
+/** Instance type returned by the {@link Mallet} factory. */
+type Mallet = ReturnType<typeof Mallet>;
 declare const NAME_TO_PATH: Record<string, string | undefined>;
 
 declare function getMellotronNames(): string[];
@@ -775,19 +786,21 @@ declare const Mellotron: InstrumentFactory<Partial<MellotronConfig & {
     decayTime?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, {}>;
+/** Instance type returned by the {@link Mellotron} factory. */
+type Mellotron = ReturnType<typeof Mellotron>;
 type MellotronJsonConfig = {
     instrument: string;
     variation?: string;
 };
 /**
- * Convert a Mellotron files.json sample list to SmplrJson.
+ * Convert a Mellotron files.json sample list to SmplrPreset.
  *
  * - Filters by variation string if provided.
  * - Extracts MIDI from the first word of each sample name.
  * - Uses spreadKeyRanges so nearby notes pitch-shift to the nearest sample.
  * - All regions get loopAuto to produce tape-loop playback.
  */
-declare function mellotronToSmplrJson(sampleNames: string[], config: MellotronJsonConfig): SmplrJson;
+declare function mellotronToPreset(sampleNames: string[], config: MellotronJsonConfig): SmplrPreset;
 
 declare const PARAMS: readonly ["preDelay", "bandwidth", "inputDiffusion1", "inputDiffusion2", "decay", "decayDiffusion1", "decayDiffusion2", "damping", "excursionRate", "excursionDepth", "wet", "dry"];
 declare class Reverb {
@@ -807,30 +820,40 @@ type AudioBuffers = Record<string | number, AudioBuffer | undefined>;
  */
 type AudioBuffersLoader = (context: BaseAudioContext, buffers: AudioBuffers) => Promise<void>;
 
-type SamplerConfig = {
+type SamplerBase = {
     storage?: Storage;
-    detune: number;
-    volume: number;
-    velocity: number;
+    detune?: number;
+    volume?: number;
+    velocity?: number;
     decayTime?: number;
     lpfCutoffHz?: number;
-    destination: AudioNode;
-    buffers: Record<string | number, string | AudioBuffer | AudioBuffers> | AudioBuffersLoader;
-    volumeToGain: (volume: number) => number;
+    destination?: AudioNode;
+    volumeToGain?: (volume: number) => number;
     onLoadProgress?: (progress: LoadProgress) => void;
 };
-/**
- * A Sampler instrument.
- */
-declare const Sampler: InstrumentFactory<Partial<SamplerConfig>, {}>;
+type SamplerBuffers = Record<string | number, string | AudioBuffer | AudioBuffers> | AudioBuffersLoader;
+type SamplerBuffersInput = {
+    buffers?: SamplerBuffers;
+    preset?: never;
+};
+type SamplerPresetInput = {
+    preset: SmplrPreset;
+    buffers?: never;
+};
+type SamplerConfig = SamplerBase & (SamplerBuffersInput | SamplerPresetInput);
+/** Input accepted by {@link Sampler.reload}: a `SmplrPreset` schema or a flat buffers record/loader. */
+type SamplerReloadInput = SmplrPreset | SamplerBuffers;
+type SamplerExtras = {
+    reload: (input: SamplerReloadInput) => Promise<void>;
+};
 type SamplerJsonOptions = Pick<SamplerConfig, "decayTime" | "lpfCutoffHz" | "detune">;
 type InternalConvertResult = {
-    json: SmplrJson;
+    json: SmplrPreset;
     urlMap: Record<string, string>;
     preloaded: Map<string, AudioBuffer>;
 };
 /**
- * Convert a flat source Record to SmplrJson + separated URL map + pre-loaded buffers.
+ * Convert a flat source Record to SmplrPreset + separated URL map + pre-loaded buffers.
  *
  * - Keys that are valid MIDI names/numbers → MIDI-mapped regions.
  *   If ALL keys are MIDI-parseable, spread key ranges (pitch-shifting).
@@ -839,7 +862,20 @@ type InternalConvertResult = {
  * - AudioBuffer values → pre-loaded map (no fetch).
  * - String URL values → urlMap (fetched asynchronously by caller).
  */
-declare function samplerToSmplrJson(source: Record<string | number, string | AudioBuffer>, options?: Partial<SamplerJsonOptions>): InternalConvertResult;
+declare function samplerToPreset(source: Record<string | number, string | AudioBuffer>, options?: Partial<SamplerJsonOptions>): InternalConvertResult;
+/**
+ * A Sampler instrument. Accepts either a flat record of samples
+ * (`{ buffers: { C4: "url" } }`) or a full `SmplrPreset`
+ * (`{ preset: { samples, groups, ... } }`) for advanced use cases including
+ * per-region pitch/velocity/round-robin control.
+ *
+ * Use `sampler.reload(input)` to swap content at runtime. `reload` accepts
+ * either shape (flat record or `SmplrPreset`), regardless of which mode was
+ * used at construction.
+ */
+declare const Sampler: InstrumentFactory<SamplerConfig, SamplerExtras>;
+/** Instance type returned by the {@link Sampler} factory. */
+type Sampler = ReturnType<typeof Sampler>;
 
 declare function getSmolkenNames(): string[];
 type SmolkenConfig = {
@@ -858,6 +894,8 @@ declare const Smolken: InstrumentFactory<Partial<SmolkenConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, {}>;
+/** Instance type returned by the {@link Smolken} factory. */
+type Smolken = ReturnType<typeof Smolken>;
 
 type LoopData = Record<number, [number, number]>;
 
@@ -884,11 +922,13 @@ declare const Soundfont: InstrumentFactory<Partial<SoundfontConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>, {}>;
+/** Instance type returned by the {@link Soundfont} factory. */
+type Soundfont = ReturnType<typeof Soundfont>;
 /**
- * Convert a list of note names (with optional loop data) to SmplrJson.
+ * Convert a list of note names (with optional loop data) to SmplrPreset.
  * Uses spreadKeyRanges so notes between recorded pitches pitch-shift correctly.
  */
-declare function soundfontToSmplrJson(noteNames: string[], loopData?: LoopData): SmplrJson;
+declare function soundfontToPreset(noteNames: string[], loopData?: LoopData): SmplrPreset;
 
 type Sf2 = {
     instruments: Sf2Instrument[];
@@ -926,8 +966,8 @@ type Soundfont2Options = {
     volume?: number;
     velocity?: number;
 };
-declare function sf2InstrumentToSmplrJson(sf2Instrument: Sf2Instrument, context: BaseAudioContext): {
-    json: SmplrJson;
+declare function sf2InstrumentToPreset(sf2Instrument: Sf2Instrument, context: BaseAudioContext): {
+    json: SmplrPreset;
     buffers: Map<string, AudioBuffer>;
 };
 type Soundfont2SamplerExtras = {
@@ -935,6 +975,8 @@ type Soundfont2SamplerExtras = {
     loadInstrument(instrumentName: string): Promise<void> | undefined;
 };
 declare const Soundfont2Sampler: InstrumentFactory<Soundfont2Options, Soundfont2SamplerExtras>;
+/** Instance type returned by the {@link Soundfont2Sampler} factory. */
+type Soundfont2Sampler = ReturnType<typeof Soundfont2Sampler>;
 
 /**
  * Configuration options for SplendidGrandPiano.
@@ -946,7 +988,7 @@ type SplendidGrandPianoConfig = {
     detune: number;
     /** Default velocity (0–127) when not specified per note. */
     velocity: number;
-    /** Release time in seconds. Maps to SmplrJson defaults.ampRelease. */
+    /** Release time in seconds. Maps to SmplrPreset defaults.ampRelease. */
     decayTime: number;
     /** Destination audio node. Defaults to context.destination. */
     destination?: AudioNode;
@@ -963,9 +1005,11 @@ type SplendidGrandPianoConfig = {
     };
 };
 declare const SplendidGrandPiano: InstrumentFactory<Partial<SplendidGrandPianoConfig>, {}>;
+/** Instance type returned by the {@link SplendidGrandPiano} factory. */
+type SplendidGrandPiano = ReturnType<typeof SplendidGrandPiano>;
 type PianoJsonOptions = Pick<SplendidGrandPianoConfig, "baseUrl" | "detune" | "decayTime" | "notesToLoad" | "formats">;
 /**
- * Convert the LAYERS array and user options into a SmplrJson descriptor.
+ * Convert the LAYERS array and user options into a SmplrPreset descriptor.
  *
  * Each layer becomes a SmplrGroup with its velRange. If `notesToLoad` is
  * specified, layers and samples are filtered accordingly. The PPP layer
@@ -974,8 +1018,7 @@ type PianoJsonOptions = Pick<SplendidGrandPianoConfig, "baseUrl" | "detune" | "d
  * `spreadKeyRanges` is used to pre-compute which key range each sample
  * covers, replacing the old on-the-fly `findNearestMidiInLayer` logic.
  */
-declare function pianoToSmplrJson(options: PianoJsonOptions): SmplrJson;
-
+declare function pianoToPreset(options: PianoJsonOptions): SmplrPreset;
 declare const LAYERS: ({
     name: string;
     vel_range: number[];
@@ -988,4 +1031,4 @@ declare const LAYERS: ({
     cutoff?: undefined;
 })[];
 
-export { CacheStorage, DrumMachine, type DrumMachineOptions, ElectricPiano, type ElectricPianoOptions, HttpStorage, Instrument, LAYERS, type LoadProgress, Mallet, Mellotron, type MellotronConfig, type MellotronOptions, NAME_TO_PATH, type NoteEvent, type PlaybackParams, type RenderOfflineOptions, RenderResult, Reverb, SampleLoader, Sampler, type SamplerConfig, Scheduler, Sequencer, type SequencerInstrument, type SequencerNote, type SequencerNoteEvent, type SequencerOptions, Smolken, type SmolkenConfig, type SmolkenOptions, type Smplr, type SmplrGroup, type SmplrJson, type SmplrOptions, type SmplrPlugin, type SmplrRegion, type SmplrSamples, Soundfont, type Soundfont2Options, Soundfont2Sampler, type SoundfontOptions, SplendidGrandPiano, type SplendidGrandPianoConfig, type SpreadResult, type StopFn, type StopTarget, type Storage, type StorageResponse, Versilian, type VersilianConfig, type VersilianOptions, type VoiceParams, audioBufferToWav, audioBufferToWav16, drumMachineToSmplrJson, getDrumMachineNames, getElectricPianoNames, getMalletNames, getMellotronNames, getSmolkenNames, getSoundfontKits, getSoundfontNames, getVersilianInstruments, loadVersilianInstrument, mellotronToSmplrJson, pianoToSmplrJson, renderOffline, samplerToSmplrJson, sf2InstrumentToSmplrJson, soundfontToSmplrJson, spreadKeyRanges, trimSilence };
+export { CacheStorage, DrumMachine, type DrumMachineOptions, ElectricPiano, type ElectricPianoOptions, HttpStorage, Instrument, LAYERS, type LoadProgress, Mallet, Mellotron, type MellotronConfig, type MellotronOptions, NAME_TO_PATH, type NoteEvent, type PlaybackParams, type RenderOfflineOptions, RenderResult, Reverb, SampleLoader, Sampler, type SamplerConfig, type SamplerReloadInput, Scheduler, Sequencer, type SequencerInstrument, type SequencerNote, type SequencerNoteEvent, type SequencerOptions, Smolken, type SmolkenConfig, type SmolkenOptions, type Smplr, type SmplrGroup, type SmplrOptions, type SmplrPlugin, type SmplrPreset, type SmplrRegion, type SmplrSamples, Soundfont, type Soundfont2Options, Soundfont2Sampler, type SoundfontOptions, SplendidGrandPiano, type SplendidGrandPianoConfig, type StopFn, type StopTarget, type Storage, type StorageResponse, Versilian, type VersilianConfig, type VersilianOptions, type VoiceParams, audioBufferToWav, audioBufferToWav16, drumMachineToPreset, getDrumMachineNames, getElectricPianoNames, getMalletNames, getMellotronNames, getSmolkenNames, getSoundfontKits, getSoundfontNames, getVersilianInstruments, loadVersilianInstrument, mellotronToPreset, pianoToPreset, renderOffline, samplerToPreset, sf2InstrumentToPreset, soundfontToPreset, trimSilence };