smplr 0.18.0 → 0.19.0

package/README.md

@@ -349,9 +349,9 @@ seq.addTrack(piano, [
 ]);
 
 seq.addTrack(drums, [
-  { note: "kick",  at: "1:1" },
+  { note: "kick", at: "1:1" },
   { note: "snare", at: "1:2" },
-  { note: "kick",  at: "1:3" },
+  { note: "kick", at: "1:3" },
   { note: "snare", at: "1:4" },
 ]);
 
@@ -363,60 +363,68 @@ seq.start();
 
 Note positions and durations accept several formats:
 
-| Format      | Meaning                              |
-|-------------|--------------------------------------|
-| `"4n"`      | quarter note                         |
-| `"8n"`      | eighth note                          |
-| `"4n."`     | dotted quarter (1.5×)                |
-| `"1m"`      | one measure                          |
-| `"2:1"`     | bar 2, beat 1 (1-indexed)            |
-| `"2:3:48"`  | bar 2, beat 3, +48 ticks             |
-| `96`        | raw ticks (number passthrough)       |
+| Format     | Meaning                        |
+| ---------- | ------------------------------ |
+| `"4n"`     | quarter note                   |
+| `"8n"`     | eighth note                    |
+| `"4n."`    | dotted quarter (1.5×)          |
+| `"1m"`     | one measure                    |
+| `"2:1"`    | bar 2, beat 1 (1-indexed)      |
+| `"2:3:48"` | bar 2, beat 3, +48 ticks       |
+| `96`       | raw ticks (number passthrough) |
 
 #### Constructor options
 
 ```js
 const seq = new Sequencer(context, {
-  bpm: 120,            // default 120
-  ppq: 480,            // pulses per quarter note, default 480
-  timeSignature: 4,    // beats per bar, default 4
-  loop: false,         // default false
-  loopStart: 0,        // loop start position (ticks or string)
-  loopEnd: "2:1",      // loop end position; defaults to end of longest track
-  lookaheadMs: 200,    // scheduling lookahead, default 200
-  intervalMs: 50,      // flush interval, default 50
-  humanize: { timing: 0.01, velocity: 8 }, // optional randomisation
+  bpm: 120, // default 120
+  ppq: 480, // pulses per quarter note, default 480
+  timeSignature: 4, // beats per bar, default 4
+  loop: false, // default false
+  loopStart: 0, // loop start position (ticks or string)
+  loopEnd: "2:1", // loop end position; defaults to end of longest track
+  lookaheadMs: 200, // scheduling lookahead, default 200
+  intervalMs: 50, // flush interval, default 50
+  humanize: { timingMs: 10, velocity: 8 }, // optional randomisation
 });
 ```
 
 #### Playback
 
 ```js
-seq.start();   // start from beginning (or resume from pause if no offset given)
-seq.pause();   // freeze position
-seq.stop();    // stop and reset to 0
+seq.start(); // start from beginning (or resume from pause if no offset given)
+seq.pause(); // freeze position
+seq.stop(); // stop and reset to 0
+seq.togglePlayPause(); // pause if playing, start/resume otherwise
 
-seq.state;     // "stopped" | "playing" | "paused"
+seq.state; // "stopped" | "playing" | "paused"
+```
+
+Individual sequenced notes can be stopped by their id:
+
+```js
+seq.stopNote("intro-c"); // stop immediately
+seq.stopNote("intro-c", time); // stop at a scheduled time
 ```
 
 #### Tempo and position
 
 ```js
-seq.bpm = 140;            // change BPM live, no glitch
-seq.timeSignature = 3;    // change time signature
+seq.bpm = 140; // change BPM live, no glitch
+seq.timeSignature = 3; // change time signature
 
-seq.position;             // current position as "bar:beat:tick" string
-seq.position = "3:1";     // seek while playing or stopped
+seq.position; // current position as "bar:beat:tick" string
+seq.position = "3:1"; // seek while playing or stopped
 ```
 
 #### Loop
 
 ```js
 seq.loop = true;
-seq.loopStart = "1:1";  // ticks or string notation
-seq.loopEnd   = "3:1";  // ticks or string notation
+seq.loopStart = "1:1"; // ticks or string notation
+seq.loopEnd = "3:1"; // ticks or string notation
 
-seq.progress;            // 0..1 within the loop range
+seq.progress; // 0..1 within the loop range
 ```
 
 #### Pattern API
@@ -440,19 +448,30 @@ seq.scheduleRepeat(callback, "4n", "2:1"); // start at bar 2
 #### Events
 
 ```js
+seq.on("statechange", (state) => {
+  // state: "playing" | "paused" | "stopped"
+  setSeqState(state);
+});
+
 seq.on("beat", (beat, time) => {
   const delay = (time - context.currentTime) * 1000;
   setTimeout(() => metronome.flash(), delay);
 });
 
-seq.on("bar",  (bar, time)  => { ui.updateBar(bar); });
-seq.on("loop", ()           => { console.log("looped"); });
-seq.on("end",  ()           => { console.log("done"); });
-seq.on("start", ()          => { });
-seq.on("stop",  ()          => { });
-seq.on("pause", ()          => { });
+seq.on("bar", (bar, time) => {
+  ui.updateBar(bar);
+});
+seq.on("loop", () => {
+  console.log("looped");
+});
+seq.on("end", () => {
+  console.log("done");
+});
+seq.on("start", () => {});
+seq.on("stop", () => {});
+seq.on("pause", () => {});
 
-seq.off("beat", handler);  // remove a listener
+seq.off("beat", handler); // remove a listener
 ```
 
 #### Note events
@@ -471,12 +490,12 @@ seq.on("noteOff", (event) => {
 
 The `event` object (`NoteEvent`) contains:
 
-| Field        | Type               | Description                                      |
-|--------------|--------------------|--------------------------------------------------|
+| Field        | Type               | Description                                            |
+| ------------ | ------------------ | ------------------------------------------------------ |
 | `noteId`     | `string \| number` | The note's `id` if provided, otherwise its array index |
-| `trackIndex` | `number`           | Index of the track in the order it was added      |
-| `noteIndex`  | `number`           | Index of the note within its track's notes array  |
-| `note`       | `SequencerNote`    | The original note object                          |
+| `trackIndex` | `number`           | Index of the track in the order it was added           |
+| `noteIndex`  | `number`           | Index of the note within its track's notes array       |
+| `note`       | `SequencerNote`    | The original note object                               |
 
 You can set a custom `id` on any `SequencerNote` to use as `noteId`:
 
@@ -489,15 +508,18 @@ seq.addTrack(piano, [
 
 #### Humanize
 
-Add subtle randomisation to timing (seconds) and velocity for a more natural feel:
+Add subtle randomisation to timing and velocity for a more natural feel:
 
 ```js
 const seq = new Sequencer(context, {
   bpm: 90,
-  humanize: { timing: 0.012, velocity: 8 },
+  humanize: { timingMs: 12, velocity: 8 },
 });
 ```
 
+- `timingMs`: maximum random offset in milliseconds (±). Default 0.
+- `velocity`: maximum random offset in MIDI velocity units (±). Default 0.
+
 ---
 
 ## Instruments

package/dist/index.d.mts

@@ -7,6 +7,7 @@ type ChannelConfig = {
     destination: AudioNode;
     volume: number;
     volumeToGain: (volume: number) => number;
+    pan?: number;
 };
 type OutputChannel = Omit<Channel, "input">;
 /**
@@ -19,6 +20,8 @@ declare class Channel {
     readonly setVolume: (vol: number) => void;
     readonly input: AudioNode;
     constructor(context: BaseAudioContext, options?: Partial<ChannelConfig>);
+    get pan(): number;
+    set pan(value: number);
     addInsert(effect: AudioNode | AudioInsert): void;
     addEffect(name: string, effect: AudioNode | {
         input: AudioNode;
@@ -58,6 +61,7 @@ type PlaybackParams = {
     loop?: boolean;
     loopStart?: number;
     loopEnd?: number;
+    reverse?: boolean;
 };
 /**
  * An individual sample region. Maps a sample to a range of notes and velocities.
@@ -122,7 +126,7 @@ type SmplrJson = {
 /**
  * A note event passed to Smplr.start(). Can be a full object, a note name, or a MIDI number.
  */
-type NoteEvent$1 = {
+type NoteEvent = {
     note: string | number;
     velocity?: number;
     time?: number;
@@ -132,8 +136,9 @@ type NoteEvent$1 = {
     loop?: boolean;
     ampRelease?: number;
     stopId?: string | number;
-    onStart?: (event: NoteEvent$1) => void;
-    onEnded?: (event: NoteEvent$1) => void;
+    onStart?: (event: NoteEvent) => void;
+    onEnded?: (event: NoteEvent) => void;
+    reverse?: boolean;
 } | string | number;
 /**
  * Target for Smplr.stop(). Can be a full object, a stopId, or a MIDI number.
@@ -153,6 +158,166 @@ type LoadProgress = {
     loaded: number;
     total: number;
 };
+/**
+ * Fully resolved playback parameters for a single Voice.
+ * Output of resolveParams() — all fields are required, no optionals except ampVelCurve/loopAuto.
+ */
+type VoiceParams = {
+    detune: number;
+    velocity: number;
+    volume: number;
+    ampRelease: number;
+    ampAttack: number;
+    lpfCutoffHz: number;
+    offset: number;
+    loop: boolean;
+    loopStart: number;
+    loopEnd: number;
+    ampVelCurve?: [number, number];
+    /** If set, loop points are computed from buffer.duration at play time. */
+    loopAuto?: {
+        startRatio: number;
+        endRatio: number;
+    };
+    reverse?: boolean;
+};
+
+/**
+ * Loads and caches AudioBuffers for all samples referenced in a SmplrJson.
+ *
+ * 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
+ * passing it via SmplrOptions.loader.
+ */
+declare class SampleLoader {
+    #private;
+    constructor(context: BaseAudioContext, options?: {
+        storage?: Storage;
+    });
+    /**
+     * Load all samples referenced in `json`. Returns a Map of sample name →
+     * AudioBuffer. Progress is reported via `onProgress` callback or via
+     * options object.
+     *
+     * - `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) | {
+        buffers?: Map<string, AudioBuffer>;
+        onProgress?: (loaded: number, total: number) => void;
+    }): Promise<Map<string, AudioBuffer>>;
+}
+
+/**
+ * Standalone scheduler. Dispatches NoteEvents immediately when they fall within the
+ * lookahead window, or queues them for future dispatch via a self-managing interval.
+ *
+ * Multiple Smplr instances can share a single Scheduler for coordinated timing.
+ */
+declare class Scheduler {
+    #private;
+    constructor(context: BaseAudioContext, options?: {
+        lookaheadMs?: number;
+        intervalMs?: number;
+    });
+    /**
+     * Schedule a callback for a NoteEvent.
+     *
+     * - If the event's time falls within the lookahead window (or has no time), the
+     *   callback is called synchronously and a no-op StopFn is returned.
+     * - Otherwise the event is queued, the interval is started if needed, and a StopFn
+     *   is returned that removes the event from the queue before it is dispatched.
+     */
+    schedule(event: NoteEvent, callback: (event: NoteEvent) => void): StopFn;
+    /**
+     * Clear all queued (not-yet-dispatched) events and stop the interval.
+     * Does not affect voices that are already playing.
+     */
+    stop(): void;
+}
+
+type SmplrOptions = {
+    /** Custom storage backend for sample fetching (e.g. CacheStorage). */
+    storage?: Storage;
+    /** Destination audio node. Defaults to context.destination. */
+    destination?: AudioNode;
+    /** Master volume (0–127 MIDI scale). Defaults to 100. */
+    volume?: number;
+    /** Custom volume-to-gain mapping function. Defaults to midiVelToGain. */
+    volumeToGain?: (volume: number) => number;
+    /** Stereo pan position (-1 = full left, 0 = centre, +1 = full right). Defaults to 0. */
+    pan?: number;
+    /** Default note velocity when not specified in NoteEvent (0–127). Defaults to 100. */
+    velocity?: number;
+    /** Shared SampleLoader instance. If omitted, a private one is created. */
+    loader?: SampleLoader;
+    /** Shared Scheduler instance. If omitted, a private one is created. */
+    scheduler?: Scheduler;
+    /** Called after each buffer is loaded (or served from cache). */
+    onLoadProgress?: (progress: LoadProgress) => void;
+    /** Called when a note is dispatched to the audio engine (slightly before playback). */
+    onStart?: (event: NoteEvent) => void;
+    /** 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?)`
+ *
+ * Pattern B — json loaded later via loadInstrument():
+ *   `new Smplr(context, options?)`  then  `smplr.loadInstrument(json)`
+ */
+declare class Smplr {
+    #private;
+    /** Resolves with `this` once all sample buffers are loaded. */
+    readonly load: Promise<Smplr>;
+    /** The AudioContext passed to the constructor. */
+    readonly context: AudioContext;
+    constructor(context: AudioContext, json: SmplrJson, options?: SmplrOptions);
+    constructor(context: AudioContext, 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;
+    /**
+     * Set a MIDI CC value. Affects region matching for groups/regions that have
+     * ccRange constraints (e.g. CC64 sustain pedal).
+     */
+    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.
+     */
+    start(event: NoteEvent): StopFn;
+    /**
+     * 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(target?: StopTarget): void;
+    /**
+     * Stop all voices, disconnect the output channel, and stop the scheduler.
+     * The instance should not be used after this call.
+     */
+    disconnect(): void;
+}
 
 /**
  * Given a list of [midi, sampleName] pairs, return one entry per sample with
@@ -188,6 +353,7 @@ type DrumMachineConfig = {
 type DrumMachineOptions = Partial<DrumMachineConfig & {
     destination?: AudioNode;
     volume?: number;
+    pan?: number;
     velocity?: number;
     onLoadProgress?: (progress: LoadProgress) => void;
 }>;
@@ -199,7 +365,7 @@ declare class DrumMachine {
     getSampleNames(): string[];
     getGroupNames(): string[];
     getSampleNamesForGroup(groupName: string): string[];
-    start(sample: NoteEvent$1): StopFn;
+    start(sample: NoteEvent): StopFn;
     stop(sample?: StopTarget): void;
     disconnect(): void;
     /** @deprecated */
@@ -246,6 +412,8 @@ type SequencerNote = {
     /** Note duration: ticks, "4n", "8n", etc. Omit for a one-shot trigger. */
     duration?: string | number;
     velocity?: number;
+    /** Probability (0–100) that this note fires on each pass. Default 100 (always). */
+    chance?: number;
 };
 /**
  * Any instrument the Sequencer can drive.
@@ -259,16 +427,12 @@ type SequencerInstrument = {
         duration?: number;
         velocity?: number;
         noteId?: string | number;
-        onStart?: (event: {
-            noteId?: string | number;
-        }) => void;
-        onEnded?: (event: {
-            noteId?: string | number;
-        }) => void;
+        onStart?: (event: unknown) => void;
+        onEnded?: (event: unknown) => void;
     }): unknown;
 };
 /** Emitted with "noteOn" and "noteOff" events. */
-type NoteEvent = {
+type SequencerNoteEvent = {
     noteId: string | number;
     trackIndex: number;
     noteIndex: number;
@@ -285,17 +449,20 @@ type SequencerOptions = {
     lookaheadMs?: number;
     /** How often (ms) the flush loop runs. Default 50. */
     intervalMs?: number;
-    /** Randomise timing (seconds) and velocity per note for a human feel. */
+    /** Randomise timing (ms) and velocity per note for a human feel. */
     humanize?: {
-        timing?: number;
+        timingMs?: number;
         velocity?: number;
     };
+    /** Emit a "step" event at this interval. Accepts musical notation or ticks: "16n", "8n", ticks, etc. */
+    stepSize?: string | number;
 };
 declare class Sequencer {
     private readonly _context;
     private readonly _clock;
     private readonly _ppq;
     private _timeSignature;
+    private _stepTicks;
     private _tracks;
     private _repeatEvents;
     private _listeners;
@@ -313,6 +480,8 @@ declare class Sequencer {
     private _totalTicks;
     /** Guards against scheduling the auto-stop setTimeout more than once. */
     private _endScheduled;
+    /** Active voices keyed by noteId, so individual notes can be stopped. */
+    private _activeVoices;
     constructor(context: BaseAudioContext, options?: SequencerOptions);
     addTrack(instrument: SequencerInstrument, notes: SequencerNote[]): this;
     removeTrack(instrument: SequencerInstrument): this;
@@ -324,6 +493,16 @@ declare class Sequencer {
     start(offsetTick?: number): this;
     pause(): this;
     stop(): this;
+    /**
+     * Stop a single note that was scheduled by the sequencer.
+     * @param noteId  The id of the note (from SequencerNote.id or auto-assigned index).
+     * @param time    Optional AudioContext time to schedule the stop.
+     */
+    stopNote(noteId: string | number, time?: number): this;
+    /**
+     * Toggle between playing and paused. If stopped, starts from the beginning.
+     */
+    togglePlayPause(): this;
     get bpm(): number;
     set bpm(value: number);
     get timeSignature(): number;
@@ -359,17 +538,19 @@ declare class Sequencer {
     /**
      * Listen to a sequencer event.
      *
-     * | Event     | Args                         |
-     * |-----------|------------------------------|
-     * | "start"   |                              |
-     * | "stop"    |                              |
-     * | "pause"   |                              |
-     * | "end"     |                              |
-     * | "loop"    |                              |
-     * | "beat"    | (beat: number, time: number) |
-     * | "bar"     | (bar: number, time: number)  |
-     * | "noteOn"  | (event: NoteEvent)           |
-     * | "noteOff" | (event: NoteEvent)           |
+     * | Event          | Args                                              |
+     * |----------------|---------------------------------------------------|
+     * | "statechange"  | (state: "playing" \| "paused" \| "stopped")       |
+     * | "start"        |                                                   |
+     * | "stop"         |                                                   |
+     * | "pause"        |                                                   |
+     * | "end"          |                                                   |
+     * | "loop"         |                                                   |
+     * | "beat"         | (beat: number, time: number)                      |
+     * | "bar"          | (bar: number, time: number)                       |
+     * | "step"         | (stepIndex: number, time: number)                 |
+     * | "noteOn"       | (event: SequencerNoteEvent)                       |
+     * | "noteOff"      | (event: SequencerNoteEvent)                       |
      */
     on(event: string, callback: (...args: any[]) => void): this;
     off(event: string, callback: (...args: any[]) => void): this;
@@ -377,8 +558,11 @@ declare class Sequencer {
     private _stopLoop;
     private _flush;
     private _scheduleWindow;
+    private _emitStepsInWindow;
     private _emitBeatsInWindow;
     private _emit;
+    /** Emit both the specific state event ("start"/"pause"/"stop") and the unified "statechange" event. */
+    private _emitStateChange;
     /** Recompute _totalTicks from all track notes (at + duration). */
     private _recomputeTotalTicks;
     /** Format a raw tick count as "bar:beat:tick" (all 1-indexed). */
@@ -413,7 +597,7 @@ declare class ElectricPiano {
     });
     get output(): OutputChannel;
     get loadProgress(): LoadProgress;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(target?: StopTarget): void;
     disconnect(): void;
 }
@@ -442,7 +626,7 @@ declare class Versilian {
     constructor(context: BaseAudioContext, options?: VersilianOptions);
     get output(): OutputChannel;
     get loadProgress(): LoadProgress;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(target?: StopTarget): void;
     disconnect(): void;
 }
@@ -473,7 +657,7 @@ declare class Mellotron {
     constructor(context: BaseAudioContext, options?: MellotronOptions);
     get output(): OutputChannel;
     get loadProgress(): LoadProgress;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(target?: StopTarget): void;
     disconnect(): void;
 }
@@ -531,7 +715,7 @@ declare class Sampler {
     constructor(context: AudioContext, options?: Partial<SamplerConfig>);
     loaded(): Promise<this>;
     get output(): OutputChannel;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(sample?: StopTarget | string | number): void;
     disconnect(): void;
 }
@@ -571,7 +755,7 @@ declare class Smolken {
     constructor(context: BaseAudioContext, options?: SmolkenOptions);
     get output(): OutputChannel;
     get loadProgress(): LoadProgress;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(target?: StopTarget): void;
     disconnect(): void;
 }
@@ -605,7 +789,7 @@ declare class Soundfont {
     get output(): OutputChannel;
     loaded(): Promise<this>;
     disconnect(): void;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(sample?: StopTarget | string | number): void;
 }
 /**
@@ -664,7 +848,7 @@ declare class Soundfont2Sampler {
     get instrumentNames(): string[];
     get output(): OutputChannel;
     loadInstrument(instrumentName: string): Promise<void> | undefined;
-    start(sample: NoteEvent$1 | string | number): StopFn;
+    start(sample: NoteEvent | string | number): StopFn;
     stop(sample?: StopTarget | string | number): void;
     disconnect(): void;
 }
@@ -704,7 +888,7 @@ declare class SplendidGrandPiano {
     get loadProgress(): LoadProgress;
     /** @deprecated Use `load` instead. */
     loaded(): Promise<this>;
-    start(event: NoteEvent$1): StopFn;
+    start(event: NoteEvent): StopFn;
     stop(target?: StopTarget): void;
     disconnect(): void;
 }
@@ -733,4 +917,4 @@ declare const LAYERS: ({
     cutoff?: undefined;
 })[];
 
-export { CacheStorage, DrumMachine, type DrumMachineOptions, ElectricPiano, type ElectricPianoOptions, HttpStorage, LAYERS, Mallet, Mellotron, type MellotronConfig, type MellotronOptions, NAME_TO_PATH, type NoteEvent, Reverb, Sampler, type SamplerConfig, Sequencer, type SequencerInstrument, type SequencerNote, type SequencerOptions, Smolken, type SmolkenConfig, type SmolkenOptions, Soundfont, type Soundfont2Options, Soundfont2Sampler, type SoundfontOptions, SplendidGrandPiano, type SplendidGrandPianoConfig, type Storage, type StorageResponse, Versilian, type VersilianConfig, type VersilianOptions, drumMachineToSmplrJson, getDrumMachineNames, getElectricPianoNames, getMalletNames, getMellotronNames, getSmolkenNames, getSoundfontKits, getSoundfontNames, getVersilianInstruments, mellotronToSmplrJson, pianoToSmplrJson, samplerToSmplrJson, sf2InstrumentToSmplrJson, soundfontToSmplrJson, spreadKeyRanges };
+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, 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, drumMachineToSmplrJson, getDrumMachineNames, getElectricPianoNames, getMalletNames, getMellotronNames, getSmolkenNames, getSoundfontKits, getSoundfontNames, getVersilianInstruments, mellotronToSmplrJson, pianoToSmplrJson, samplerToSmplrJson, sf2InstrumentToSmplrJson, soundfontToSmplrJson, spreadKeyRanges };