libadlmidi-js 1.1.0 → 1.2.0

package/dist/libadlmidi.full.slim.processor.js

@@ -2385,10 +2385,11 @@ async function createADLMIDI(moduleArg = {}) {
       return;
     }
     try {
-      func();
-      maybeExit();
+      return func();
     } catch (e) {
       handleException(e);
+    } finally {
+      maybeExit();
     }
   };
   var _emscripten_get_now = () => performance.now();
@@ -2605,60 +2606,79 @@ async function createADLMIDI(moduleArg = {}) {
   Module["setValue"] = setValue;
   Module["getValue"] = getValue;
   Module["UTF8ToString"] = UTF8ToString;
-  var _adl_init, _adl_close, _adl_setNumChips, _adl_setBank, _adl_getBanksCount, _adl_getBankNames, _adl_reserveBanks, _adl_getBank, _adl_getInstrument, _adl_setInstrument, _adl_loadEmbeddedBank, _adl_setNumFourOpsChn, _adl_setPercMode, _adl_setHVibrato, _adl_setHTremolo, _adl_setScaleModulators, _adl_setLoopEnabled, _adl_setLoopCount, _adl_setSoftPanEnabled, _adl_setVolumeRangeModel, _adl_openBankFile, _adl_openBankData, _adl_openData, _adl_chipEmulatorName, _adl_switchEmulator, _adl_errorString, _adl_errorInfo, _adl_reset, _adl_totalTimeLength, _adl_positionTell, _adl_positionSeek, _adl_positionRewind, _adl_setTempo, _adl_play, _adl_playFormat, _adl_generate, _adl_generateFormat, _adl_atEnd, _adl_panic, _adl_rt_resetState, _adl_rt_noteOn, _adl_rt_noteOff, _adl_rt_controllerChange, _adl_rt_patchChange, _adl_rt_pitchBend, _adl_rt_pitchBendML, __emscripten_timeout, _malloc, _free, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, memory, __indirect_function_table, wasmMemory;
+  var _adl_init, _adl_close, _adl_setNumChips, _adl_getNumChips, _adl_getNumChipsObtained, _adl_setBank, _adl_getBanksCount, _adl_getBankNames, _adl_reserveBanks, _adl_getBank, _adl_getInstrument, _adl_setInstrument, _adl_loadEmbeddedBank, _adl_setNumFourOpsChn, _adl_getNumFourOpsChn, _adl_setPercMode, _adl_setHVibrato, _adl_setHTremolo, _adl_setScaleModulators, _adl_setFullRangeBrightness, _adl_setAutoArpeggio, _adl_getAutoArpeggio, _adl_setLoopEnabled, _adl_setLoopCount, _adl_setSoftPanEnabled, _adl_setVolumeRangeModel, _adl_getVolumeRangeModel, _adl_setChannelAllocMode, _adl_getChannelAllocMode, _adl_openBankFile, _adl_openBankData, _adl_openData, _adl_chipEmulatorName, _adl_switchEmulator, _adl_setRunAtPcmRate, _adl_linkedLibraryVersion, _adl_linkedVersion, _adl_errorString, _adl_errorInfo, _adl_reset, _adl_totalTimeLength, _adl_positionTell, _adl_positionSeek, _adl_positionRewind, _adl_setTempo, _adl_metaMusicTitle, _adl_metaMusicCopyright, _adl_play, _adl_playFormat, _adl_generate, _adl_generateFormat, _adl_atEnd, _adl_panic, _adl_rt_resetState, _adl_rt_noteOn, _adl_rt_noteOff, _adl_rt_noteAfterTouch, _adl_rt_channelAfterTouch, _adl_rt_controllerChange, _adl_rt_patchChange, _adl_rt_pitchBend, _adl_rt_pitchBendML, _adl_rt_bankChangeLSB, _adl_rt_bankChangeMSB, _adl_rt_bankChange, __emscripten_timeout, _malloc, _free, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, memory, __indirect_function_table, wasmMemory;
   function assignWasmExports(wasmExports2) {
     _adl_init = Module["_adl_init"] = wasmExports2["p"];
     _adl_close = Module["_adl_close"] = wasmExports2["q"];
     _adl_setNumChips = Module["_adl_setNumChips"] = wasmExports2["r"];
-    _adl_setBank = Module["_adl_setBank"] = wasmExports2["s"];
-    _adl_getBanksCount = Module["_adl_getBanksCount"] = wasmExports2["t"];
-    _adl_getBankNames = Module["_adl_getBankNames"] = wasmExports2["u"];
-    _adl_reserveBanks = Module["_adl_reserveBanks"] = wasmExports2["v"];
-    _adl_getBank = Module["_adl_getBank"] = wasmExports2["w"];
-    _adl_getInstrument = Module["_adl_getInstrument"] = wasmExports2["x"];
-    _adl_setInstrument = Module["_adl_setInstrument"] = wasmExports2["y"];
-    _adl_loadEmbeddedBank = Module["_adl_loadEmbeddedBank"] = wasmExports2["z"];
-    _adl_setNumFourOpsChn = Module["_adl_setNumFourOpsChn"] = wasmExports2["A"];
-    _adl_setPercMode = Module["_adl_setPercMode"] = wasmExports2["B"];
-    _adl_setHVibrato = Module["_adl_setHVibrato"] = wasmExports2["C"];
-    _adl_setHTremolo = Module["_adl_setHTremolo"] = wasmExports2["D"];
-    _adl_setScaleModulators = Module["_adl_setScaleModulators"] = wasmExports2["E"];
-    _adl_setLoopEnabled = Module["_adl_setLoopEnabled"] = wasmExports2["F"];
-    _adl_setLoopCount = Module["_adl_setLoopCount"] = wasmExports2["G"];
-    _adl_setSoftPanEnabled = Module["_adl_setSoftPanEnabled"] = wasmExports2["H"];
-    _adl_setVolumeRangeModel = Module["_adl_setVolumeRangeModel"] = wasmExports2["I"];
-    _adl_openBankFile = Module["_adl_openBankFile"] = wasmExports2["J"];
-    _adl_openBankData = Module["_adl_openBankData"] = wasmExports2["K"];
-    _adl_openData = Module["_adl_openData"] = wasmExports2["L"];
-    _adl_chipEmulatorName = Module["_adl_chipEmulatorName"] = wasmExports2["M"];
-    _adl_switchEmulator = Module["_adl_switchEmulator"] = wasmExports2["N"];
-    _adl_errorString = Module["_adl_errorString"] = wasmExports2["O"];
-    _adl_errorInfo = Module["_adl_errorInfo"] = wasmExports2["P"];
-    _adl_reset = Module["_adl_reset"] = wasmExports2["Q"];
-    _adl_totalTimeLength = Module["_adl_totalTimeLength"] = wasmExports2["R"];
-    _adl_positionTell = Module["_adl_positionTell"] = wasmExports2["S"];
-    _adl_positionSeek = Module["_adl_positionSeek"] = wasmExports2["T"];
-    _adl_positionRewind = Module["_adl_positionRewind"] = wasmExports2["U"];
-    _adl_setTempo = Module["_adl_setTempo"] = wasmExports2["V"];
-    _adl_play = Module["_adl_play"] = wasmExports2["W"];
-    _adl_playFormat = Module["_adl_playFormat"] = wasmExports2["X"];
-    _adl_generate = Module["_adl_generate"] = wasmExports2["Y"];
-    _adl_generateFormat = Module["_adl_generateFormat"] = wasmExports2["Z"];
-    _adl_atEnd = Module["_adl_atEnd"] = wasmExports2["_"];
-    _adl_panic = Module["_adl_panic"] = wasmExports2["$"];
-    _adl_rt_resetState = Module["_adl_rt_resetState"] = wasmExports2["aa"];
-    _adl_rt_noteOn = Module["_adl_rt_noteOn"] = wasmExports2["ba"];
-    _adl_rt_noteOff = Module["_adl_rt_noteOff"] = wasmExports2["ca"];
-    _adl_rt_controllerChange = Module["_adl_rt_controllerChange"] = wasmExports2["da"];
-    _adl_rt_patchChange = Module["_adl_rt_patchChange"] = wasmExports2["ea"];
-    _adl_rt_pitchBend = Module["_adl_rt_pitchBend"] = wasmExports2["fa"];
-    _adl_rt_pitchBendML = Module["_adl_rt_pitchBendML"] = wasmExports2["ga"];
-    __emscripten_timeout = wasmExports2["ha"];
-    _malloc = Module["_malloc"] = wasmExports2["ia"];
-    _free = Module["_free"] = wasmExports2["ja"];
-    __emscripten_stack_restore = wasmExports2["ka"];
-    __emscripten_stack_alloc = wasmExports2["la"];
-    _emscripten_stack_get_current = wasmExports2["ma"];
+    _adl_getNumChips = Module["_adl_getNumChips"] = wasmExports2["s"];
+    _adl_getNumChipsObtained = Module["_adl_getNumChipsObtained"] = wasmExports2["t"];
+    _adl_setBank = Module["_adl_setBank"] = wasmExports2["u"];
+    _adl_getBanksCount = Module["_adl_getBanksCount"] = wasmExports2["v"];
+    _adl_getBankNames = Module["_adl_getBankNames"] = wasmExports2["w"];
+    _adl_reserveBanks = Module["_adl_reserveBanks"] = wasmExports2["x"];
+    _adl_getBank = Module["_adl_getBank"] = wasmExports2["y"];
+    _adl_getInstrument = Module["_adl_getInstrument"] = wasmExports2["z"];
+    _adl_setInstrument = Module["_adl_setInstrument"] = wasmExports2["A"];
+    _adl_loadEmbeddedBank = Module["_adl_loadEmbeddedBank"] = wasmExports2["B"];
+    _adl_setNumFourOpsChn = Module["_adl_setNumFourOpsChn"] = wasmExports2["C"];
+    _adl_getNumFourOpsChn = Module["_adl_getNumFourOpsChn"] = wasmExports2["D"];
+    _adl_setPercMode = Module["_adl_setPercMode"] = wasmExports2["E"];
+    _adl_setHVibrato = Module["_adl_setHVibrato"] = wasmExports2["F"];
+    _adl_setHTremolo = Module["_adl_setHTremolo"] = wasmExports2["G"];
+    _adl_setScaleModulators = Module["_adl_setScaleModulators"] = wasmExports2["H"];
+    _adl_setFullRangeBrightness = Module["_adl_setFullRangeBrightness"] = wasmExports2["I"];
+    _adl_setAutoArpeggio = Module["_adl_setAutoArpeggio"] = wasmExports2["J"];
+    _adl_getAutoArpeggio = Module["_adl_getAutoArpeggio"] = wasmExports2["K"];
+    _adl_setLoopEnabled = Module["_adl_setLoopEnabled"] = wasmExports2["L"];
+    _adl_setLoopCount = Module["_adl_setLoopCount"] = wasmExports2["M"];
+    _adl_setSoftPanEnabled = Module["_adl_setSoftPanEnabled"] = wasmExports2["N"];
+    _adl_setVolumeRangeModel = Module["_adl_setVolumeRangeModel"] = wasmExports2["O"];
+    _adl_getVolumeRangeModel = Module["_adl_getVolumeRangeModel"] = wasmExports2["P"];
+    _adl_setChannelAllocMode = Module["_adl_setChannelAllocMode"] = wasmExports2["Q"];
+    _adl_getChannelAllocMode = Module["_adl_getChannelAllocMode"] = wasmExports2["R"];
+    _adl_openBankFile = Module["_adl_openBankFile"] = wasmExports2["S"];
+    _adl_openBankData = Module["_adl_openBankData"] = wasmExports2["T"];
+    _adl_openData = Module["_adl_openData"] = wasmExports2["U"];
+    _adl_chipEmulatorName = Module["_adl_chipEmulatorName"] = wasmExports2["V"];
+    _adl_switchEmulator = Module["_adl_switchEmulator"] = wasmExports2["W"];
+    _adl_setRunAtPcmRate = Module["_adl_setRunAtPcmRate"] = wasmExports2["X"];
+    _adl_linkedLibraryVersion = Module["_adl_linkedLibraryVersion"] = wasmExports2["Y"];
+    _adl_linkedVersion = Module["_adl_linkedVersion"] = wasmExports2["Z"];
+    _adl_errorString = Module["_adl_errorString"] = wasmExports2["_"];
+    _adl_errorInfo = Module["_adl_errorInfo"] = wasmExports2["$"];
+    _adl_reset = Module["_adl_reset"] = wasmExports2["aa"];
+    _adl_totalTimeLength = Module["_adl_totalTimeLength"] = wasmExports2["ba"];
+    _adl_positionTell = Module["_adl_positionTell"] = wasmExports2["ca"];
+    _adl_positionSeek = Module["_adl_positionSeek"] = wasmExports2["da"];
+    _adl_positionRewind = Module["_adl_positionRewind"] = wasmExports2["ea"];
+    _adl_setTempo = Module["_adl_setTempo"] = wasmExports2["fa"];
+    _adl_metaMusicTitle = Module["_adl_metaMusicTitle"] = wasmExports2["ga"];
+    _adl_metaMusicCopyright = Module["_adl_metaMusicCopyright"] = wasmExports2["ha"];
+    _adl_play = Module["_adl_play"] = wasmExports2["ia"];
+    _adl_playFormat = Module["_adl_playFormat"] = wasmExports2["ja"];
+    _adl_generate = Module["_adl_generate"] = wasmExports2["ka"];
+    _adl_generateFormat = Module["_adl_generateFormat"] = wasmExports2["la"];
+    _adl_atEnd = Module["_adl_atEnd"] = wasmExports2["ma"];
+    _adl_panic = Module["_adl_panic"] = wasmExports2["na"];
+    _adl_rt_resetState = Module["_adl_rt_resetState"] = wasmExports2["oa"];
+    _adl_rt_noteOn = Module["_adl_rt_noteOn"] = wasmExports2["pa"];
+    _adl_rt_noteOff = Module["_adl_rt_noteOff"] = wasmExports2["qa"];
+    _adl_rt_noteAfterTouch = Module["_adl_rt_noteAfterTouch"] = wasmExports2["ra"];
+    _adl_rt_channelAfterTouch = Module["_adl_rt_channelAfterTouch"] = wasmExports2["sa"];
+    _adl_rt_controllerChange = Module["_adl_rt_controllerChange"] = wasmExports2["ta"];
+    _adl_rt_patchChange = Module["_adl_rt_patchChange"] = wasmExports2["ua"];
+    _adl_rt_pitchBend = Module["_adl_rt_pitchBend"] = wasmExports2["va"];
+    _adl_rt_pitchBendML = Module["_adl_rt_pitchBendML"] = wasmExports2["wa"];
+    _adl_rt_bankChangeLSB = Module["_adl_rt_bankChangeLSB"] = wasmExports2["xa"];
+    _adl_rt_bankChangeMSB = Module["_adl_rt_bankChangeMSB"] = wasmExports2["ya"];
+    _adl_rt_bankChange = Module["_adl_rt_bankChange"] = wasmExports2["za"];
+    __emscripten_timeout = wasmExports2["Aa"];
+    _malloc = Module["_malloc"] = wasmExports2["Ba"];
+    _free = Module["_free"] = wasmExports2["Ca"];
+    __emscripten_stack_restore = wasmExports2["Da"];
+    __emscripten_stack_alloc = wasmExports2["Ea"];
+    _emscripten_stack_get_current = wasmExports2["Fa"];
     memory = wasmMemory = wasmExports2["n"];
     __indirect_function_table = wasmExports2["__indirect_function_table"];
   }
@@ -3036,7 +3056,7 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
         this.adl._adl_rt_noteOff(this.midi, msg.channel, msg.note);
         break;
       case "pitchBend":
-        this.adl._adl_rt_pitchBendML(this.midi, msg.channel, msg.lsb, msg.msb);
+        this.adl._adl_rt_pitchBendML(this.midi, msg.channel, msg.msb, msg.lsb);
         break;
       case "controlChange":
         this.adl._adl_rt_controllerChange(this.midi, msg.channel, msg.controller, msg.value);
@@ -3044,6 +3064,21 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
       case "programChange":
         this.adl._adl_rt_patchChange(this.midi, msg.channel, msg.program);
         break;
+      case "noteAfterTouch":
+        this.adl._adl_rt_noteAfterTouch(this.midi, msg.channel, msg.note, msg.pressure);
+        break;
+      case "channelAfterTouch":
+        this.adl._adl_rt_channelAfterTouch(this.midi, msg.channel, msg.pressure);
+        break;
+      case "bankChange":
+        this.adl._adl_rt_bankChange(this.midi, msg.channel, msg.bank);
+        break;
+      case "bankChangeMSB":
+        this.adl._adl_rt_bankChangeMSB(this.midi, msg.channel, msg.msb);
+        break;
+      case "bankChangeLSB":
+        this.adl._adl_rt_bankChangeLSB(this.midi, msg.channel, msg.lsb);
+        break;
       case "resetState":
         this.adl._adl_rt_resetState(this.midi);
         break;
@@ -3076,6 +3111,30 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
       case "setNumChips":
         this.adl._adl_setNumChips(this.midi, msg.chips);
         break;
+      case "setNumFourOpChannels":
+        this.adl._adl_setNumFourOpsChn(this.midi, msg.channels);
+        break;
+      case "getNumFourOpChannels":
+        this.port.postMessage({ type: "numFourOpChannels", channels: this.adl._adl_getNumFourOpsChn(this.midi) });
+        break;
+      case "setScaleModulators":
+        this.adl._adl_setScaleModulators(this.midi, msg.enabled ? 1 : 0);
+        break;
+      case "setFullRangeBrightness":
+        this.adl._adl_setFullRangeBrightness(this.midi, msg.enabled ? 1 : 0);
+        break;
+      case "setAutoArpeggio":
+        this.adl._adl_setAutoArpeggio(this.midi, msg.enabled ? 1 : 0);
+        break;
+      case "getAutoArpeggio":
+        this.port.postMessage({ type: "autoArpeggio", enabled: this.adl._adl_getAutoArpeggio(this.midi) !== 0 });
+        break;
+      case "setChannelAllocMode":
+        this.adl._adl_setChannelAllocMode(this.midi, msg.mode);
+        break;
+      case "getChannelAllocMode":
+        this.port.postMessage({ type: "channelAllocMode", mode: this.adl._adl_getChannelAllocMode(this.midi) });
+        break;
       case "setVolumeModel":
         this.adl._adl_setVolumeRangeModel(this.midi, msg.model);
         break;
@@ -3088,6 +3147,9 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
       case "setTremolo":
         this.adl._adl_setHTremolo(this.midi, msg.enabled ? 1 : 0);
         break;
+      case "setRunAtPcmRate":
+        this.adl._adl_setRunAtPcmRate(this.midi, msg.enabled ? 1 : 0);
+        break;
       case "switchEmulator": {
         const result = this.adl._adl_switchEmulator(this.midi, msg.emulator);
         this.port.postMessage({ type: "emulatorSwitched", success: result === 0, emulator: msg.emulator });
@@ -3099,6 +3161,31 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
         this.port.postMessage({ type: "emulatorName", name });
         break;
       }
+      case "getLibraryVersion": {
+        const ptr = this.adl._adl_linkedLibraryVersion();
+        const version = ptr ? this.adl.UTF8ToString(ptr) : "Unknown";
+        this.port.postMessage({ type: "libraryVersion", version });
+        break;
+      }
+      case "getVersion": {
+        const ptr = this.adl._adl_linkedVersion();
+        const version = ptr ? {
+          major: this.adl.getValue(ptr, "i16"),
+          minor: this.adl.getValue(ptr + 2, "i16"),
+          patch: this.adl.getValue(ptr + 4, "i16")
+        } : null;
+        this.port.postMessage({ type: "version", version });
+        break;
+      }
+      case "getNumChips":
+        this.port.postMessage({ type: "numChips", chips: this.adl._adl_getNumChips(this.midi) });
+        break;
+      case "getNumChipsObtained":
+        this.port.postMessage({ type: "numChipsObtained", chips: this.adl._adl_getNumChipsObtained(this.midi) });
+        break;
+      case "getVolumeModel":
+        this.port.postMessage({ type: "volumeModel", model: this.adl._adl_getVolumeRangeModel(this.midi) });
+        break;
       case "getEmbeddedBanks": {
         const banks = this.getEmbeddedBankList();
         this.port.postMessage({ type: "embeddedBanks", banks });
@@ -3108,6 +3195,18 @@ var _AdlMidiProcessor = class _AdlMidiProcessor extends AudioWorkletProcessor {
       case "loadMidi":
         this.loadMidiData(msg.data);
         break;
+      case "getMusicTitle": {
+        const ptr = this.adl._adl_metaMusicTitle(this.midi);
+        const title = ptr ? this.adl.UTF8ToString(ptr) : "";
+        this.port.postMessage({ type: "musicTitle", title });
+        break;
+      }
+      case "getMusicCopyright": {
+        const ptr = this.adl._adl_metaMusicCopyright(this.midi);
+        const copyright = ptr ? this.adl.UTF8ToString(ptr) : "";
+        this.port.postMessage({ type: "musicCopyright", copyright });
+        break;
+      }
       case "play":
         if (this.adl._adl_atEnd(this.midi) !== 0) {
           this.adl._adl_positionRewind(this.midi);

package/dist/libadlmidi.js

@@ -30,7 +30,9 @@ var Emulator = Object.freeze({
   /** Nuked OPL2 LLE - Transistor-level emulation */
   NUKED_OPL2_LLE: 9,
   /** Nuked OPL3 LLE - Transistor-level emulation */
-  NUKED_OPL3_LLE: 10
+  NUKED_OPL3_LLE: 10,
+  /** Nuked OPL2 Lite - Lightweight OPL2 emulation for AdLib-era music */
+  NUKED_OPL2_LITE: 11
 });
 var _ready, _messageHandlers, _AdlMidi_instances, handleMessage_fn, onceMessage_fn, send_fn;
 var AdlMidi = class {
@@ -75,13 +77,12 @@ var AdlMidi = class {
     if (this.ctx.state === "suspended") {
       await this.ctx.resume();
     }
-    let wasmBinary = null;
     const effectiveWasmUrl = wasmUrl || processorUrl.replace(".processor.js", ".core.wasm");
     const response = await fetch(effectiveWasmUrl);
     if (!response.ok) {
       throw new Error(`Failed to fetch WASM: ${response.status}`);
     }
-    wasmBinary = await response.arrayBuffer();
+    const wasmBinary = await response.arrayBuffer();
     await this.ctx.audioWorklet.addModule(processorUrl);
     this.node = new AudioWorkletNode(this.ctx, "adl-midi-processor", {
       processorOptions: {
@@ -156,6 +157,47 @@ var AdlMidi = class {
   programChange(channel, program) {
     __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "programChange", channel, program });
   }
+  /**
+   * Send note aftertouch
+   * @param {number} channel - MIDI channel (0-15)
+   * @param {number} note - Note number (0-127)
+   * @param {number} pressure - Pressure (0-127)
+   */
+  noteAfterTouch(channel, note, pressure) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "noteAfterTouch", channel, note, pressure });
+  }
+  /**
+   * Send channel aftertouch
+   * @param {number} channel - MIDI channel (0-15)
+   * @param {number} pressure - Pressure (0-127)
+   */
+  channelAfterTouch(channel, pressure) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "channelAfterTouch", channel, pressure });
+  }
+  /**
+   * Change bank (16-bit)
+   * @param {number} channel - MIDI channel (0-15)
+   * @param {number} bank - Bank number
+   */
+  bankChange(channel, bank) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "bankChange", channel, bank });
+  }
+  /**
+   * Change bank MSB
+   * @param {number} channel - MIDI channel (0-15)
+   * @param {number} msb - Bank MSB (0-127)
+   */
+  bankChangeMSB(channel, msb) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "bankChangeMSB", channel, msb });
+  }
+  /**
+   * Change bank LSB
+   * @param {number} channel - MIDI channel (0-15)
+   * @param {number} lsb - Bank LSB (0-127)
+   */
+  bankChangeLSB(channel, lsb) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "bankChangeLSB", channel, lsb });
+  }
   /**
    * Reset the real-time state (stops all notes, resets controllers)
    * @returns {void}
@@ -279,6 +321,92 @@ var AdlMidi = class {
   setNumChips(chips) {
     __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setNumChips", chips });
   }
+  /**
+   * Set the number of 4-operator channels
+   * @param {number} channels - Number of channels (-1 for auto)
+   */
+  setNumFourOpChannels(channels) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setNumFourOpChannels", channels });
+  }
+  /**
+   * Get the number of 4-operator channels
+   * @returns {Promise<number>}
+   */
+  async getNumFourOpChannels() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "numFourOpChannels",
+        /** @param {{channels: number}} msg */
+        (msg) => {
+          resolve(msg.channels);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getNumFourOpChannels" });
+    });
+  }
+  /**
+   * Enable/disable scaling of modulators by volume
+   * @param {boolean} enabled
+   */
+  setScaleModulators(enabled) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setScaleModulators", enabled });
+  }
+  /**
+   * Enable/disable full-range brightness
+   * @param {boolean} enabled
+   */
+  setFullRangeBrightness(enabled) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setFullRangeBrightness", enabled });
+  }
+  /**
+   * Enable/disable automatic arpeggio
+   * @param {boolean} enabled
+   */
+  setAutoArpeggio(enabled) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setAutoArpeggio", enabled });
+  }
+  /**
+   * Get automatic arpeggio state
+   * @returns {Promise<boolean>}
+   */
+  async getAutoArpeggio() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "autoArpeggio",
+        /** @param {{enabled: boolean}} msg */
+        (msg) => {
+          resolve(msg.enabled);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getAutoArpeggio" });
+    });
+  }
+  /**
+   * Set channel allocation mode
+   * @param {number} mode - Mode ID
+   */
+  setChannelAllocMode(mode) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setChannelAllocMode", mode });
+  }
+  /**
+   * Get channel allocation mode
+   * @returns {Promise<number>}
+   */
+  async getChannelAllocMode() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "channelAllocMode",
+        /** @param {{mode: number}} msg */
+        (msg) => {
+          resolve(msg.mode);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getChannelAllocMode" });
+    });
+  }
   /**
    * Set the volume model
    * @param {number} model - Volume model number
@@ -307,6 +435,13 @@ var AdlMidi = class {
   setTremolo(enabled) {
     __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setTremolo", enabled });
   }
+  /**
+   * Run emulator with PCM rate to reduce CPU usage
+   * @param {boolean} enabled
+   */
+  setRunAtPcmRate(enabled) {
+    __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "setRunAtPcmRate", enabled });
+  }
   /**
    * Switch the OPL3 emulator core at runtime
    * 
@@ -359,6 +494,91 @@ var AdlMidi = class {
       __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getEmulatorName" });
     });
   }
+  /**
+   * Get the version string of the linked libADLMIDI library
+   * @returns {Promise<string>}
+   */
+  async getLibraryVersion() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "libraryVersion",
+        /** @param {{version: string}} msg */
+        (msg) => {
+          resolve(msg.version);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getLibraryVersion" });
+    });
+  }
+  /**
+   * Get the version of the linked libADLMIDI library as an object
+   * @returns {Promise<{major: number, minor: number, patch: number}>}
+   */
+  async getVersion() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "version",
+        /** @param {{version: {major: number, minor: number, patch: number}}} msg */
+        (msg) => {
+          resolve(msg.version);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getVersion" });
+    });
+  }
+  /**
+   * Get the number of emulated chips
+   * @returns {Promise<number>}
+   */
+  async getNumChips() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "numChips",
+        /** @param {{chips: number}} msg */
+        (msg) => {
+          resolve(msg.chips);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getNumChips" });
+    });
+  }
+  /**
+   * Get the number of emulated chips obtained
+   * @returns {Promise<number>}
+   */
+  async getNumChipsObtained() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "numChipsObtained",
+        /** @param {{chips: number}} msg */
+        (msg) => {
+          resolve(msg.chips);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getNumChipsObtained" });
+    });
+  }
+  /**
+   * Get the volume range model
+   * @returns {Promise<number>}
+   */
+  async getVolumeModel() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "volumeModel",
+        /** @param {{model: number}} msg */
+        (msg) => {
+          resolve(msg.model);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getVolumeModel" });
+    });
+  }
   /**
    * Get list of embedded banks available in this build
    * Note: Slim builds have no embedded banks and will return an empty array
@@ -403,13 +623,47 @@ var AdlMidi = class {
           if (msg.success) {
             resolve({ duration: msg.duration });
           } else {
-            reject(new Error(msg.error || "Failed to load MIDI data"));
+            reject(new Error(msg.error || "Failed to parse MIDI data"));
           }
         }
       );
       __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "loadMidi", data: arrayBuffer });
     });
   }
+  /**
+   * Get the music title of the loaded MIDI file
+   * @returns {Promise<string>}
+   */
+  async getMusicTitle() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "musicTitle",
+        /** @param {{title: string}} msg */
+        (msg) => {
+          resolve(msg.title);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getMusicTitle" });
+    });
+  }
+  /**
+   * Get the copyright notice of the loaded MIDI file
+   * @returns {Promise<string>}
+   */
+  async getMusicCopyright() {
+    return new Promise((resolve) => {
+      __privateMethod(this, _AdlMidi_instances, onceMessage_fn).call(
+        this,
+        "musicCopyright",
+        /** @param {{copyright: string}} msg */
+        (msg) => {
+          resolve(msg.copyright);
+        }
+      );
+      __privateMethod(this, _AdlMidi_instances, send_fn).call(this, { type: "getMusicCopyright" });
+    });
+  }
   /**
    * Start or resume MIDI file playback
    * @returns {void}