audio-mixer-engine 0.1.0

package/dist/audio-mixer-engine.es.js

@@ -0,0 +1,1669 @@
+class k {
+  /**
+   * Create a new AudioEngine instance
+   * @param {AudioContext} audioContext - Web Audio API context
+   * @param {Object} options - Engine-specific options
+   */
+  constructor(t, e = {}) {
+    if (new.target === k)
+      throw new Error("AudioEngine is abstract and cannot be instantiated directly");
+    this.audioContext = t, this.options = e, this.isInitialized = !1, this.channels = /* @__PURE__ */ new WeakMap(), this.activeChannels = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Initialize the audio engine - load soundfont and set up synthesis
+   * @param {string|ArrayBuffer} soundfontData - Path to soundfont or binary data
+   * @returns {Promise<void>}
+   */
+  async initialize(t) {
+    throw new Error("initialize() must be implemented by subclass");
+  }
+  /**
+   * Create a new channel for a musical part
+   * @param {string} partId - Unique identifier for this part (e.g., 'soprano', 'piano')
+   * @param {Object} options - Channel configuration
+   * @param {string|number} [options.instrument] - Initial instrument
+   * @param {number} [options.initialVolume=1.0] - Initial volume (0.0-1.0)
+   * @returns {ChannelHandle} Handle object for controlling this channel
+   */
+  createChannel(t, e = {}) {
+    throw new Error("createChannel() must be implemented by subclass");
+  }
+  /**
+   * Stop all notes on all channels
+   */
+  allSoundsOff() {
+    throw new Error("allSoundsOff() must be implemented by subclass");
+  }
+  /**
+   * Get list of all active channel handles
+   * @returns {Array<ChannelHandle>} Array of active channel handles
+   */
+  getActiveChannels() {
+    return Array.from(this.activeChannels);
+  }
+  /**
+   * Clean up all resources and disconnect audio nodes
+   */
+  destroy() {
+    this.allSoundsOff(), this.activeChannels.clear(), this.isInitialized = !1;
+  }
+  /**
+   * Validate that the engine is initialized
+   * @protected
+   */
+  _validateInitialized() {
+    if (!this.isInitialized)
+      throw new Error("AudioEngine not initialized. Call initialize() first.");
+  }
+  /**
+   * Register a new channel handle (called by subclasses)
+   * @param {ChannelHandle} handle - Channel handle to register
+   * @protected
+   */
+  _registerChannel(t) {
+    this.activeChannels.add(t);
+  }
+  /**
+   * Unregister a channel handle (called when channel is destroyed)
+   * @param {ChannelHandle} handle - Channel handle to unregister
+   * @protected
+   */
+  _unregisterChannel(t) {
+    this.activeChannels.delete(t), this.channels.delete(t);
+  }
+}
+class v {
+  constructor(t, e, s = {}) {
+    if (new.target === v)
+      throw new Error("ChannelHandle is abstract and cannot be instantiated directly");
+    this.engine = t, this.partId = e, this.options = { initialVolume: 1, ...s }, this.isDestroyed = !1, this.noteRefCounts = /* @__PURE__ */ new Map(), this.scheduledEvents = /* @__PURE__ */ new Map(), this.activeNotes = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get the output audio node for this channel
+   * This node can be connected to gain controls, analyzers, etc.
+   * @returns {AudioNode} Output node (typically a GainNode)
+   */
+  getOutputNode() {
+    throw new Error("getOutputNode() must be implemented by subclass");
+  }
+  /**
+   * Start a note with reference counting (handles overlaps automatically)
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @param {number} velocity - Note velocity (0-127)
+   */
+  noteOn(t, e) {
+    this._validateActive();
+    const s = this.noteRefCounts.get(t) || 0;
+    this.noteRefCounts.set(t, s + 1), this._actualNoteOn(t, e), s === 0 && this.activeNotes.add(t);
+  }
+  /**
+   * Stop a note with reference counting (only stops when count reaches 0)
+   * @param {number} pitch - MIDI pitch (0-127)
+   */
+  noteOff(t) {
+    this._validateActive();
+    const e = this.noteRefCounts.get(t) || 0;
+    if (e <= 0)
+      return;
+    const s = e - 1;
+    this.noteRefCounts.set(t, s), s === 0 && (this._actualNoteOff(t), this.activeNotes.delete(t), this.noteRefCounts.delete(t));
+  }
+  /**
+   * Schedule a note with automatic timing adjustment
+   * @param {number} startTime - Absolute audio context time when note should start
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @param {number} velocity - Note velocity (0-127)
+   * @param {number} duration - Note duration in seconds
+   * @returns {string} Event ID for cancellation
+   */
+  playNote(t, e, s, i) {
+    this._validateActive();
+    const r = this.engine.audioContext.currentTime, n = `${this.partId}_${t}_${e}_${Date.now()}`;
+    let l = t, o = i;
+    if (t < r) {
+      const f = r - t;
+      l = r, o = Math.max(0, i - f);
+    }
+    if (o <= 0)
+      return n;
+    const a = Math.max(0, (l - r) * 1e3), c = setTimeout(() => {
+      this.noteOn(e, s), this.scheduledEvents.delete(`${n}_on`);
+    }, a), h = a + o * 1e3, m = setTimeout(() => {
+      this.noteOff(e), this.scheduledEvents.delete(`${n}_off`);
+    }, h);
+    return this.scheduledEvents.set(`${n}_on`, c), this.scheduledEvents.set(`${n}_off`, m), n;
+  }
+  /**
+   * Stop all notes on this channel
+   */
+  allNotesOff() {
+    this._validateActive(), this.scheduledEvents.forEach((t) => {
+      clearTimeout(t);
+    }), this.scheduledEvents.clear(), this.activeNotes.forEach((t) => {
+      this._actualNoteOff(t);
+    }), this.noteRefCounts.clear(), this.activeNotes.clear();
+  }
+  /**
+   * Actually start a note (implemented by subclass)
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @param {number} velocity - Note velocity (0-127)
+   * @protected
+   */
+  _actualNoteOn(t, e) {
+    throw new Error("_actualNoteOn() must be implemented by subclass");
+  }
+  /**
+   * Actually stop a note (implemented by subclass)
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @protected
+   */
+  _actualNoteOff(t) {
+    throw new Error("_actualNoteOff() must be implemented by subclass");
+  }
+  /**
+   * Change the instrument for this channel
+   * @param {string|number} instrument - Instrument name or program number
+   * @returns {Promise<void>}
+   */
+  async setInstrument(t) {
+    throw new Error("setInstrument() must be implemented by subclass");
+  }
+  /**
+   * Get current instrument for this channel
+   * @returns {string|number} Current instrument
+   */
+  getInstrument() {
+    throw new Error("getInstrument() must be implemented by subclass");
+  }
+  /**
+   * Set volume for this channel (affects the internal channel volume)
+   * Note: External volume control should use the output node from getOutputNode()
+   * @param {number} volume - Volume level (0.0-1.0)
+   */
+  setVolume(t) {
+    throw new Error("setVolume() must be implemented by subclass");
+  }
+  /**
+   * Get current volume for this channel
+   * @returns {number} Current volume (0.0-1.0)
+   */
+  getVolume() {
+    throw new Error("getVolume() must be implemented by subclass");
+  }
+  /**
+   * Get the part ID for this channel
+   * @returns {string} Part identifier
+   */
+  getPartId() {
+    return this.partId;
+  }
+  /**
+   * Check if this channel is still active
+   * @returns {boolean} True if channel is active
+   */
+  isActive() {
+    return !this.isDestroyed && this.engine.isInitialized && this.engine.activeChannels.has(this);
+  }
+  /**
+   * Destroy this channel and clean up resources
+   */
+  destroy() {
+    if (!this.isDestroyed) {
+      this.allNotesOff();
+      const t = this.getOutputNode();
+      t && t.disconnect(), this.noteRefCounts.clear(), this.scheduledEvents.clear(), this.activeNotes.clear(), this.engine._unregisterChannel(this), this.isDestroyed = !0;
+    }
+  }
+  /**
+   * Validate that this channel is still active
+   * @protected
+   */
+  _validateActive() {
+    if (this.isDestroyed)
+      throw new Error("Channel has been destroyed");
+    if (!this.engine.isInitialized)
+      throw new Error("AudioEngine is not initialized");
+  }
+}
+class P {
+  /**
+   * Map common instrument names to MIDI program numbers
+   * @param {string|number} instrument - Instrument name or program number
+   * @returns {number} MIDI program number
+   */
+  static getInstrumentProgram(t) {
+    if (typeof t == "number") return t;
+    const s = {
+      // Piano family (0-7)
+      piano: 0,
+      bright_piano: 1,
+      electric_grand: 2,
+      honky_tonk: 3,
+      electric_piano_1: 4,
+      electric_piano_2: 5,
+      harpsichord: 6,
+      clavinet: 7,
+      // Chromatic percussion (8-15)
+      celesta: 8,
+      glockenspiel: 9,
+      music_box: 10,
+      vibraphone: 11,
+      marimba: 12,
+      xylophone: 13,
+      tubular_bells: 14,
+      dulcimer: 15,
+      // Organ (16-23)
+      drawbar_organ: 16,
+      percussive_organ: 17,
+      rock_organ: 18,
+      church_organ: 19,
+      reed_organ: 20,
+      accordion: 21,
+      harmonica: 22,
+      tango_accordion: 23,
+      organ: 19,
+      // Guitar (24-31)
+      nylon_guitar: 24,
+      steel_guitar: 25,
+      electric_guitar_jazz: 26,
+      electric_guitar_clean: 27,
+      electric_guitar_muted: 28,
+      overdriven_guitar: 29,
+      distortion_guitar: 30,
+      guitar_harmonics: 31,
+      guitar: 24,
+      // Bass (32-39)
+      acoustic_bass: 32,
+      electric_bass_finger: 33,
+      electric_bass_pick: 34,
+      fretless_bass: 35,
+      slap_bass_1: 36,
+      slap_bass_2: 37,
+      synth_bass_1: 38,
+      synth_bass_2: 39,
+      bass: 32,
+      // Strings (40-47)
+      violin: 40,
+      viola: 41,
+      cello: 42,
+      contrabass: 43,
+      tremolo_strings: 44,
+      pizzicato_strings: 45,
+      orchestral_harp: 46,
+      timpani: 47,
+      strings: 48,
+      strings_ensemble: 48,
+      // Ensemble (48-55)
+      slow_strings: 49,
+      synth_strings_1: 50,
+      synth_strings_2: 51,
+      choir_aahs: 52,
+      voice_oohs: 53,
+      synth_voice: 54,
+      orchestra_hit: 55,
+      // Brass (56-63)
+      trumpet: 56,
+      trombone: 57,
+      tuba: 58,
+      muted_trumpet: 59,
+      french_horn: 60,
+      brass_section: 61,
+      synth_brass_1: 62,
+      synth_brass_2: 63,
+      // Reed (64-71)
+      soprano_sax: 64,
+      alto_sax: 65,
+      tenor_sax: 66,
+      baritone_sax: 67,
+      oboe: 68,
+      english_horn: 69,
+      bassoon: 70,
+      clarinet: 71,
+      saxophone: 64,
+      // Pipe (72-79)
+      piccolo: 72,
+      flute: 73,
+      recorder: 74,
+      pan_flute: 75,
+      blown_bottle: 76,
+      shakuhachi: 77,
+      whistle: 78,
+      ocarina: 79,
+      // Synth lead (80-87)
+      lead_1_square: 80,
+      lead_2_sawtooth: 81,
+      lead_3_calliope: 82,
+      lead_4_chiff: 83,
+      lead_5_charang: 84,
+      lead_6_voice: 85,
+      lead_7_fifths: 86,
+      lead_8_bass: 87,
+      // Synth pad (88-95)
+      pad_1_new_age: 88,
+      pad_2_warm: 89,
+      pad_3_polysynth: 90,
+      pad_4_choir: 91,
+      pad_5_bowed: 92,
+      pad_6_metallic: 93,
+      pad_7_halo: 94,
+      pad_8_sweep: 95,
+      // Synth effects (96-103)
+      fx_1_rain: 96,
+      fx_2_soundtrack: 97,
+      fx_3_crystal: 98,
+      fx_4_atmosphere: 99,
+      fx_5_brightness: 100,
+      fx_6_goblins: 101,
+      fx_7_echoes: 102,
+      fx_8_sci_fi: 103,
+      // Ethnic (104-111)
+      sitar: 104,
+      banjo: 105,
+      shamisen: 106,
+      koto: 107,
+      kalimba: 108,
+      bag_pipe: 109,
+      fiddle: 110,
+      shanai: 111,
+      // Percussive (112-119)
+      tinkle_bell: 112,
+      agogo: 113,
+      steel_drums: 114,
+      woodblock: 115,
+      taiko_drum: 116,
+      melodic_tom: 117,
+      synth_drum: 118,
+      reverse_cymbal: 119,
+      // Sound effects (120-127)
+      guitar_fret_noise: 120,
+      breath_noise: 121,
+      seashore: 122,
+      bird_tweet: 123,
+      telephone_ring: 124,
+      helicopter: 125,
+      applause: 126,
+      gunshot: 127
+    }[t.toLowerCase()];
+    return s !== void 0 ? s : 0;
+  }
+  /**
+   * Get instrument name from MIDI program number (for display purposes)
+   * @param {number} programNumber - MIDI program number (0-127)
+   * @returns {string} Instrument name or fallback
+   */
+  static getProgramName(t) {
+    return [
+      // Piano family (0-7)
+      "Piano",
+      "Bright Piano",
+      "Electric Grand",
+      "Honky-tonk Piano",
+      "Electric Piano 1",
+      "Electric Piano 2",
+      "Harpsichord",
+      "Clavinet",
+      // Chromatic percussion (8-15)
+      "Celesta",
+      "Glockenspiel",
+      "Music Box",
+      "Vibraphone",
+      "Marimba",
+      "Xylophone",
+      "Tubular Bells",
+      "Dulcimer",
+      // Organ (16-23)
+      "Drawbar Organ",
+      "Percussive Organ",
+      "Rock Organ",
+      "Church Organ",
+      "Reed Organ",
+      "Accordion",
+      "Harmonica",
+      "Tango Accordion",
+      // Guitar (24-31)
+      "Nylon Guitar",
+      "Steel Guitar",
+      "Electric Guitar (jazz)",
+      "Electric Guitar (clean)",
+      "Electric Guitar (muted)",
+      "Overdriven Guitar",
+      "Distortion Guitar",
+      "Guitar Harmonics",
+      // Bass (32-39)
+      "Acoustic Bass",
+      "Electric Bass (finger)",
+      "Electric Bass (pick)",
+      "Fretless Bass",
+      "Slap Bass 1",
+      "Slap Bass 2",
+      "Synth Bass 1",
+      "Synth Bass 2",
+      // Strings (40-47)
+      "Violin",
+      "Viola",
+      "Cello",
+      "Contrabass",
+      "Tremolo Strings",
+      "Pizzicato Strings",
+      "Orchestral Harp",
+      "Timpani",
+      // Ensemble (48-55)
+      "String Ensemble 1",
+      "String Ensemble 2",
+      "Synth Strings 1",
+      "Synth Strings 2",
+      "Choir Aahs",
+      "Voice Oohs",
+      "Synth Voice",
+      "Orchestra Hit",
+      // Brass (56-63)
+      "Trumpet",
+      "Trombone",
+      "Tuba",
+      "Muted Trumpet",
+      "French Horn",
+      "Brass Section",
+      "Synth Brass 1",
+      "Synth Brass 2",
+      // Reed (64-71)
+      "Soprano Sax",
+      "Alto Sax",
+      "Tenor Sax",
+      "Baritone Sax",
+      "Oboe",
+      "English Horn",
+      "Bassoon",
+      "Clarinet",
+      // Pipe (72-79)
+      "Piccolo",
+      "Flute",
+      "Recorder",
+      "Pan Flute",
+      "Blown Bottle",
+      "Shakuhachi",
+      "Whistle",
+      "Ocarina",
+      // Synth lead (80-87)
+      "Lead 1 (square)",
+      "Lead 2 (sawtooth)",
+      "Lead 3 (calliope)",
+      "Lead 4 (chiff)",
+      "Lead 5 (charang)",
+      "Lead 6 (voice)",
+      "Lead 7 (fifths)",
+      "Lead 8 (bass + lead)",
+      // Synth pad (88-95)
+      "Pad 1 (new age)",
+      "Pad 2 (warm)",
+      "Pad 3 (polysynth)",
+      "Pad 4 (choir)",
+      "Pad 5 (bowed)",
+      "Pad 6 (metallic)",
+      "Pad 7 (halo)",
+      "Pad 8 (sweep)",
+      // Synth effects (96-103)
+      "FX 1 (rain)",
+      "FX 2 (soundtrack)",
+      "FX 3 (crystal)",
+      "FX 4 (atmosphere)",
+      "FX 5 (brightness)",
+      "FX 6 (goblins)",
+      "FX 7 (echoes)",
+      "FX 8 (sci-fi)",
+      // Ethnic (104-111)
+      "Sitar",
+      "Banjo",
+      "Shamisen",
+      "Koto",
+      "Kalimba",
+      "Bag pipe",
+      "Fiddle",
+      "Shanai",
+      // Percussive (112-119)
+      "Tinkle Bell",
+      "Agogo",
+      "Steel Drums",
+      "Woodblock",
+      "Taiko Drum",
+      "Melodic Tom",
+      "Synth Drum",
+      "Reverse Cymbal",
+      // Sound effects (120-127)
+      "Guitar Fret Noise",
+      "Breath Noise",
+      "Seashore",
+      "Bird Tweet",
+      "Telephone Ring",
+      "Helicopter",
+      "Applause",
+      "Gunshot"
+    ][t] || `Program ${t}`;
+  }
+  /**
+   * Generate a unique note ID
+   * @param {number} channel - MIDI channel
+   * @param {number} pitch - MIDI pitch
+   * @param {number} startTime - Start time
+   * @returns {string} Unique note ID
+   */
+  static generateNoteId(t, e, s) {
+    return `${t}_${e}_${Math.round(s)}`;
+  }
+}
+class x extends v {
+  constructor(t, e, s, i = {}) {
+    super(t, e, i), this.midiChannel = s, this.currentVolume = i.initialVolume || 1, this.currentInstrument = i.instrument || "piano", this.outputGain = null, this._setupOutputNode(), this.setVolume(this.currentVolume), i.instrument && this.setInstrument(i.instrument);
+  }
+  getOutputNode() {
+    return this.outputGain;
+  }
+  /**
+   * Actually start a note in the synthesizer
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @param {number} velocity - Note velocity (0-127)
+   * @protected
+   */
+  _actualNoteOn(t, e) {
+    const s = this.engine._getSynthesizer();
+    if (s && s.noteOn) {
+      const i = Math.round(e * this.currentVolume);
+      s.noteOn(this.midiChannel, t, i);
+    }
+  }
+  /**
+   * Actually stop a note in the synthesizer
+   * @param {number} pitch - MIDI pitch (0-127)
+   * @protected
+   */
+  _actualNoteOff(t) {
+    const e = this.engine._getSynthesizer();
+    e && e.noteOff && e.noteOff(this.midiChannel, t);
+  }
+  async setInstrument(t) {
+    this._validateActive();
+    const e = P.getInstrumentProgram(t);
+    this.currentInstrument = t;
+    const s = this.engine._getSynthesizer();
+    s && s.programChange ? s.programChange(this.midiChannel, e) : console.warn("Cannot set instrument: synthesizer not available or no programChange method");
+  }
+  getInstrument() {
+    return this.currentInstrument;
+  }
+  setVolume(t) {
+    this._validateActive(), t = Math.max(0, Math.min(1, t)), this.currentVolume = t;
+    const e = Math.round(t * 127), s = this.engine._getSynthesizer();
+    s && s.controllerChange && s.controllerChange(this.midiChannel, 7, e);
+  }
+  getVolume() {
+    return this.currentVolume;
+  }
+  /**
+   * Get the MIDI channel number used by this handle
+   * @returns {number} MIDI channel (0-15)
+   */
+  getMidiChannel() {
+    return this.midiChannel;
+  }
+  /**
+   * Get count of active notes
+   * @returns {number} Number of active notes
+   */
+  getActiveNoteCount() {
+    return this.activeNotes.size;
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      const t = this.engine._getIndividualOutput(this.midiChannel);
+      this.outputGain && this.outputGain !== t && this.outputGain.disconnect(), this.outputGain = null;
+    }
+    super.destroy();
+  }
+  /**
+   * Set up the output gain node for this channel
+   * This connects to the individual synthesizer output for this MIDI channel
+   * @private
+   */
+  _setupOutputNode() {
+    const t = this.engine._getIndividualOutput(this.midiChannel);
+    t ? this.outputGain = t : (console.warn(`No individual output available for MIDI channel ${this.midiChannel}, using fallback`), this.outputGain = this.engine.audioContext.createGain(), this.outputGain.gain.value = this.currentVolume);
+  }
+}
+class B extends k {
+  constructor(t, e = {}) {
+    super(t, e), this.synthesizer = null, this.soundfont = null, this.channelCounter = 0, this.partToMidiChannel = /* @__PURE__ */ new Map(), this.midiChannelToPart = /* @__PURE__ */ new Map(), this.individualOutputs = [];
+  }
+  async initialize(t) {
+    try {
+      const { Synthetizer: e } = await import("spessasynth_lib");
+      let s;
+      if (typeof t == "string")
+        console.log("Loading soundfont from path:", t), s = await this._loadSoundfontFromPath(t), console.log("Soundfont loaded successfully, size:", s.byteLength, "bytes");
+      else if (t instanceof ArrayBuffer)
+        s = t;
+      else
+        throw new Error("Invalid soundfont data type. Expected string path or ArrayBuffer.");
+      await this._loadAudioWorkletSafely(), this._setupIndividualOutputs(), this.dummyTarget = this.audioContext.createGain(), await new Promise((i) => setTimeout(i, 50)), this.synthesizer = new e(this.dummyTarget, s), this._connectIndividualOutputs(), this.isInitialized = !0;
+    } catch (e) {
+      throw console.error("Failed to initialize SpessaSynthAudioEngine:", e), e;
+    }
+  }
+  createChannel(t, e = {}) {
+    if (this._validateInitialized(), this.partToMidiChannel.has(t))
+      throw new Error(`Channel for part '${t}' already exists`);
+    const s = this.channelCounter;
+    if (s >= 16)
+      throw new Error("Maximum number of MIDI channels (16) exceeded");
+    this.channelCounter++, this.partToMidiChannel.set(t, s), this.midiChannelToPart.set(s, t);
+    const i = new x(
+      this,
+      t,
+      s,
+      e
+    );
+    return this._registerChannel(i), e.instrument && i.setInstrument(e.instrument), i;
+  }
+  allSoundsOff() {
+    this.synthesizer && this.midiChannelToPart.forEach((t, e) => {
+      this.synthesizer.controllerChange && this.synthesizer.controllerChange(e, 120, 0);
+    });
+  }
+  /**
+   * Clear all channels (for loading new scores)
+   */
+  clearAllChannels() {
+    this.allSoundsOff(), this.partToMidiChannel.clear(), this.midiChannelToPart.clear(), this.channelCounter = 0;
+  }
+  destroy() {
+    this.allSoundsOff(), this.synthesizer && typeof this.synthesizer.disconnect == "function" && this.synthesizer.disconnect(), this.individualOutputs.forEach((t) => {
+      t && t.disconnect && t.disconnect();
+    }), this.individualOutputs = [], this.dummyTarget && (this.dummyTarget.disconnect(), this.dummyTarget = null), this.partToMidiChannel.clear(), this.midiChannelToPart.clear(), this.channelCounter = 0, super.destroy(), this.synthesizer = null, this.soundfont = null;
+  }
+  /**
+   * Get the MIDI channel number for a part
+   * @param {string} partId - Part identifier
+   * @returns {number|null} MIDI channel number or null if not found
+   */
+  getMidiChannelForPart(t) {
+    return this.partToMidiChannel.has(t) ? this.partToMidiChannel.get(t) : null;
+  }
+  /**
+   * Get access to the underlying synthesizer for channel handles
+   * @returns {Object} SpessaSynth synthesizer instance
+   * @protected
+   */
+  _getSynthesizer() {
+    return this.synthesizer;
+  }
+  /**
+   * Get the individual output node for a specific MIDI channel
+   * @param {number} midiChannel - MIDI channel number (0-15)
+   * @returns {AudioNode|null} Individual output node or null if not available
+   * @protected
+   */
+  _getIndividualOutput(t) {
+    return t >= 0 && t < this.individualOutputs.length ? this.individualOutputs[t] : null;
+  }
+  /**
+   * Set up individual output nodes for each MIDI channel
+   * @private
+   */
+  _setupIndividualOutputs() {
+    this.individualOutputs = [];
+    for (let t = 0; t < 16; t++) {
+      const e = this.audioContext.createGain();
+      e.gain.value = 1, this.individualOutputs.push(e);
+    }
+  }
+  /**
+   * Connect synthesizer individual outputs to channel-specific gain nodes
+   * @private
+   */
+  _connectIndividualOutputs() {
+    try {
+      this.synthesizer && this.synthesizer.connectIndividualOutputs ? this.synthesizer.connectIndividualOutputs(this.individualOutputs) : console.warn("Synthesizer does not support individual outputs, using master output only");
+    } catch (t) {
+      console.warn("Failed to connect individual outputs:", t.message), console.warn("Falling back to master output routing");
+    }
+  }
+  /**
+   * Load soundfont from file path or URL
+   * @param {string} path - Path to soundfont file
+   * @returns {Promise<ArrayBuffer>} Soundfont data
+   * @private
+   */
+  async _loadSoundfontFromPath(t) {
+    if (typeof window < "u") {
+      const e = await fetch(t);
+      if (!e.ok)
+        throw new Error(`Failed to load soundfont: ${e.status} ${e.statusText}`);
+      return await e.arrayBuffer();
+    } else {
+      const e = await Promise.resolve().then(() => C), s = await Promise.resolve().then(() => C), i = s.isAbsolute(t) ? t : s.resolve(process.cwd(), t);
+      return e.readFileSync(i).buffer;
+    }
+  }
+  /**
+   * Load AudioWorklet with aggressive Firefox compatibility measures
+   * @private
+   */
+  async _loadAudioWorkletSafely() {
+    const t = "/node_modules/spessasynth_lib/synthetizer/worklet_processor.min.js", s = typeof navigator < "u" && navigator.userAgent.toLowerCase().includes("firefox");
+    for (let i = 1; i <= 5; i++)
+      try {
+        if (s) {
+          const r = i * 200;
+          await new Promise((n) => setTimeout(n, r)), "gc" in window && typeof window.gc == "function" && window.gc(), this.audioContext.state === "suspended" && await this.audioContext.resume();
+        }
+        console.log(`Attempting to load AudioWorklet (attempt ${i}/5)`), await this.audioContext.audioWorklet.addModule(t), console.log(`AudioWorklet loaded successfully on attempt ${i}`);
+        return;
+      } catch (r) {
+        if (console.warn(`AudioWorklet loading failed (attempt ${i}/5):`, r.message), i === 5)
+          throw new Error(`AudioWorklet failed after 5 attempts: ${r.message}`);
+        const n = s ? i * 1e3 : i * 500;
+        await new Promise((l) => setTimeout(l, n));
+      }
+  }
+}
+class E {
+  constructor() {
+    this.partNames = [
+      "soprano",
+      "alto",
+      "tenor",
+      "bass",
+      "treble",
+      "mezzo",
+      "baritone",
+      "s",
+      "a",
+      "t",
+      "b",
+      "satb"
+    ], this.parsedData = {
+      parts: {},
+      // Will contain separate arrays for each vocal part
+      barStructure: [],
+      // Will contain bar timing information
+      metadata: {}
+      // Will contain title, composer, etc.
+    };
+  }
+  /**
+   * Main method to parse a MIDI file
+   * @param {ArrayBuffer} midiFileBuffer - The MIDI file as an ArrayBuffer
+   * @returns {Object} Parsed data with parts, barStructure and metadata
+   */
+  async parse(t) {
+    try {
+      const e = await this._parseMidiBuffer(t);
+      return this._extractMetadata(e), this._extractBarStructure(e), this._extractParts(e), this.parsedData;
+    } catch (e) {
+      throw console.error("Error parsing MIDI file:", e), e;
+    }
+  }
+  /**
+   * Parse the MIDI buffer into a workable format
+   * @private
+   */
+  async _parseMidiBuffer(t) {
+    const e = new Uint8Array(t);
+    if (!(e[0] === 77 && e[1] === 84 && e[2] === 104 && e[3] === 100))
+      throw new Error("Not a valid MIDI file");
+    const s = this._bytesToNumber(e.slice(4, 8)), i = this._bytesToNumber(e.slice(8, 10)), r = this._bytesToNumber(e.slice(10, 12)), n = this._bytesToNumber(e.slice(12, 14)), l = n & 32768 ? null : n, o = {
+      format: i,
+      ticksPerBeat: l,
+      tracks: [],
+      duration: 0
+    };
+    let a = 8 + s;
+    for (let c = 0; c < r; c++)
+      if (e[a] === 77 && e[a + 1] === 84 && e[a + 2] === 114 && e[a + 3] === 107) {
+        const h = this._bytesToNumber(e.slice(a + 4, a + 8)), m = e.slice(a + 8, a + 8 + h), f = this._parseTrack(m);
+        o.tracks.push(f), a += 8 + h;
+      } else
+        throw new Error(`Invalid track header at position ${a}`);
+    return o;
+  }
+  /**
+   * Parse a single MIDI track
+   * @private
+   */
+  _parseTrack(t) {
+    const e = {
+      notes: [],
+      name: null,
+      lyrics: [],
+      events: [],
+      duration: 0
+    };
+    let s = 0, i = 0, r = null;
+    for (; s < t.length; ) {
+      let n = 0, l = 0;
+      do
+        l = t[s++], n = n << 7 | l & 127;
+      while (l & 128);
+      i += n, l = t[s++];
+      let o = l;
+      if ((l & 128) === 0) {
+        if (r === null)
+          throw new Error("Running status byte encountered before status byte");
+        o = r, s--;
+      } else
+        r = o;
+      if (o === 255) {
+        const a = t[s++], c = this._readVariableLengthValue(t, s);
+        s += c.bytesRead;
+        const h = t.slice(s, s + c.value);
+        switch (s += c.value, a) {
+          case 3:
+            e.name = this._bytesToString(h);
+            break;
+          case 1:
+            e.events.push({
+              type: "text",
+              text: this._bytesToString(h),
+              tick: i
+            });
+            break;
+          case 5:
+            e.lyrics.push({
+              text: this._bytesToString(h),
+              tick: i
+            });
+            break;
+          case 81:
+            const m = this._bytesToNumber(h), f = Math.round(6e7 / m);
+            e.events.push({
+              type: "tempo",
+              bpm: f,
+              tick: i
+            });
+            break;
+          case 88:
+            e.events.push({
+              type: "timeSignature",
+              numerator: h[0],
+              denominator: Math.pow(2, h[1]),
+              tick: i
+            });
+            break;
+          case 47:
+            e.duration = i;
+            break;
+        }
+      } else if ((o & 240) === 144) {
+        const a = o & 15, c = t[s++], h = t[s++];
+        h > 0 ? e.notes.push({
+          type: "noteOn",
+          noteNumber: c,
+          velocity: h,
+          tick: i,
+          channel: a
+        }) : e.notes.push({
+          type: "noteOff",
+          noteNumber: c,
+          tick: i,
+          channel: a
+        });
+      } else if ((o & 240) === 128) {
+        const a = o & 15, c = t[s++];
+        t[s++], e.notes.push({
+          type: "noteOff",
+          noteNumber: c,
+          tick: i,
+          channel: a
+        });
+      } else if (o === 240 || o === 247) {
+        const a = this._readVariableLengthValue(t, s);
+        s += a.bytesRead + a.value;
+      } else if ((o & 240) === 176) {
+        const a = o & 15, c = t[s++], h = t[s++];
+        e.events.push({
+          type: "controller",
+          controllerNumber: c,
+          value: h,
+          channel: a,
+          tick: i
+        });
+      } else if ((o & 240) === 192) {
+        const a = o & 15, c = t[s++];
+        e.events.push({
+          type: "programChange",
+          programNumber: c,
+          channel: a,
+          tick: i
+        });
+      } else if ((o & 240) === 208) {
+        const a = o & 15, c = t[s++];
+        e.events.push({
+          type: "channelAftertouch",
+          pressure: c,
+          channel: a,
+          tick: i
+        });
+      } else if ((o & 240) === 224) {
+        const a = o & 15, c = t[s++], m = (t[s++] << 7 | c) - 8192;
+        e.events.push({
+          type: "pitchBend",
+          value: m,
+          channel: a,
+          tick: i
+        });
+      } else if ((o & 240) === 160) {
+        const a = o & 15, c = t[s++], h = t[s++];
+        e.events.push({
+          type: "noteAftertouch",
+          noteNumber: c,
+          pressure: h,
+          channel: a,
+          tick: i
+        });
+      } else
+        console.warn(`Unknown event type: ${o.toString(16)} at position ${s - 1}`), s++;
+    }
+    return e;
+  }
+  /**
+   * Extract metadata from the MIDI object
+   * @private
+   */
+  _extractMetadata(t) {
+    const e = {
+      title: null,
+      composer: null,
+      partNames: [],
+      format: t.format,
+      ticksPerBeat: t.ticksPerBeat
+    };
+    t.tracks.forEach((s, i) => {
+      if (s.name && !e.title && (e.title = s.name), s.events.filter((r) => r.type === "text").forEach((r) => {
+        const n = r.text.toLowerCase();
+        (n.includes("compos") || n.includes("by")) && !e.composer && (e.composer = r.text);
+      }), s.name) {
+        const r = s.name.toLowerCase();
+        for (const n of this.partNames)
+          if (r.includes(n)) {
+            e.partNames.push({
+              index: i,
+              name: s.name
+            });
+            break;
+          }
+      }
+    }), this.parsedData.metadata = e;
+  }
+  /**
+   * Extract bar structure (time signatures, tempo changes)
+   * New format: {"sig": [numerator, denominator], "bpm": tempo_or_array}
+   * @private
+   */
+  _extractBarStructure(t) {
+    const e = t.ticksPerBeat || 480, s = [];
+    t.tracks.forEach((h) => {
+      h.events.forEach((m) => {
+        (m.type === "timeSignature" || m.type === "tempo") && s.push(m);
+      });
+    }), s.sort((h, m) => h.tick - m.tick);
+    let i = 0;
+    t.tracks.forEach((h) => {
+      h.notes && h.notes.forEach((m) => {
+        m.type === "noteOff" && m.tick > i && (i = m.tick);
+      });
+    }), i === 0 && (i = e * 8);
+    const r = [], n = s.filter((h) => h.type === "timeSignature").sort((h, m) => h.tick - m.tick);
+    let l = { numerator: 4, denominator: 4 }, o = 120, a = 0, c = 0;
+    for (; a < i; ) {
+      for (; c < n.length && n[c].tick <= a; )
+        l = n[c], c++;
+      let h;
+      h = a + e * 4 * l.numerator / l.denominator;
+      const m = s.filter(
+        (g) => g.type === "tempo" && g.tick >= a && g.tick < h
+      ), f = l.numerator, u = [];
+      for (let g = 0; g < f; g++) {
+        const y = a + g * e;
+        let w = o;
+        for (let b = m.length - 1; b >= 0; b--) {
+          const T = m[b];
+          if (T.tick <= y) {
+            w = T.bpm;
+            break;
+          }
+        }
+        for (let b = s.length - 1; b >= 0; b--) {
+          const T = s[b];
+          if (T.type === "tempo" && T.tick <= y) {
+            w = T.bpm, T.tick <= a && (o = T.bpm);
+            break;
+          }
+        }
+        u.push(w * l.denominator / 4);
+      }
+      const _ = u.every((g) => g === u[0]) ? u[0] : u;
+      r.push({
+        sig: [l.numerator, l.denominator],
+        bpm: _
+      }), a = h;
+    }
+    this.parsedData.barStructure = r;
+  }
+  /**
+   * Extract notes for each voice part
+   * @private
+   */
+  _extractParts(t) {
+    const e = {}, s = t.ticksPerBeat;
+    t.tracks.forEach((i, r) => {
+      if (!i.notes.length) return;
+      let n = null;
+      if (i.name) {
+        const u = i.name.toLowerCase();
+        for (const d of this.partNames)
+          if (d.length === 1) {
+            if (u === d) {
+              n = d;
+              break;
+            }
+          } else if (u.includes(d)) {
+            n = d;
+            break;
+          }
+      }
+      n || (n = i.name || `Track ${r + 1}`), n === "s" && (n = "soprano"), n === "a" && (n = "alto"), n === "t" && (n = "tenor"), n === "b" && (n = "bass");
+      let l = n, o = 2;
+      for (; e[l]; )
+        l = `${n} ${o}`, o++;
+      n = l;
+      const a = [], c = {};
+      i.notes.forEach((u) => {
+        if (u.type === "noteOn")
+          c[u.noteNumber] = {
+            tick: u.tick,
+            velocity: u.velocity
+          };
+        else if (u.type === "noteOff" && c[u.noteNumber]) {
+          const d = c[u.noteNumber], _ = u.tick - d.tick;
+          a.push({
+            pitch: u.noteNumber,
+            name: this._midiNoteToName(u.noteNumber),
+            startTick: d.tick,
+            endTick: u.tick,
+            duration: _,
+            // Convert ticks to actual time considering tempo changes
+            startTime: this._ticksToTime(d.tick, t),
+            endTime: this._ticksToTime(u.tick, t),
+            velocity: d.velocity
+          }), delete c[u.noteNumber];
+        }
+      });
+      const h = i.lyrics.map((u) => ({
+        text: u.text,
+        tick: u.tick,
+        time: u.tick / s
+        // Time in quarter notes
+      }));
+      a.sort((u, d) => u.startTick - d.startTick);
+      const m = i.events.filter((u) => u.type === "programChange").map((u) => ({
+        programNumber: u.programNumber,
+        tick: u.tick,
+        time: this._ticksToTime(u.tick, t)
+      })).sort((u, d) => u.tick - d.tick), f = m.length > 0 ? m[0].programNumber : 0;
+      e[n] = {
+        notes: a,
+        lyrics: h,
+        trackIndex: r,
+        programChanges: m,
+        defaultInstrument: f
+      };
+    }), this.parsedData.parts = e;
+  }
+  /**
+   * Convert a MIDI note number to note name
+   * @private
+   */
+  _midiNoteToName(t) {
+    const e = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"], s = Math.floor(t / 12) - 1;
+    return `${e[t % 12]}${s}`;
+  }
+  /**
+   * Convert bytes to number
+   * @private
+   */
+  _bytesToNumber(t) {
+    let e = 0;
+    for (let s = 0; s < t.length; s++)
+      e = e << 8 | t[s];
+    return e;
+  }
+  /**
+   * Convert bytes to string
+   * @private
+   */
+  _bytesToString(t) {
+    return new TextDecoder().decode(t);
+  }
+  /**
+   * Read variable-length value from MIDI data
+   * @private
+   */
+  _readVariableLengthValue(t, e) {
+    let s = 0, i, r = 0;
+    do
+      i = t[e + r++], s = s << 7 | i & 127;
+    while (i & 128);
+    return { value: s, bytesRead: r };
+  }
+  /**
+   * Convert ticks to time in seconds considering tempo changes within bars
+   * @private
+   */
+  _ticksToTime(t, e) {
+    const s = e.ticksPerBeat || 480, i = [];
+    e.tracks.forEach((o) => {
+      o.events.forEach((a) => {
+        a.type === "tempo" && i.push(a);
+      });
+    }), i.sort((o, a) => o.tick - a.tick);
+    let r = 0, n = 0, l = 120;
+    for (const o of i) {
+      if (o.tick > t) break;
+      if (o.tick > n) {
+        const c = (o.tick - n) / s * (60 / l);
+        r += c, n = o.tick;
+      }
+      l = o.bpm;
+    }
+    if (t > n) {
+      const a = (t - n) / s * (60 / l);
+      r += a;
+    }
+    return r;
+  }
+}
+class S {
+  constructor() {
+    this.barOrder = [], this.beatTable = [];
+  }
+  /**
+   * Main method to generate beat mapping from parsed MIDI and structure metadata
+   * @param {Object} parsedMidiData - Output from MidiParser
+   * @param {Object} structureMetadata - Score structure with sections and order
+   * @returns {Array} Beat table with time, repeat, bar, and beat information
+   */
+  mapBeats(t, e) {
+    try {
+      return this.barOrder = this.generateBarOrder(e.sections, e.order), this.beatTable = this.generateBeatTable(this.barOrder, t.barStructure), this.beatTable;
+    } catch (s) {
+      throw console.error("Error mapping beats:", s), s;
+    }
+  }
+  /**
+   * Generate ordered sequence of bars with repeat information
+   * @param {Array} sections - Section definitions from structure metadata
+   * @param {Array} order - Play order from structure metadata
+   * @returns {Array} Bar order with bar numbers and repeat counts
+   */
+  generateBarOrder(t, e) {
+    const s = [], i = {};
+    for (const r of e) {
+      const n = t[r.section];
+      if (!n)
+        throw new Error(`Invalid section index: ${r.section}`);
+      const l = r.section;
+      i[l] || (i[l] = 0), i[l]++;
+      const o = i[l], a = r.from !== void 0 ? r.from : this._getSectionStartBar(t, r.section), c = r.to !== void 0 ? r.to : n.to, h = r.as || 1;
+      for (let m = a; m <= c; m++)
+        this._shouldPlayBar(n, m, h) && s.push({
+          barNumber: m,
+          repeat: o,
+          sectionIndex: r.section,
+          voltaTime: h
+        });
+    }
+    return s;
+  }
+  /**
+   * Generate beat table from bar order and MIDI bar structure
+   * @param {Array} barOrder - Bar sequence with repeat information
+   * @param {Array} barStructure - MIDI bar structure with timing info
+   * @returns {Array} Beat table with time, repeat, bar, and beat information
+   */
+  generateBeatTable(t, e) {
+    const s = [];
+    let i = 0;
+    for (const r of t) {
+      const n = r.barNumber, l = e[n];
+      if (!l)
+        throw new Error(`No bar structure data found for bar ${n}`);
+      const { sig: [o, a], bpm: c } = l, h = 60 / c;
+      for (let m = 1; m <= o; m++)
+        s.push({
+          time: i,
+          repeat: r.repeat,
+          bar: n,
+          beat: m
+        }), i += h;
+    }
+    return s;
+  }
+  /**
+   * Determine the starting bar for a section
+   * @private
+   */
+  _getSectionStartBar(t, e) {
+    return t[e].pickup !== void 0 ? 0 : e === 0 ? 1 : t[e - 1].to + 1;
+  }
+  /**
+   * Check if a bar should be played based on volta information
+   * @private
+   */
+  _shouldPlayBar(t, e, s) {
+    if (!t.voltas)
+      return !0;
+    const i = t.voltas.indexOf(e);
+    return i === -1 ? !0 : i + 1 === s;
+  }
+}
+function O(p) {
+  return { all: p = p || /* @__PURE__ */ new Map(), on: function(t, e) {
+    var s = p.get(t);
+    s ? s.push(e) : p.set(t, [e]);
+  }, off: function(t, e) {
+    var s = p.get(t);
+    s && (e ? s.splice(s.indexOf(e) >>> 0, 1) : p.set(t, []));
+  }, emit: function(t, e) {
+    var s = p.get(t);
+    s && s.slice().map(function(i) {
+      i(e);
+    }), (s = p.get("*")) && s.slice().map(function(i) {
+      i(t, e);
+    });
+  } };
+}
+class N {
+  /**
+   * Create a new MidiPlayer instance
+   * @param {AudioEngine} audioEngine - Initialized audio engine instance
+   * @param {Object} instrumentMap - Mapping of part names to instrument configurations  
+   * @param {Object} parsedMidiData - Output from MidiParser
+   * @param {Object} [structureMetadata] - Optional score structure for beat mapping
+   */
+  constructor(t, e, s, i = null) {
+    if (!t || !t.isInitialized)
+      throw new Error("Initialized AudioEngine is required");
+    if (!s)
+      throw new Error("Parsed MIDI data is required");
+    this.audioEngine = t, this.instrumentMap = e || {}, this.parsedData = s, this._isPlaying = !1, this._currentTime = 0, this._totalDuration = 0, this.playbackSpeed = 1, this.partChannels = /* @__PURE__ */ new Map(), this.partOutputs = /* @__PURE__ */ new Map(), this.playbackStartTime = 0, this.lookAheadTime = 0.05, this.scheduleInterval = null, this.partNotePointers = /* @__PURE__ */ new Map(), this.partProgramPointers = /* @__PURE__ */ new Map(), this.eventBus = O(), this.beatMapper = new S(), this.beats = [], this._setupPartChannels(), this._calculateTotalDuration(), this._resetNotePointers(), this._resetProgramPointers(), i ? this.beats = this.beatMapper.mapBeats(s, i) : this.beats = this._generateSimpleBeatMapping();
+  }
+  // ========================================
+  // PUBLIC API METHODS (unchanged interface)
+  // ========================================
+  /**
+   * Start playback from current position
+   */
+  play() {
+    this._isPlaying || (this._isPlaying = !0, this.playbackStartTime = this.audioEngine.audioContext.currentTime - this._currentTime / this.playbackSpeed, this._resetNotePointers(), this._resetProgramPointers(), this._schedulePlayback(), this._startTimeUpdateLoop());
+  }
+  /**
+   * Start playback at a specific audio context time
+   * @param {number} startTime - Audio context time when playback should begin
+   */
+  playAt(t) {
+    this._isPlaying || (this._isPlaying = !0, this.playbackStartTime = t - this._currentTime / this.playbackSpeed, this._resetNotePointers(), this._resetProgramPointers(), this._schedulePlayback(), this._startTimeUpdateLoop());
+  }
+  /**
+   * Pause playback (resumable)
+   */
+  pause() {
+    this._isPlaying && (this._isPlaying = !1, this._stopScheduling(), this._stopTimeUpdateLoop());
+  }
+  /**
+   * Stop playback and reset to beginning
+   */
+  stop() {
+    this._isPlaying = !1, this._currentTime = 0, this._stopScheduling(), this._stopTimeUpdateLoop(), this._resetNotePointers(), this._resetProgramPointers();
+  }
+  /**
+   * Skip to a specific time in seconds
+   * @param {number} seconds - Time to skip to
+   */
+  skipToTime(t) {
+    t = Math.max(0, Math.min(t, this._totalDuration));
+    const e = this._isPlaying;
+    e && this.pause(), this._currentTime = t, this._resetNotePointers(), this._resetProgramPointers(), e && this.play();
+  }
+  /**
+   * Set playback speed
+   * @param {number} speed - Speed multiplier (1.0 = normal)
+   */
+  setPlaybackSpeed(t) {
+    if (t <= 0)
+      throw new Error("Playback speed must be greater than 0");
+    const e = this._isPlaying;
+    e && this.pause(), this.playbackSpeed = t, e && this.play();
+  }
+  /**
+   * Navigate to a specific bar position
+   * @param {number} barNumber - Bar number (1-based)
+   * @param {number} repeat - Repeat section number (0-based)
+   */
+  setBar(t, e = 0) {
+    const s = this.getTimeFromBar(t, e);
+    s !== null && (this.skipToTime(s), this._emitEvent("barChanged", { bar: t, beat: 1, repeat: e, time: s }));
+  }
+  /**
+   * Get time position for a specific bar
+   * @param {number} barNumber - Bar number (1-based)
+   * @param {number} repeat - Repeat section number (0-based)
+   * @returns {number|null} Time in seconds or null if not found
+   */
+  getTimeFromBar(t, e = 0) {
+    const s = this.beats.find(
+      (i) => i.bar === t && i.beat === 1 && i.repeat === e
+    );
+    return s ? s.time : null;
+  }
+  /**
+   * Get bar information for a specific time position
+   * @param {number} time - Time in seconds
+   * @returns {Object|null} Bar info object or null
+   */
+  getBarFromTime(t) {
+    if (!this.beats.length) return null;
+    let e = null;
+    for (let s = this.beats.length - 1; s >= 0; s--)
+      if (this.beats[s].time <= t) {
+        e = this.beats[s];
+        break;
+      }
+    return e;
+  }
+  /**
+   * Stop all sounds immediately
+   */
+  allSoundsOff() {
+    this.audioEngine.allSoundsOff();
+  }
+  /**
+   * Get the output node for a specific part for external mixer routing
+   * 
+   * IMPORTANT: You MUST connect this output to external gain/analyzer nodes:
+   * 
+   * @example
+   * const partOutput = player.getPartOutput('soprano');
+   * const externalGain = audioContext.createGain();
+   * const analyzer = audioContext.createAnalyser();
+   * 
+   * partOutput.connect(externalGain);
+   * externalGain.connect(analyzer);
+   * analyzer.connect(masterGain); // External master gain
+   * 
+   * // Now control volume via external gain:
+   * externalGain.gain.value = 0.5; // 50% volume
+   * 
+   * @param {string} partName - Name of the part (e.g., 'soprano', 'alto')
+   * @returns {AudioNode|null} Output gain node for this part
+   */
+  getPartOutput(t) {
+    return this.partOutputs.get(t) || null;
+  }
+  /**
+   * Get the channel handle for a specific part (for direct note control)
+   * @param {string} partName - Name of the part
+   * @returns {ChannelHandle|null} Channel handle for this part
+   */
+  getPartChannel(t) {
+    return this.partChannels.get(t) || null;
+  }
+  // ========================================
+  // STATE ACCESS METHODS (unchanged)
+  // ========================================
+  getCurrentTime() {
+    if (this._isPlaying) {
+      const t = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed;
+      this._currentTime = Math.min(t, this._totalDuration);
+    }
+    return this._currentTime;
+  }
+  getTotalDuration() {
+    return this._totalDuration;
+  }
+  isPlaying() {
+    return this._isPlaying;
+  }
+  // ========================================
+  // EVENT HANDLING (mitt-based)
+  // ========================================
+  on(t, e) {
+    this.eventBus.on(t, e);
+  }
+  off(t, e) {
+    this.eventBus.off(t, e);
+  }
+  // ========================================
+  // PART-CENTRIC IMPLEMENTATION METHODS
+  // ========================================
+  /**
+   * Set up channel handles for each musical part
+   * @private
+   */
+  _setupPartChannels() {
+    Object.keys(this.parsedData.parts).forEach((t) => {
+      const e = this.parsedData.parts[t], s = this.instrumentMap[t] || {}, i = s.instrument !== void 0 ? s.instrument : e.defaultInstrument !== void 0 ? e.defaultInstrument : 0;
+      try {
+        const r = this.audioEngine.createChannel(t, {
+          instrument: i,
+          initialVolume: s.volume || 1
+        });
+        this.partChannels.set(t, r);
+        const n = this.audioEngine.audioContext.createGain();
+        n.gain.value = 1;
+        const l = r.getOutputNode();
+        l && l.connect(n), this.partOutputs.set(t, n);
+      } catch (r) {
+        console.error(`Failed to create channel for part '${t}':`, r), this._emitEvent("error", r);
+      }
+    });
+  }
+  /**
+   * Calculate total duration from parsed MIDI data
+   * @private
+   */
+  _calculateTotalDuration() {
+    let t = 0;
+    Object.values(this.parsedData.parts).forEach((e) => {
+      e.notes.forEach((s) => {
+        s.endTime > t && (t = s.endTime);
+      });
+    }), this._totalDuration = t;
+  }
+  /**
+   * Schedule all notes for playback using simplified approach
+   * @private
+   */
+  _schedulePlayback() {
+    this._stopScheduling(), this._startScheduleLoop();
+  }
+  /**
+   * Start the simplified scheduling loop
+   * @private
+   */
+  _startScheduleLoop() {
+    this.scheduleInterval || (this.scheduleInterval = setInterval(() => {
+      if (!this._isPlaying) return;
+      const e = (this.audioEngine.audioContext.currentTime - this.playbackStartTime) * this.playbackSpeed, s = e + this.lookAheadTime;
+      for (const [i, r] of this.partChannels) {
+        const n = this.parsedData.parts[i];
+        if (n) {
+          if (n.programChanges && n.programChanges.length > 0) {
+            let l = this.partProgramPointers.get(i) || 0;
+            const o = n.programChanges;
+            for (; l < o.length && o[l].time < e; )
+              l++;
+            for (; l < o.length && o[l].time <= s; ) {
+              const a = o[l];
+              r.setInstrument(a.programNumber), l++;
+            }
+            this.partProgramPointers.set(i, l);
+          }
+          if (n.notes) {
+            let l = this.partNotePointers.get(i) || 0;
+            const o = n.notes;
+            for (; l < o.length && o[l].endTime < e; )
+              l++;
+            for (; l < o.length && o[l].startTime <= s; ) {
+              const a = o[l];
+              if (a.endTime - a.startTime >= 0.01) {
+                const c = this.playbackStartTime + a.startTime / this.playbackSpeed, h = (a.endTime - a.startTime) / this.playbackSpeed;
+                r.playNote(c, a.pitch, a.velocity, h);
+              }
+              l++;
+            }
+            this.partNotePointers.set(i, l);
+          }
+        }
+      }
+    }, 50));
+  }
+  /**
+   * Reset note pointers for all parts based on current playback time
+   * @private
+   */
+  _resetNotePointers() {
+    const t = this._currentTime;
+    for (const [e] of this.partChannels) {
+      const s = this.parsedData.parts[e];
+      if (!s || !s.notes) continue;
+      let i = 0;
+      for (; i < s.notes.length && s.notes[i].endTime < t; )
+        i++;
+      this.partNotePointers.set(e, i);
+    }
+  }
+  /**
+   * Reset program change pointers for all parts based on current playback time
+   * @private
+   */
+  _resetProgramPointers() {
+    const t = this._currentTime;
+    for (const [e, s] of this.partChannels) {
+      const i = this.parsedData.parts[e];
+      if (!i || !i.programChanges) {
+        this.partProgramPointers.set(e, 0);
+        continue;
+      }
+      let r = 0, n = i.defaultInstrument;
+      for (; r < i.programChanges.length && i.programChanges[r].time <= t; )
+        n = i.programChanges[r].programNumber, r++;
+      s.setInstrument(n), this.partProgramPointers.set(e, r);
+    }
+  }
+  /**
+   * Stop scheduling and all channel notes
+   * @private
+   */
+  _stopScheduling() {
+    this.scheduleInterval && (clearInterval(this.scheduleInterval), this.scheduleInterval = null), this.partChannels.forEach((t) => {
+      t.isActive() && t.allNotesOff();
+    });
+  }
+  /**
+   * Start the time update loop for firing timeupdate events
+   * @private
+   */
+  _startTimeUpdateLoop() {
+    this.timeUpdateInterval = setInterval(() => {
+      const t = this.getCurrentTime();
+      this._emitEvent("timeupdate", { currentTime: t });
+      const e = this.getBarFromTime(t);
+      e && this._emitEvent("barChanged", e), t >= this._totalDuration && (this.stop(), this._emitEvent("ended", { finalTime: t }));
+    }, 100);
+  }
+  /**
+   * Stop the time update loop
+   * @private
+   */
+  _stopTimeUpdateLoop() {
+    this.timeUpdateInterval && (clearInterval(this.timeUpdateInterval), this.timeUpdateInterval = null);
+  }
+  /**
+   * Emit an event to all registered listeners
+   * @param {string} eventType - Type of event
+   * @param {any} data - Data to pass to listeners
+   * @private
+   */
+  _emitEvent(t, e) {
+    (this.eventBus.all.get(t) || []).forEach((i) => {
+      try {
+        i(e);
+      } catch (r) {
+        console.error(`Error in ${t} event listener:`, r);
+      }
+    });
+  }
+  /**
+   * Generate simple beat mapping from MIDI tempo changes when no structure metadata provided
+   * @returns {Array} Array of beat mapping objects
+   * @private
+   */
+  _generateSimpleBeatMapping() {
+    const t = [], e = this.parsedData.tempoChanges || [], s = 120, i = this.parsedData.barStructure || [], r = i[0] || { sig: [4, 4], bpm: s }, n = r.sig[0], a = 60 / (Array.isArray(r.bpm) ? r.bpm[0] : r.bpm) * n;
+    if (e.length === 0) {
+      const m = Math.max(1, Math.ceil(this._totalDuration / a));
+      let f = 0;
+      for (let u = 1; u <= m; u++) {
+        const d = Math.max(0, u - 1), _ = i[d] || r, g = _.sig[0], y = Array.isArray(_.bpm) ? _.bpm[0] : _.bpm, w = 60 / y;
+        for (let b = 1; b <= g; b++)
+          t.push({
+            bar: u,
+            beat: b,
+            repeat: 0,
+            tempo: y,
+            time: f,
+            timeSig: g
+          }), f += w;
+      }
+      return t;
+    }
+    let c = 0, h = 1;
+    for (let m = 0; m < e.length; m++) {
+      const f = e[m], u = e[m + 1], d = u ? u.time : this._totalDuration, _ = f.tempo || s, g = 60 / _;
+      for (; c < d; ) {
+        for (let y = 1; y <= n && c < d; y++)
+          t.push({
+            bar: h,
+            beat: y,
+            repeat: 0,
+            tempo: _,
+            time: c,
+            timeSig: n
+          }), c += g;
+        h++;
+      }
+    }
+    return t;
+  }
+  /**
+   * Clean up resources and destroy the player
+   */
+  destroy() {
+    this.stop(), this.partChannels.forEach((t) => {
+      t.destroy();
+    }), this.partChannels.clear(), this.partOutputs.forEach((t) => {
+      t.disconnect();
+    }), this.partOutputs.clear(), this.partNotePointers.clear(), this.partProgramPointers.clear(), this.eventBus.all.clear();
+  }
+}
+const C = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  k as AudioEngine,
+  P as AudioEngineUtils,
+  S as BeatMapper,
+  v as ChannelHandle,
+  E as MidiParser,
+  N as MidiPlayer,
+  B as SpessaSynthAudioEngine,
+  x as SpessaSynthChannelHandle
+};