smplr 0.24.0 → 0.25.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,
@@ -1461,6 +1468,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 +2220,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 +2278,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);
   }
   // ---------------------------------------------------------------------------
@@ -2362,7 +2837,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;
@@ -2823,11 +3298,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"]
       })
@@ -3976,6 +4451,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 +4474,12 @@ var LAYERS = [
   Versilian,
   audioBufferToWav,
   audioBufferToWav16,
+  drumAbuseSampleUrl,
   drumMachineToPreset,
+  getDrumAbuseMachineNames,
+  getDrumAbuseMachinePack,
+  getDrumAbuseMachinesForPack,
+  getDrumAbusePackNames,
   getDrumMachineNames,
   getElectricPianoNames,
   getMalletNames,