smplr 0.20.0 → 0.22.0

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;
 }
@@ -110,6 +115,8 @@ type SmplrSamples = {
  * The top-level smplr.json descriptor. Passed to the Smplr constructor.
  */
 type SmplrJson = {
+    /** Schema version. Omit for the current format. Reserved for future migrations. */
+    smplr?: "1.0";
     meta?: {
         name?: string;
         description?: string;
@@ -260,80 +267,129 @@ type SmplrOptions = {
     /** Called when each voice's audio node ends. */
     onEnded?: (event: NoteEvent) => void;
 };
+
 /**
- * The main sampler class. Loads samples described by a SmplrJson descriptor,
- * matches notes to regions, and plays them through a Channel.
- *
- * Multiple Smplr instances can share a SampleLoader (shared cache) and/or a
- * Scheduler (coordinated timing) by passing them via SmplrOptions.
- *
- * Pattern A — json provided at construction:
- *   `new Smplr(context, json, options?)`
+ * Public Smplr interface — the type plugin authors, helper functions, and
+ * users program against. Mirrors the surface of the underlying SmplrImpl
+ * class, minus internal helpers.
  *
- * Pattern B — json loaded later via loadInstrument():
- *   `new Smplr(context, options?)`  then  `smplr.loadInstrument(json)`
+ * `loadInstrument` is intentionally *not* on this interface — it's the
+ * plugin-side API, exposed via {@link PluginSmplr} to plugin bodies only.
  */
-declare class Smplr {
-    #private;
-    /** Resolves with `this` once all sample buffers are loaded. */
-    readonly load: Promise<Smplr>;
-    /** The AudioContext (or OfflineAudioContext) passed to the constructor. */
+interface Smplr {
     readonly context: BaseAudioContext;
-    constructor(context: BaseAudioContext, json: SmplrJson, options?: SmplrOptions);
-    constructor(context: BaseAudioContext, options?: SmplrOptions);
-    /**
-     * Load (or replace) the instrument descriptor. Creates a new RegionMatcher
-     * and fetches all sample buffers. Pre-loaded buffers (e.g. base64-decoded)
-     * can be passed via the `buffers` parameter — those skip the fetch step.
-     *
-     * Returns a Promise that resolves when all samples are ready.
-     */
-    loadInstrument(json: SmplrJson, buffers?: Map<string, AudioBuffer>): Promise<void>;
-    /** Current loading progress snapshot. `total` is known before loading starts. */
-    get loadProgress(): LoadProgress;
-    /** The output channel — use to add effects, adjust volume, or route audio. */
-    get output(): OutputChannel;
+    /** Resolves when the instrument is ready to play. Preferred over `load`. */
+    readonly ready: Promise<void>;
     /**
-     * Set a MIDI CC value. Affects region matching for groups/regions that have
-     * ccRange constraints (e.g. CC64 sustain pedal).
+     * @deprecated Use `ready` instead. Returns a Promise that resolves to the
+     * instrument for compatibility with `const x = await new X(ctx).load`.
      */
+    readonly load: Promise<Smplr>;
+    readonly output: OutputChannel;
+    /** Shared with other instruments via SmplrOptions.loader. */
+    readonly loader: SampleLoader;
+    /** Shared with other instruments via SmplrOptions.scheduler. */
+    readonly scheduler: Scheduler;
+    readonly loadProgress: LoadProgress;
+    start(event: NoteEvent): StopFn;
+    stop(target?: StopTarget): void;
     setCC(cc: number, value: number): void;
     /**
-     * Start playing a note. Returns a StopFn that cancels the note if it hasn't
-     * played yet, or stops the resulting voices if it has.
+     * 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).
      */
-    start(event: NoteEvent): StopFn;
+    getCC(cc: number): number;
     /**
-     * Stop voices.
-     *
-     * - No argument → stop all active voices
-     * - String or number → stop all voices with that stopId
-     * - `{ stopId }` → stop voices with that stopId, optionally at a future time
-     * - `{ time }` (no stopId) → stop all voices at a future time
+     * 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.
      */
-    stop(target?: StopTarget): void;
+    dispose(): void;
+    /** @deprecated Use `dispose()` instead. */
+    disconnect(): void;
+}
+/**
+ * Plugin-facing widening of {@link Smplr} that exposes `loadInstrument` —
+ * the primary plugin → smplr API for wiring an async-loaded JSON.
+ *
+ * This interface is *not* exported from the package barrel. Plugin authors
+ * receive it as the third argument to their {@link SmplrPlugin}.
+ */
+interface PluginSmplr extends Smplr {
     /**
-     * Stop all voices, disconnect the output channel, and stop the scheduler.
-     * The instance should not be used after this call.
+     * Replace the current instrument JSON and re-fetch buffers. Pre-decoded
+     * buffers (e.g. base64-decoded from a soundfont) can be passed via the
+     * `buffers` parameter.
+     *
+     * Resolves when all samples are ready.
      */
-    disconnect(): void;
+    loadInstrument(json: SmplrJson, buffers?: Map<string, AudioBuffer>): Promise<void>;
 }
-
 /**
- * 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.
+ * Permitted return shapes for an {@link SmplrPlugin}:
  *
- * 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.
+ * - `void` — sync plugin, no async load, no extras
+ * - `Promise<void>` — async load, no extras
+ * - `{ extras: E; ready: Promise<void> }` — sync extras + async load
+ * - `{ ready: Promise<void> }` — async load, no extras (explicit form)
+ *
+ * Extras keys are merged onto the smplr instance via `Object.assign` and
+ * may shadow base {@link Smplr} methods (e.g. DrumMachine overrides `start`
+ * to inject `stopId: sample.note`). For sync extras with no async load,
+ * use `{ extras, ready: Promise.resolve() }`.
  */
-type SpreadResult = {
-    keyRange: [number, number];
-    pitch: number;
-    sample: string;
+type SmplrPluginResult<E extends object> = void | Promise<void> | {
+    extras: E;
+    ready: Promise<void>;
+} | {
+    ready: Promise<void>;
+};
+/**
+ * Plugin signature. Receives the audio context, the user options (with
+ * SmplrOptions keys already stripped by the {@link Instrument} builder),
+ * and a {@link PluginSmplr} the plugin can wire up.
+ */
+type SmplrPlugin<O, E extends object = {}> = (ctx: BaseAudioContext, options: O, smplr: PluginSmplr) => SmplrPluginResult<E>;
+/**
+ * The dual call/construct factory produced by {@link Instrument}. Callable
+ * without `new` (preferred) or with `new` (kept for compatibility with
+ * pre-1.0 examples).
+ */
+/**
+ * The full instance type produced by an {@link InstrumentFactory} — a Smplr
+ * with its plugin extras, plus a `load` Promise refined to resolve back to
+ * the same intersection (so `await x.load` preserves the extras shape).
+ */
+type InstrumentInstance<E extends object = {}> = Smplr & E & {
+    readonly load: Promise<Smplr & E>;
+};
+type InstrumentFactory<O, E extends object = {}> = {
+    (ctx: BaseAudioContext, options?: O & Partial<SmplrOptions>): InstrumentInstance<E>;
+    /**
+     * @deprecated Call as a function: `MyInstrument(ctx, opts)` instead of
+     * `new MyInstrument(...)`. Kept for compatibility with pre-1.0 examples.
+     */
+    new (ctx: BaseAudioContext, options?: O & Partial<SmplrOptions>): InstrumentInstance<E>;
 };
-declare function spreadKeyRanges(samples: [number, string][]): SpreadResult[];
+/**
+ * Builder for smplr instruments. Wraps a plugin function into a dual
+ * call/construct factory that produces ready-to-play {@link Smplr} instances
+ * augmented with plugin extras.
+ *
+ * ```ts
+ * type MyOptions = { instrument: string };
+ *
+ * export const MyInstrument = Instrument<MyOptions>((ctx, options, smplr) => {
+ *   return smplr.loadInstrument(fetchJson(options.instrument));
+ * });
+ *
+ * const inst = MyInstrument(ctx, { instrument: "piano", volume: 80 });
+ * await inst.ready;
+ * inst.start("C4");
+ * ```
+ */
+declare function Instrument<O, E extends object = {}>(plugin: SmplrPlugin<O, E>): InstrumentFactory<O, E>;
 
 type DrumMachineInstrument = {
     baseUrl: string;
@@ -357,24 +413,21 @@ type DrumMachineOptions = Partial<DrumMachineConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>;
-declare class DrumMachine {
-    #private;
-    readonly load: Promise<this>;
-    readonly output: OutputChannel;
-    constructor(context: AudioContext, options?: DrumMachineOptions);
+type DrumMachineExtras = {
     getSampleNames(): string[];
     getGroupNames(): string[];
     getSampleNamesForGroup(groupName: string): string[];
-    start(sample: NoteEvent): StopFn;
-    stop(sample?: StopTarget): void;
-    disconnect(): void;
-    /** @deprecated */
-    loaded(): Promise<this>;
-    /** @deprecated */
-    get sampleNames(): string[];
-    /** @deprecated */
-    getVariations(groupName: string): string[];
-}
+    start(event: NoteEvent): StopFn;
+};
+declare const DrumMachine: InstrumentFactory<Partial<DrumMachineConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    pan?: number;
+    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.
  *
@@ -652,22 +705,24 @@ type ElectricPianoOptions = Partial<{
     /** Audio formats to try, in order of preference. Defaults to ["ogg", "m4a"]. */
     formats: string[];
 }>;
-declare class ElectricPiano {
-    #private;
-    readonly context: AudioContext;
-    readonly load: Promise<this>;
-    readonly tremolo: Readonly<{
+declare const ElectricPiano: InstrumentFactory<Partial<{
+    instrument: string;
+    storage: Storage;
+    destination: AudioNode;
+    volume: number;
+    velocity: number;
+    onLoadProgress: (progress: LoadProgress) => void;
+    /** Audio formats to try, in order of preference. Defaults to ["ogg", "m4a"]. */
+    formats: string[];
+}> & {
+    instrument: string;
+}, {
+    tremolo: Readonly<{
         level: (value: number) => void;
     }>;
-    constructor(context: AudioContext, options: ElectricPianoOptions & {
-        instrument: string;
-    });
-    get output(): OutputChannel;
-    get loadProgress(): LoadProgress;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(target?: StopTarget): void;
-    disconnect(): void;
-}
+}>;
+/** Instance type returned by the {@link ElectricPiano} factory. */
+type ElectricPiano = ReturnType<typeof ElectricPiano>;
 
 declare function getVersilianInstruments(): Promise<string[]>;
 type VersilianConfig = {
@@ -686,23 +741,30 @@ type VersilianOptions = Partial<VersilianConfig & {
  * The Versilian Community Sample Library is an open CC0 general-purpose sample
  * library created by Versilian Studios LLC.
  */
-declare class Versilian {
-    #private;
-    readonly context: BaseAudioContext;
-    readonly load: Promise<this>;
-    constructor(context: BaseAudioContext, options?: VersilianOptions);
-    get output(): OutputChannel;
-    get loadProgress(): LoadProgress;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(target?: StopTarget): void;
-    disconnect(): void;
-}
+declare const Versilian: InstrumentFactory<Partial<VersilianConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    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
+ * package barrel.
+ */
+declare function loadVersilianInstrument(smplr: PluginSmplr, options: VersilianOptions): Promise<void>;
 
-declare function getMalletNames(): MalletName[];
-declare class Mallet extends Versilian {
-    constructor(context: AudioContext, options: VersilianOptions);
-}
-type MalletName = keyof typeof NAME_TO_PATH;
+declare function getMalletNames(): string[];
+declare const Mallet: InstrumentFactory<Partial<VersilianConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    velocity?: number;
+    onLoadProgress?: (progress: LoadProgress) => void;
+}>, {}>;
+/** 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[];
@@ -717,17 +779,15 @@ type MellotronOptions = Partial<MellotronConfig & {
     decayTime?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>;
-declare class Mellotron {
-    #private;
-    readonly context: BaseAudioContext;
-    readonly load: Promise<this>;
-    constructor(context: BaseAudioContext, options?: MellotronOptions);
-    get output(): OutputChannel;
-    get loadProgress(): LoadProgress;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(target?: StopTarget): void;
-    disconnect(): void;
-}
+declare const Mellotron: InstrumentFactory<Partial<MellotronConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    velocity?: number;
+    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;
@@ -772,20 +832,6 @@ type SamplerConfig = {
     volumeToGain: (volume: number) => number;
     onLoadProgress?: (progress: LoadProgress) => void;
 };
-/**
- * A Sampler instrument
- */
-declare class Sampler {
-    #private;
-    readonly context: AudioContext;
-    readonly load: Promise<this>;
-    constructor(context: AudioContext, options?: Partial<SamplerConfig>);
-    loaded(): Promise<this>;
-    get output(): OutputChannel;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(sample?: StopTarget | string | number): void;
-    disconnect(): void;
-}
 type SamplerJsonOptions = Pick<SamplerConfig, "decayTime" | "lpfCutoffHz" | "detune">;
 type InternalConvertResult = {
     json: SmplrJson;
@@ -803,6 +849,12 @@ type InternalConvertResult = {
  * - String URL values → urlMap (fetched asynchronously by caller).
  */
 declare function samplerToSmplrJson(source: Record<string | number, string | AudioBuffer>, options?: Partial<SamplerJsonOptions>): InternalConvertResult;
+/**
+ * A Sampler instrument.
+ */
+declare const Sampler: InstrumentFactory<Partial<SamplerConfig>, {}>;
+/** Instance type returned by the {@link Sampler} factory. */
+type Sampler = ReturnType<typeof Sampler>;
 
 declare function getSmolkenNames(): string[];
 type SmolkenConfig = {
@@ -815,17 +867,14 @@ type SmolkenOptions = Partial<SmolkenConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>;
-declare class Smolken {
-    #private;
-    readonly context: BaseAudioContext;
-    readonly load: Promise<this>;
-    constructor(context: BaseAudioContext, options?: SmolkenOptions);
-    get output(): OutputChannel;
-    get loadProgress(): LoadProgress;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(target?: StopTarget): void;
-    disconnect(): void;
-}
+declare const Smolken: InstrumentFactory<Partial<SmolkenConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    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]>;
 
@@ -846,19 +895,14 @@ type SoundfontOptions = Partial<SoundfontConfig & {
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>;
-declare class Soundfont {
-    #private;
-    readonly context: AudioContext;
-    readonly config: Readonly<SoundfontConfig>;
-    readonly load: Promise<this>;
-    constructor(context: AudioContext, options: SoundfontOptions);
-    get hasLoops(): boolean;
-    get output(): OutputChannel;
-    loaded(): Promise<this>;
-    disconnect(): void;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(sample?: StopTarget | string | number): void;
-}
+declare const Soundfont: InstrumentFactory<Partial<SoundfontConfig & {
+    destination?: AudioNode;
+    volume?: number;
+    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.
  * Uses spreadKeyRanges so notes between recorded pitches pitch-shift correctly.
@@ -901,24 +945,17 @@ type Soundfont2Options = {
     volume?: number;
     velocity?: number;
 };
-declare function sf2InstrumentToSmplrJson(sf2Instrument: Sf2Instrument, context: AudioContext): {
+declare function sf2InstrumentToSmplrJson(sf2Instrument: Sf2Instrument, context: BaseAudioContext): {
     json: SmplrJson;
     buffers: Map<string, AudioBuffer>;
 };
-declare class Soundfont2Sampler {
-    #private;
-    readonly context: AudioContext;
-    readonly options: Soundfont2Options;
-    soundfont: Sf2 | undefined;
-    readonly load: Promise<this>;
-    constructor(context: AudioContext, options: Soundfont2Options);
-    get instrumentNames(): string[];
-    get output(): OutputChannel;
+type Soundfont2SamplerExtras = {
+    readonly instrumentNames: string[];
     loadInstrument(instrumentName: string): Promise<void> | undefined;
-    start(sample: NoteEvent | string | number): StopFn;
-    stop(sample?: StopTarget | string | number): void;
-    disconnect(): void;
-}
+};
+declare const Soundfont2Sampler: InstrumentFactory<Soundfont2Options, Soundfont2SamplerExtras>;
+/** Instance type returned by the {@link Soundfont2Sampler} factory. */
+type Soundfont2Sampler = ReturnType<typeof Soundfont2Sampler>;
 
 /**
  * Configuration options for SplendidGrandPiano.
@@ -946,19 +983,9 @@ type SplendidGrandPianoConfig = {
         velocityRange: [number, number];
     };
 };
-declare class SplendidGrandPiano {
-    #private;
-    readonly context: AudioContext;
-    readonly load: Promise<this>;
-    constructor(context: AudioContext, options?: Partial<SplendidGrandPianoConfig>);
-    get output(): OutputChannel;
-    get loadProgress(): LoadProgress;
-    /** @deprecated Use `load` instead. */
-    loaded(): Promise<this>;
-    start(event: NoteEvent): StopFn;
-    stop(target?: StopTarget): void;
-    disconnect(): void;
-}
+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.
@@ -971,7 +998,6 @@ type PianoJsonOptions = Pick<SplendidGrandPianoConfig, "baseUrl" | "detune" | "d
  * covers, replacing the old on-the-fly `findNearestMidiInLayer` logic.
  */
 declare function pianoToSmplrJson(options: PianoJsonOptions): SmplrJson;
-
 declare const LAYERS: ({
     name: string;
     vel_range: number[];
@@ -984,4 +1010,4 @@ declare const LAYERS: ({
     cutoff?: undefined;
 })[];
 
-export { CacheStorage, DrumMachine, type DrumMachineOptions, ElectricPiano, type ElectricPianoOptions, HttpStorage, 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, Smplr, type SmplrGroup, type SmplrJson, type SmplrOptions, 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, 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, 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 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, trimSilence };