audio-mixer-engine 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "audio-mixer-engine",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Audio engine library for audio mixer applications with MIDI parsing, playback, and synthesis",
   "main": "src/index.js",
   "type": "module",

package/src/lib/audio-engine.js

@@ -1,3 +1,6 @@
+import stick4csUrl from '../assets/stick-4cs.mp3';
+import stick4dUrl from '../assets/stick-4d.mp3';
+
 /**
  * Abstract AudioEngine - Part-centric audio synthesis for audio mixers
  * This class provides the contract for creating and managing musical parts
@@ -124,8 +127,8 @@ export default class AudioEngine {
       // Try to load tick sound files if available
       if (typeof fetch !== 'undefined') {
         const [regularResponse, accentResponse] = await Promise.all([
-          fetch('sounds/click-regular.mp3'),
-          fetch('sounds/click-accent.mp3')
+          fetch(stick4csUrl),
+          fetch(stick4dUrl)
         ]);
 
         const [regularBuffer, accentBuffer] = await Promise.all([
@@ -461,6 +464,83 @@ export class ChannelHandle {
   }
 }
 
+const MidiInstrumentNumbers = {
+  // 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
+};
+
+const MidiInstrumentNames = Object.entries(MidiInstrumentNumbers)
+  .reduce((o,[k,v])=>{
+    o[v]=k;
+    return o;
+  },{})
+
 /**
  * Utility class for common audio engine operations
  */
@@ -472,79 +552,7 @@ export class AudioEngineUtils {
    */
   static getInstrumentProgram(instrument) {
     if (typeof instrument === 'number') return instrument;
-    
-    const instrumentMap = {
-      // 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
-    };
-
-    const program = instrumentMap[instrument.toLowerCase()];
+    const program = MidiInstrumentNumbers[instrument.toLowerCase()];
     return program !== undefined ? program : 0; // Default to Piano
   }
 
@@ -554,73 +562,8 @@ export class AudioEngineUtils {
    * @returns {string} Instrument name or fallback
    */
   static getProgramName(programNumber) {
-    const programNames = [
-      // 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'
-    ];
-    
-    return programNames[programNumber] || `Program ${programNumber}`;
+
+    return MidiInstrumentNames[programNumber] || `Program ${programNumber}`;
   }
 
   /**

package/src/lib/beat-mapper.js

@@ -18,7 +18,6 @@ class BeatMapper {
     try {
       // Step 1: Generate the bar order from sections and order
       this.barOrder = this.generateBarOrder(structureMetadata.sections, structureMetadata.order);
-      
       // Step 2: Generate beat table from bar order and MIDI bar structure
       this.beatTable = this.generateBeatTable(this.barOrder, parsedMidiData.barStructure);
       
@@ -85,95 +84,13 @@ class BeatMapper {
    */
   generateBeatTable(barOrder, barStructure) {
     const beatTable = [];
-    
-    // Detect if we need the complex BEATMAPPING.md algorithm
-    const needsComplexAlgorithm = this._needsComplexAlgorithm(barOrder, barStructure);
-    
-    if (needsComplexAlgorithm) {
-      return this._generateBeatTableComplex(barOrder, barStructure);
-    } else {
-      return this._generateBeatTableSimple(barOrder, barStructure);
-    }
-  }
-  
-  /**
-   * Determine if we need the complex barBeats tracking algorithm
-   * @private
-   */
-  _needsComplexAlgorithm(barOrder, barStructure) {
-    // Check for scenarios that require barBeats tracking:
-    // 1. Bar numbers repeat (same bar appears multiple times)
-    // 2. MIDI structure doesn't match bar order length (mismatches) - BUT not for simple offset cases
-    
-    const barNumbers = barOrder.map(b => b.barNumber);
-    const uniqueBars = new Set(barNumbers);
-    const hasRepeatedBars = uniqueBars.size < barNumbers.length;
-    
-    // Only treat as mismatch if it's a significant difference (not just pickup offset)
-    const significantMismatch = Math.abs(barOrder.length - barStructure.length) > 1;
-    
-    return hasRepeatedBars || significantMismatch;
-  }
-  
-  /**
-   * Simple direct mapping for basic cases
-   * @private
-   */
-  _generateBeatTableSimple(barOrder, barStructure) {
-    const beatTable = [];
-    
-    // Handle both direct mapping and sequential mapping
-    const hasPickupBar = barStructure[0] && barStructure[0].sig && barStructure[0].sig[0] === 1;
-    const startsWithBarZero = barOrder.length > 0 && barOrder[0].barNumber === 0;
-    const isDirectMapping = hasPickupBar && startsWithBarZero;
-    
-    for (let i = 0; i < barOrder.length; i++) {
-      const barInfo = barOrder[i];
-      let midiBar;
-      
-      if (isDirectMapping) {
-        // Direct mapping: bar number = MIDI index
-        midiBar = barStructure[barInfo.barNumber];
-      } else {
-        // Sequential mapping: i-th score bar = i-th MIDI bar
-        // If there's a pickup bar and we're not starting from bar 0, offset by 1
-        const offset = (hasPickupBar && !startsWithBarZero) ? 1 : 0;
-        midiBar = barStructure[i + offset];
-      }
-      
-      if (!midiBar) {
-        throw new Error(`No MIDI bar data for bar ${barInfo.barNumber}`);
-      }
-      
-      this._generateBeatsForBar(beatTable, barInfo, midiBar, midiBar.sig[0]);
-    }
-    
-    return beatTable;
-  }
-  
-  /**
-   * Complex algorithm from BEATMAPPING.md for handling mismatches and repeats
-   * @private
-   */
-  _generateBeatTableComplex(barOrder, barStructure) {
-    const beatTable = [];
     const barBeats = {}; // Track beat count for each bar number (step 3)
     let midiBarI = 0; // Index into MIDI bar array (step 1)
     let scoreBarI = 0; // Index into score bar order array (step 1)
     
     // Create a working copy of barStructure to allow modifications
     const workingBarStructure = [...barStructure];
-    
-    // Special handling: if we have a pickup bar but don't start from bar 0,
-    // we need to find the correct starting MIDI bar
-    const hasPickupBar = workingBarStructure[0] && workingBarStructure[0].sig && workingBarStructure[0].sig[0] === 1;
-    const firstBarNumber = barOrder[0]?.barNumber || 0;
-    
-    if (hasPickupBar && firstBarNumber > 0) {
-      // Skip to the MIDI bar that corresponds to the first requested bar
-      midiBarI = firstBarNumber;
-    }
-    
+
     // Algorithm from BEATMAPPING.md steps 1-10
     while (scoreBarI < barOrder.length && midiBarI < workingBarStructure.length) {
       const barInfo = barOrder[scoreBarI];

package/src/lib/midi-player.js

@@ -29,11 +29,11 @@ export default class MidiPlayer {
   /**
    * 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} instrumentMap - Mapping of part names to instrument configurations
    * @param {Object} [structureMetadata] - Optional score structure for beat mapping
    */
-  constructor(audioEngine, instrumentMap, parsedMidiData, structureMetadata = null) {
+  constructor(audioEngine, parsedMidiData, instrumentMap = null, structureMetadata = null) {
     // Validate required parameters
     if (!audioEngine || !audioEngine.isInitialized) {
       throw new Error('Initialized AudioEngine is required');
@@ -594,40 +594,11 @@ export default class MidiPlayer {
    * @private
    */
   _createDefaultStructureMetadata() {
-    const barStructure = this.parsedData.barStructure || [];
-    
-    // Determine number of bars from barStructure (index 0 is null/unused)
-    let numBars = 1; // Default fallback
-    if (barStructure.length > 1) {
-      numBars = barStructure.length;
-    } else {
-      // No barStructure exists - we need to create default barStructure
-      // Estimate from duration using default bar timing
-      const defaultTempo = 120;
-      const defaultBeatsPerBar = 4;
-      const secondsPerBeat = 60 / defaultTempo;
-      const secondsPerBar = secondsPerBeat * defaultBeatsPerBar;
-      
-      if (this._totalDuration > 0) {
-        numBars = Math.max(1, Math.ceil(this._totalDuration / secondsPerBar));
-      } else {
-        numBars = 1; // Fallback for zero duration
-      }
-      
-      // Create default barStructure for BeatMapper to use
-      this.parsedData.barStructure = [null]; // Index 0 is unused
-      for (let i = 1; i <= numBars; i++) {
-        const barStartTime = (i - 1) * 2; // Each bar is 2 seconds (4 beats * 0.5s/beat at 120 BPM)
-        this.parsedData.barStructure[i] = { 
-          sig: [4, 4], 
-          beats: [barStartTime, barStartTime + 0.5, barStartTime + 1, barStartTime + 1.5] 
-        };
-      }
-    }
+    const barStructure = this.parsedData.barStructure;
     
     return {
       sections: [
-        { from: 1, to: numBars } // Single section covering all bars
+        { from: 1, to: barStructure.length } // Single section covering all bars
       ],
       order: [
         { section: 0 } // Play section 0 once (no repeats)

package/src/lib/playback-manager.js

@@ -1,6 +1,4 @@
 import mitt from 'mitt';
-import stick4csUrl from '../assets/stick-4cs.mp3';
-import stick4dUrl from '../assets/stick-4d.mp3';
 
 /**
  * PlaybackManager - High-level orchestration for MIDI playback, metronome, and lead-in
@@ -69,8 +67,7 @@ export default class PlaybackManager {
     // Beat-based metronome scheduling
     this.nextBeatIndex = 0; // Index of next beat to play
 
-    // Audio setup
-    this._setupMetronomeAudio();
+    // Event setup
     this._setupEventDelegation();
 
     // Input validation
@@ -459,17 +456,6 @@ export default class PlaybackManager {
    */
   allSoundsOff() {
     this.midiPlayer.allSoundsOff();
-    
-    // Stop metronome sounds
-    if (this.currentMetronomeSource) {
-      try {
-        this.currentMetronomeSource.disconnect();
-        this.currentMetronomeSource.stop();
-        this.currentMetronomeSource = null;
-      } catch (error) {
-        // Ignore errors from already stopped sources
-      }
-    }
   }
 
   // ========================================
@@ -510,57 +496,7 @@ export default class PlaybackManager {
   // PRIVATE IMPLEMENTATION METHODS
   // ========================================
 
-  /**
-   * Set up metronome audio using direct audio files
-   * @private
-   */
-  async _setupMetronomeAudio() {
-    try {
-      // Create output gain node for mixer control
-      this.metronomeOutput = this.audioEngine.audioContext.createGain();
-      this.metronomeOutput.gain.value = this.metronomeConfig.volume;
-
-      // Load metronome sound files
-      this.metronomeBuffers = null; // Will be loaded lazily
-      this.currentMetronomeSource = null;
-
-    } catch (error) {
-      console.error('Failed to setup metronome audio:', error);
-      throw new Error('Failed to initialize metronome audio: ' + error.message);
-    }
-  }
-
-  /**
-   * Ensure metronome audio buffers are loaded
-   * @private
-   */
-  async _ensureMetronomeBuffersLoaded() {
-    if (this.metronomeBuffers) {
-      return; // Already loaded
-    }
-
-    try {
-      // Check if we're in a test environment or asset URLs are undefined
-      if (typeof window === 'undefined' || typeof fetch === 'undefined' || !stick4csUrl || !stick4dUrl) {
-        // Mock buffers for testing environment
-        console.log('Test environment detected, using mock metronome buffers');
-        this.metronomeBuffers = [null, null];
-        return;
-      }
-      
-      // Load both sound files from bundled assets
-      this.metronomeBuffers = await Promise.all([
-        fetch(stick4csUrl).then(r => r.arrayBuffer()).then(b => this.audioEngine.audioContext.decodeAudioData(b)),
-        fetch(stick4dUrl).then(r => r.arrayBuffer()).then(b => this.audioEngine.audioContext.decodeAudioData(b))
-      ]);
 
-    } catch (error) {
-      console.error('Failed to load metronome sound buffers:', error);
-      // Set empty buffers to prevent repeated attempts
-      this.metronomeBuffers = [null, null];
-      throw error;
-    }
-  }
 
   /**
    * Set up event delegation from MidiPlayer
@@ -665,44 +601,21 @@ export default class PlaybackManager {
     const startTime = this.frozenTime;
     const leadInBars = this.leadInConfig.bars;
 
-    if (!beats || beats.length === 0) {
-      // Fallback to simple calculation
-      const defaultPeriod = 0.5;
-      const defaultBeatsPerBar = 4;
-      const totalBeats = leadInBars * defaultBeatsPerBar ;
-      
-      return {
-        totalBeats,
-        duration: totalBeats * defaultPeriod,
-        beatSequence: this._generateBeatSequence(totalBeats, defaultPeriod, defaultBeatsPerBar),
-        beatsPerBar: defaultBeatsPerBar
-      };
-    }
-
     // Find the last beat at or before start time
     // And, the time between this beat and the next, or the one before
-    let startBeat = beats[0], beatPeriod = 0.5;
-    for (let i = beats.length - 1; i >= 0; i--) {
-      if (beats[i].time <= startTime) {
-        startBeat = beats[i];
-        if (i + 1 < beats.length) beatPeriod = beats[i+1].time - startBeat.time;
-        else if (i>0) beatPeriod = startBeat.time - beats[i-1].time;
-        break;
-      }
-    }
+    let startIndex = beats.length-1, beatPeriod = 0.5;
+    while (beats[startIndex].time > startTime) startIndex--;
+    const startBeat = beats[startIndex];
+    const nextBeat = beats[startIndex + 1];
+    if (nextBeat) beatPeriod = nextBeat.time - startBeat.time;
+    else if (startIndex>0) beatPeriod = startBeat.time - beats[startIndex-1].time;
 
-    // Extract tempo and time signature from bar structure at start position
-    const barIndex = Math.max(0, startBeat.bar - 1);
-    const barStructure = this.midiPlayer.parsedData.barStructure || [];
-    const currentBarData = barStructure[barIndex] || { sig: [4, 4], bpm: 120 };
-    
-    const beatsPerBar = startBeat.timeSig;
-    const tempo = Array.isArray(currentBarData.bpm) ? currentBarData.bpm[0] : currentBarData.bpm;
-    
+    const isPickup = startBeat.timeSig === 1
+    const beatsPerBar = isPickup && nextBeat? nextBeat.timeSig : startBeat.timeSig;
 
     // Calculate beats needed: full lead-in bars + beats from current position to reach start position
     // If we're at beat 2 of 4, we need 1 more beat to complete current bar (just the difference to next downbeat)
-    const beatsToStart = startBeat.beat > 1 ? startBeat.beat - 1 : 0;
+    const beatsToStart = isPickup ? beatsPerBar - 1 : startBeat.beat > 1 ? startBeat.beat - 1 : 0;
     const totalBeats = leadInBars * beatsPerBar + beatsToStart;
 
     return {
@@ -966,7 +879,7 @@ export default class PlaybackManager {
    * @private
    */
   _scheduleMetronomeTicksAt(startTime) {
-    if (!this.metronomeConfig.enabled || !this.metronomeOutput) {
+    if (!this.metronomeConfig.enabled) {
       return;
     }
 
@@ -1004,7 +917,7 @@ export default class PlaybackManager {
    * @private
    */
   _scheduleMetronomeTicks() {
-    if (!this.metronomeConfig.enabled || !this.metronomeOutput) {
+    if (!this.metronomeConfig.enabled) {
       return;
     }
 
@@ -1202,21 +1115,6 @@ export default class PlaybackManager {
     this._stopMetronome();
     this._stopTimeUpdateLoop();
 
-    // Stop and cleanup metronome audio
-    if (this.currentMetronomeSource) {
-      try {
-        this.currentMetronomeSource.disconnect();
-        this.currentMetronomeSource.stop();
-      } catch (error) {
-        // Ignore errors from already stopped sources
-      }
-      this.currentMetronomeSource = null;
-    }
-
-    // Disconnect metronome output
-    if (this.metronomeOutput) {
-      this.metronomeOutput.disconnect();
-    }
 
     // Clear event bus
     this.eventBus.all.clear();