smplr 0.24.0 → 0.26.0

package/dist/index.js

@@ -74,6 +74,8 @@ var __async = (__this, __arguments, generator) => {
 var index_exports = {};
 __export(index_exports, {
   CacheStorage: () => CacheStorage,
+  DRUM_ABUSE_PACKS: () => DRUM_ABUSE_PACKS,
+  DrumAbuse: () => DrumAbuse,
   DrumMachine: () => DrumMachine,
   ElectricPiano: () => ElectricPiano,
   HttpStorage: () => HttpStorage,
@@ -95,7 +97,12 @@ __export(index_exports, {
   Versilian: () => Versilian,
   audioBufferToWav: () => audioBufferToWav,
   audioBufferToWav16: () => audioBufferToWav16,
+  drumAbuseSampleUrl: () => drumAbuseSampleUrl,
   drumMachineToPreset: () => drumMachineToPreset,
+  getDrumAbuseMachineNames: () => getDrumAbuseMachineNames,
+  getDrumAbuseMachinePack: () => getDrumAbuseMachinePack,
+  getDrumAbuseMachinesForPack: () => getDrumAbuseMachinesForPack,
+  getDrumAbusePackNames: () => getDrumAbusePackNames,
   getDrumMachineNames: () => getDrumMachineNames,
   getElectricPianoNames: () => getElectricPianoNames,
   getMalletNames: () => getMalletNames,
@@ -379,7 +386,7 @@ function pickPlaybackParams(obj) {
   return result;
 }
 function resolveParams(defaults, group, region, midi, velocity, overrides) {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c, _d, _e, _f;
   const merged = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, PARAM_DEFAULTS), defaults), pickPlaybackParams(group)), pickPlaybackParams(region));
   const pitch = (_b = (_a = region.pitch) != null ? _a : region.key) != null ? _b : midi;
   const semitones = midi - pitch;
@@ -398,7 +405,7 @@ function resolveParams(defaults, group, region, midi, velocity, overrides) {
     loopEnd: merged.loopEnd,
     ampVelCurve: region.ampVelCurve,
     loopAuto: region.loopAuto,
-    reverse: overrides == null ? void 0 : overrides.reverse
+    reverse: (_f = overrides == null ? void 0 : overrides.reverse) != null ? _f : merged.reverse
   };
 }
 
@@ -576,14 +583,6 @@ var SampleLoaderImpl = class {
     __privateSet(this, _context, context);
     __privateSet(this, _storage, (_a = options == null ? void 0 : options.storage) != null ? _a : HttpStorage);
   }
-  /**
-   * 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, onProgressOrOptions) {
     return __async(this, null, function* () {
       var _a, _b;
@@ -703,14 +702,6 @@ var SchedulerImpl = class {
     __privateSet(this, _intervalMs, (_b = options == null ? void 0 : options.intervalMs) != null ? _b : INTERVAL_MS_DEFAULT);
     __privateSet(this, _queue, new SortedQueue((a, b) => a.time - b.time));
   }
-  /**
-   * 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, callback) {
     var _a;
     const now = __privateGet(this, _context2).currentTime;
@@ -726,10 +717,6 @@ var SchedulerImpl = class {
       __privateGet(this, _queue).removeAll((q) => q === item);
     };
   }
-  /**
-   * Clear all queued (not-yet-dispatched) events and stop the interval.
-   * Does not affect voices that are already playing.
-   */
   stop() {
     __privateGet(this, _queue).clear();
     if (__privateGet(this, _intervalId) !== void 0) {
@@ -1002,10 +989,12 @@ var SmplrImpl = class {
     __privateSet(this, _voices2, new VoiceManager());
     this.loader = (_c = options == null ? void 0 : options.loader) != null ? _c : SampleLoader(context, { storage: options == null ? void 0 : options.storage });
     if (json) {
-      this.ready = this.loader.load(json, (loaded, total) => {
-        var _a2;
-        __privateSet(this, _loadProgress, { loaded, total });
-        (_a2 = __privateGet(this, _onLoadProgress)) == null ? void 0 : _a2.call(this, { loaded, total });
+      this.ready = this.loader.load(json, {
+        onProgress: (loaded, total) => {
+          var _a2;
+          __privateSet(this, _loadProgress, { loaded, total });
+          (_a2 = __privateGet(this, _onLoadProgress)) == null ? void 0 : _a2.call(this, { loaded, total });
+        }
       }).then((buffers) => {
         __privateSet(this, _buffers, buffers);
       });
@@ -1461,6 +1450,465 @@ function drumMachineToPreset(instrument) {
   };
 }
 
+// src/drum-abuse/index.ts
+var DEFAULT_BASE_URL = "https://smpldsnds.github.io";
+var MIDI_BASE = 36;
+var DRUM_ABUSE_PACKS = [
+  "vol1",
+  "vol2",
+  "vol3",
+  "vol4",
+  "vol5"
+];
+var MACHINES_BY_PACK = {
+  vol1: [
+    "4-inthefloor-percussioncombo",
+    "ace-tone-rhythm-ace-fr-1",
+    "ace-tone-rhythm-ace-fr-7l",
+    "ace-tone-rhythm-ace-fr6",
+    "ace-tone-rhythm-king",
+    "ace-tone-rhythm-master",
+    "antonelli-2377",
+    "arp-axxe",
+    "conn-min-o-matic",
+    "eko-compu-rhythm",
+    "eko-ritmo-12",
+    "eko-ritmo-20",
+    "elgam-carousel",
+    "emu-modular",
+    "farfisa-pro",
+    "farfisa-rhythm-10",
+    "farfisa-rhythm-maker-16",
+    "gibson-maestro-g-2",
+    "gibson-maestro-rhythm-jester",
+    "gibson-maestro-rhythm-king-mrk-1",
+    "gulbransen-organ",
+    "hammond-rhythm",
+    "hammond-rhythm-ii",
+    "hohner-automatic-rhythm-player",
+    "jen-sx-1000",
+    "kay-r-8",
+    "keio-checkmate",
+    "kent-k-200",
+    "kent-rhythm-master",
+    "korg-kr-33",
+    "korg-krz",
+    "korg-minipops-series",
+    "korg-s-3",
+    "korg-univox-micro-rhythmer-12",
+    "korg-univox-sr-120",
+    "korg-univox-sr-95",
+    "luxor-passat",
+    "moog-modular-55",
+    "roland-arr",
+    "roland-edp-1",
+    "roland-sh-3a",
+    "roland-system-100",
+    "roland-tr-1-prototype",
+    "roland-tr-33",
+    "roland-tr-41-prototype",
+    "roland-tr-66",
+    "roland-tr-77",
+    "seeburg-rhythm-prince",
+    "seeburg-select-a-rhythm",
+    "solton-disco-64",
+    "sonor-mini-mammut-module",
+    "video-tech-rythmic-10",
+    "vox-percussion-king",
+    "whippany-melo-sonic-350",
+    "wurlitzer-swinging-rhythm",
+    "yamaha-cs-15d",
+    "yamaha-cs-5",
+    "yamaha-cs-6",
+    "yamaha-ps-1",
+    "yamaha-ps-2",
+    "yamaha-ps-3"
+  ],
+  vol2: [
+    "bontempi-hf222",
+    "boss-dr-55",
+    "casio-mt-18",
+    "casio-pt-30",
+    "casio-vl-1",
+    "chaser-computer-drum-pr-80",
+    "crb-rhythmboy-480",
+    "eko-musicbox-12",
+    "electro-harmonix-drm-15",
+    "electro-harmonix-drm-16",
+    "electro-harmonix-spacedrum",
+    "elka-drumstar-80",
+    "elka-x-1000",
+    "emu-e-drum",
+    "gem-drum-15",
+    "hammond-autovari-64",
+    "hohner-rhythm-80k",
+    "korg-kpr-77",
+    "korg-kr-55",
+    "korg-kr-mini",
+    "korg-monopoly",
+    "korg-ms-10",
+    "korg-trident",
+    "linn-lm-1",
+    "monacor-rhythmical-choice",
+    "mti-auto-orchestra-ao-1",
+    "multi-moog",
+    "mxr-185",
+    "new-england-digital-synclavier",
+    "oberheim-dmx",
+    "pearl-drum-x",
+    "pollard-syndrum-178",
+    "roland-cr-1000",
+    "roland-cr-68",
+    "roland-cr-78",
+    "roland-cr-80",
+    "roland-cr-8000",
+    "roland-dr-55",
+    "roland-jupiter-8",
+    "roland-pb-300-rhythm-plus",
+    "roland-rhy-33",
+    "roland-rhy-55",
+    "roland-sh-09",
+    "roland-tr-55",
+    "roland-tr-606",
+    "roland-tr-808",
+    "simmons-drum",
+    "simmons-sds-1",
+    "simmons-sds-5",
+    "solton-programmer-24",
+    "star-instruments-synare-3",
+    "star-instruments-synare-ps-1",
+    "visco-space-drum",
+    "watford-electronics-rhythm-generator",
+    "yamaha-cs-40m",
+    "yamaha-mr-10",
+    "yamaha-ps-55"
+  ],
+  vol3: [
+    "amdek-pck-100",
+    "austin-arb-6",
+    "bme-rattlesnake-parametric-percussion-system",
+    "boss-dr-110",
+    "casio-mt-100",
+    "coron-drumsynce-ds-7",
+    "coron-rds",
+    "denon-crb-90",
+    "drumfire-df-2000",
+    "drumfire-df-500",
+    "electro-harmonix-drm-32",
+    "emu-drumulator",
+    "kay-drm-1",
+    "korg-ddm-110",
+    "korg-ddm-220",
+    "korg-poly-800",
+    "linn-linndrum-lm-1-vinyl",
+    "linn-lm-2",
+    "mattel-electronics-synsonics-drm",
+    "mattel-electronics-synsonics-pro",
+    "panasonic-rd-9844",
+    "pearl-drx-1",
+    "roland-ddr-30",
+    "roland-mc-202",
+    "roland-rhy-77",
+    "roland-tr-909",
+    "rsf-dd-30",
+    "sakata-dpm-48",
+    "sequential-circuits-drumtraks",
+    "simmons-clap-trap",
+    "simmons-sds-200",
+    "simmons-sds-400",
+    "soundmaster-sm-8",
+    "soundmaster-sr-88",
+    "tama-ts-206",
+    "tama-ts-305",
+    "wersi-wm-24",
+    "yamaha-dx7"
+  ],
+  vol4: [
+    "atlantex-mpc-1",
+    "boss-hc-2",
+    "boss-pc-2",
+    "casio-ct-310",
+    "casio-mt-500",
+    "casio-mt-800",
+    "casio-pt-68",
+    "casio-pt-82",
+    "casio-sk-1",
+    "dr-b-hm-digital-drums",
+    "emu-sp-12",
+    "ensoniq-mirage",
+    "hing-hon-ek-001",
+    "kawai-acr-20",
+    "kawai-sx-240",
+    "klone-dual-percussion-synthesiser",
+    "korg-ddd-1",
+    "korg-pss-50",
+    "kurzweil-electrodrum-prototype",
+    "linn-9000",
+    "linn-linndrum-lm-2-vinyl",
+    "nasta-hitstix-2",
+    "oberheim-dx",
+    "pearl-sc-40",
+    "rhodes-polaris",
+    "roland-juno-106",
+    "roland-super-quartet-mks-7",
+    "roland-tr-707",
+    "roland-tr-727",
+    "siel-mdp-40",
+    "simmons-sds-1000",
+    "simmons-sds-7",
+    "simmons-sds-8",
+    "simmons-sds-9",
+    "sony-drp-1",
+    "soundmaster-stix-st-305",
+    "suzuki-rpm-40",
+    "tama-ts-500",
+    "technics-ax-5",
+    "technics-pcm-dp-50",
+    "wersi-prisma-dx-5",
+    "yamaha-dd-5",
+    "yamaha-rx-11",
+    "yamaha-rx-15",
+    "yamaha-rx-21",
+    "yamaha-rx-5"
+  ],
+  vol5: [
+    "boss-dr-pad-drp-i",
+    "casio-ct-403",
+    "casio-cz-230s",
+    "casio-ht-700",
+    "casio-rz-1",
+    "cheetah-spec-drum",
+    "forat-f-9000",
+    "korg-ddd-5",
+    "korg-dss-1",
+    "m-p-c-electronics-dsm-1",
+    "pearl-sy-1",
+    "roland-tr-505",
+    "sequential-circuits-studio-440",
+    "simmons-sds-2000",
+    "simmons-sdx",
+    "yamaha-pss-130",
+    "yamaha-ptx8",
+    "yamaha-rx-21l"
+  ]
+};
+var machineToPack = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const pack of DRUM_ABUSE_PACKS) {
+    for (const id of MACHINES_BY_PACK[pack]) m.set(id, pack);
+  }
+  return m;
+})();
+function getDrumAbuseMachineNames() {
+  return [...machineToPack.keys()];
+}
+function getDrumAbuseMachinesForPack(pack) {
+  return MACHINES_BY_PACK[pack];
+}
+function getDrumAbusePackNames() {
+  return DRUM_ABUSE_PACKS;
+}
+function getDrumAbuseMachinePack(id) {
+  return machineToPack.get(id);
+}
+var encSeg = (s) => s.split("/").map(encodeURIComponent).join("/");
+function packBase(baseUrl, pack) {
+  return `${baseUrl}/drum-abuse-${pack}`;
+}
+function sampleBaseUrl(baseUrl, pack, urlPath) {
+  return `${packBase(baseUrl, pack)}/samples/${encSeg(urlPath)}/`;
+}
+function drumAbuseSampleUrl(pack, urlPath, fileNoExt, format = "wav", baseUrl = DEFAULT_BASE_URL) {
+  return `${sampleBaseUrl(baseUrl, pack, urlPath)}${encodeURIComponent(fileNoExt)}.${format}`;
+}
+function stripExt(filename) {
+  return filename.replace(/\.[^.]+$/, "");
+}
+var jsonCache = /* @__PURE__ */ new Map();
+function fetchJSON(url, storage) {
+  let p = jsonCache.get(url);
+  if (!p) {
+    p = storage.fetch(url).then((r) => {
+      if (r.status >= 400) throw new Error(`DrumAbuse: ${r.status} ${url}`);
+      return r.json();
+    });
+    jsonCache.set(url, p);
+  }
+  return p;
+}
+function buildMachinePreset(machine, setPath, baseUrl, pack) {
+  if (machine.sample_sets.length === 0) {
+    throw new Error(`DrumAbuse: machine "${machine.id}" has no sample sets`);
+  }
+  const set = setPath ? machine.sample_sets.find((s) => s.path === setPath) : machine.sample_sets[0];
+  if (!set) {
+    throw new Error(`DrumAbuse: set "${setPath}" not found on "${machine.id}"`);
+  }
+  if (set.samples.length === 0) {
+    throw new Error(
+      `DrumAbuse: set "${set.path}" of "${machine.id}" has no samples`
+    );
+  }
+  const sampleNames = [];
+  const groupNames = [];
+  const sampleNamesForGroup = {};
+  const aliases = {};
+  const regions = set.samples.map((file, i) => {
+    const key = stripExt(file);
+    const midi = MIDI_BASE + i;
+    sampleNames.push(key);
+    aliases[key] = midi;
+    const group = set.sample_instruments[i] || "";
+    if (group) {
+      if (!sampleNamesForGroup[group]) {
+        sampleNamesForGroup[group] = [];
+        groupNames.push(group);
+        aliases[group] = midi;
+      }
+      sampleNamesForGroup[group].push(key);
+    }
+    return {
+      sample: key,
+      keyRange: [midi, midi],
+      pitch: midi
+    };
+  });
+  return {
+    preset: {
+      samples: {
+        baseUrl: sampleBaseUrl(baseUrl, pack, set.url_path),
+        formats: ["wav"]
+      },
+      groups: [{ regions }],
+      aliases
+    },
+    sampleNames,
+    groupNames,
+    sampleNamesForGroup,
+    setPath: set.path
+  };
+}
+function buildPackPreset(list, baseUrl, pack) {
+  var _a;
+  if (list.length === 0) {
+    throw new Error(`DrumAbuse: empty pack-instrument list for pack "${pack}"`);
+  }
+  const fileCount = {};
+  for (const s of list) {
+    const f = stripExt(s.file);
+    fileCount[f] = ((_a = fileCount[f]) != null ? _a : 0) + 1;
+  }
+  const sampleNames = [];
+  const groupNames = [];
+  const sampleNamesForGroup = {};
+  const map = {};
+  const aliases = {};
+  const regions = list.map((s, i) => {
+    const fileKey = stripExt(s.file);
+    const uniqueKey = `${s.machine_id}/${fileKey}`;
+    const midi = MIDI_BASE + i;
+    sampleNames.push(uniqueKey);
+    aliases[uniqueKey] = midi;
+    if (fileCount[fileKey] === 1) aliases[fileKey] = midi;
+    map[uniqueKey] = `${packBase(baseUrl, pack)}/samples/${encSeg(s.url_path)}/${encodeURIComponent(s.file)}`;
+    if (!sampleNamesForGroup[s.machine_id]) {
+      sampleNamesForGroup[s.machine_id] = [];
+      groupNames.push(s.machine_id);
+      aliases[s.machine_id] = midi;
+    }
+    sampleNamesForGroup[s.machine_id].push(uniqueKey);
+    return {
+      sample: uniqueKey,
+      keyRange: [midi, midi],
+      pitch: midi
+    };
+  });
+  return {
+    preset: {
+      samples: { baseUrl: "", formats: ["wav"], map },
+      groups: [{ regions }],
+      aliases
+    },
+    sampleNames,
+    groupNames,
+    sampleNamesForGroup,
+    setPath: null
+  };
+}
+var DrumAbuse = Instrument(
+  (_ctx, options = {}, smplr) => {
+    var _a, _b;
+    const source = options.source;
+    if (!source) {
+      throw new Error("DrumAbuse: options.source is required");
+    }
+    const baseUrl = (_a = options.baseUrl) != null ? _a : DEFAULT_BASE_URL;
+    const storage = (_b = options.storage) != null ? _b : HttpStorage;
+    let sampleNames = [];
+    let groupNames = [];
+    let sampleNamesForGroup = {};
+    let machineId = null;
+    let setPath = null;
+    let packId;
+    let mode;
+    let presetPromise;
+    if (source.kind === "machine") {
+      mode = "machine";
+      const pack = getDrumAbuseMachinePack(source.machine);
+      if (!pack) {
+        throw new Error(`DrumAbuse: unknown machine "${source.machine}"`);
+      }
+      packId = pack;
+      machineId = source.machine;
+      const url = `${packBase(baseUrl, pack)}/machines/${encodeURIComponent(source.machine)}.json`;
+      presetPromise = fetchJSON(url, storage).then((machine) => {
+        const built = buildMachinePreset(machine, source.set, baseUrl, pack);
+        sampleNames = built.sampleNames;
+        groupNames = built.groupNames;
+        sampleNamesForGroup = built.sampleNamesForGroup;
+        setPath = built.setPath;
+        return built.preset;
+      });
+    } else {
+      mode = "pack";
+      if (!DRUM_ABUSE_PACKS.includes(source.pack)) {
+        throw new Error(`DrumAbuse: unknown pack "${source.pack}"`);
+      }
+      packId = source.pack;
+      const url = `${packBase(baseUrl, source.pack)}/instruments/${encodeURIComponent(source.instrument)}.json`;
+      presetPromise = fetchJSON(url, storage).then((list) => {
+        const built = buildPackPreset(list, baseUrl, source.pack);
+        sampleNames = built.sampleNames;
+        groupNames = built.groupNames;
+        sampleNamesForGroup = built.sampleNamesForGroup;
+        return built.preset;
+      });
+    }
+    const baseStart = smplr.start.bind(smplr);
+    const extras = {
+      get mode() {
+        return mode;
+      },
+      getSampleNames: () => sampleNames.slice(),
+      getGroupNames: () => groupNames.slice(),
+      getSampleNamesForGroup: (g) => {
+        var _a2;
+        return ((_a2 = sampleNamesForGroup[g]) != null ? _a2 : []).slice();
+      },
+      getMachineId: () => machineId,
+      getSetPath: () => setPath,
+      getPackId: () => packId,
+      start: (event) => {
+        var _a2;
+        const ev = typeof event === "object" ? event : { note: event };
+        return baseStart(__spreadProps(__spreadValues({}, ev), { stopId: (_a2 = ev.stopId) != null ? _a2 : ev.note }));
+      }
+    };
+    const ready = presetPromise.then((preset) => smplr.loadInstrument(preset));
+    return { extras, ready };
+  }
+);
+
 // src/offline/wav-encoder.ts
 function audioBufferToWav(buffer) {
   return encodeWav(buffer, 32);
@@ -1754,6 +2202,11 @@ var TransportClock = class {
    *
    * Any checkpoints at or after `audioTime` are removed and replaced with this
    * new anchor, preserving the BPM that was in effect at that time.
+   *
+   * @internal Leaks checkpoint-list semantics; only called by `Sequencer._flush`
+   * for loop-boundary re-anchoring. Not safe to share between Sequencers — see
+   * thoughts/research/2026-05-17_20-18-43_shared-transport.md §3. Must not be
+   * exported from any barrel.
    */
   seekAt(tick, audioTime) {
     let bpm = this._bpm;
@@ -1807,9 +2260,13 @@ var TransportClock = class {
     return cp.tick + (audioTime - cp.audioTime) / this._secondsPerTick(cp.bpm);
   }
   /**
-   * Duration in seconds for a given number of ticks at the current BPM.
+   * Convert a tick count to seconds at the current (snapshot) BPM.
+   *
+   * Uses `this._bpm` directly, not the checkpoint history — so after a
+   * mid-play BPM change this returns a value based on the *latest* BPM only.
+   * For checkpoint-aware durations, use `tickToAudioTime(end) - tickToAudioTime(start)`.
    */
-  tickDuration(ticks) {
+  ticksToSeconds(ticks) {
     return ticks * this._secondsPerTick(this._bpm);
   }
   // ---------------------------------------------------------------------------
@@ -2096,6 +2553,7 @@ var SequencerImpl = class {
     this._clock.stop();
     this._stopLoop();
     this._endScheduled = false;
+    for (const stopFn of this._activeVoices.values()) stopFn();
     this._activeVoices.clear();
     this._emitStateChange("stopped");
     return this;
@@ -2362,7 +2820,7 @@ var SequencerImpl = class {
           if (Math.random() * 100 >= note.chance) continue;
         }
         const audioTime = this._clock.tickToAudioTime(noteTick);
-        const durationSec = note.duration !== void 0 ? this._clock.tickDuration(
+        const durationSec = note.duration !== void 0 ? this._clock.ticksToSeconds(
           parseTicks(note.duration, this._ppq, this._timeSignature)
         ) : void 0;
         const timingOffset = trackHumanize.timing ? (Math.random() * 2 - 1) * trackHumanize.timing / 1e3 : 0;
@@ -2733,8 +3191,10 @@ function createTremolo(context, depth) {
     splitter.disconnect(ampR, 1);
     ampL.disconnect(merger, 0, 0);
     ampR.disconnect(merger, 0, 1);
-    lfoL.disconnect(ampL);
-    lfoR.disconnect(ampR);
+    lfoL.disconnect(lfoLAmp);
+    lfoLAmp.disconnect(ampL.gain);
+    lfoR.disconnect(lfoRAmp);
+    lfoRAmp.disconnect(ampR.gain);
     merger.disconnect(output);
   };
   return { input, output };
@@ -2805,15 +3265,11 @@ var ElectricPiano = Instrument(
 
 // src/versilian.ts
 var VCSL_BASE_URL = "https://smpldsnds.github.io/sgossner-vcsl";
-var instruments = [];
+var instrumentsPromise;
 function getVersilianInstruments() {
-  return __async(this, null, function* () {
-    if (instruments.length) return instruments;
-    instruments = yield fetch(VCSL_BASE_URL + "/sfz_files.json").then(
-      (res) => res.json()
-    );
-    return instruments;
-  });
+  return instrumentsPromise != null ? instrumentsPromise : instrumentsPromise = fetch(
+    VCSL_BASE_URL + "/sfz_files.json"
+  ).then((res) => res.json());
 }
 var Versilian = Instrument(
   (ctx, options = {}, smplr) => loadVersilianInstrument(smplr, options)
@@ -2823,11 +3279,11 @@ function loadVersilianInstrument(smplr, options) {
   const instrument = (_a = options.instrument) != null ? _a : "Strings/Violin/Violin - Arco";
   const sfzUrl = `${VCSL_BASE_URL}/${instrument}.sfz`;
   const base = instrument.slice(0, instrument.lastIndexOf("/") + 1);
-  const sampleBaseUrl = `${VCSL_BASE_URL}/${base}`;
+  const sampleBaseUrl2 = `${VCSL_BASE_URL}/${base}`;
   return fetch(sfzUrl).then((r) => r.text()).then(
     (sfzText) => smplr.loadInstrument(
       sfzToPreset(sfzText, {
-        baseUrl: sampleBaseUrl,
+        baseUrl: sampleBaseUrl2,
         pathFromSampleName: (name) => name.replace(/\.wav$/i, ""),
         formats: ["ogg", "m4a"]
       })
@@ -2945,7 +3401,7 @@ function mellotronToPreset(sampleNames, config) {
   for (const sampleName of sampleNames) {
     if (config.variation && !sampleName.includes(config.variation)) continue;
     const midi = toMidi((_a = sampleName.split(" ")[0]) != null ? _a : "");
-    if (!midi) continue;
+    if (midi === void 0) continue;
     entries.push([midi, sampleName]);
   }
   const spread = spreadKeyRanges(entries);
@@ -3030,7 +3486,7 @@ var ReverbImpl = class {
   }
   getParam(name) {
     var _a;
-    return (_a = __privateGet(this, _effect)) == null ? void 0 : _a.parameters.get("preDelay");
+    return (_a = __privateGet(this, _effect)) == null ? void 0 : _a.parameters.get(name);
   }
   get isReady() {
     return __privateGet(this, _effect) !== void 0;
@@ -3357,10 +3813,9 @@ function fetchSoundfontLoopData(url, sampleRate = 44100) {
       const loopData = {};
       Object.keys(raw).forEach((key) => {
         const midi = toMidi(key);
-        if (midi) {
-          const offsets = raw[key];
-          loopData[midi] = [offsets[0] / sampleRate, offsets[1] / sampleRate];
-        }
+        if (midi === void 0) return;
+        const offsets = raw[key];
+        loopData[midi] = [offsets[0] / sampleRate, offsets[1] / sampleRate];
       });
       return loopData;
     } catch (err) {
@@ -3405,7 +3860,7 @@ function decodeSoundfontFile(context, config) {
     yield Promise.all(
       noteNames.map((noteName) => __async(null, null, function* () {
         const midi = toMidi(noteName);
-        if (!midi) return;
+        if (midi === void 0) return;
         try {
           const audioData = base64ToArrayBuffer(
             removeBase64Prefix(json[noteName])
@@ -3976,6 +4431,8 @@ var LAYERS = [
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CacheStorage,
+  DRUM_ABUSE_PACKS,
+  DrumAbuse,
   DrumMachine,
   ElectricPiano,
   HttpStorage,
@@ -3997,7 +4454,12 @@ var LAYERS = [
   Versilian,
   audioBufferToWav,
   audioBufferToWav16,
+  drumAbuseSampleUrl,
   drumMachineToPreset,
+  getDrumAbuseMachineNames,
+  getDrumAbuseMachinePack,
+  getDrumAbuseMachinesForPack,
+  getDrumAbusePackNames,
   getDrumMachineNames,
   getElectricPianoNames,
   getMalletNames,