midi player on frontend

backend/main.py

@@ -376,6 +376,40 @@ async def download_midi(job_id: str):
     )
 
 
+@app.get("/api/v1/scores/{job_id}/metadata")
+async def get_metadata(job_id: str):
+    """
+    Get detected metadata for a completed transcription.
+
+    Returns tempo, key signature, and time signature detected from audio.
+
+    Args:
+        job_id: Job identifier
+
+    Returns:
+        JSON with tempo, key_signature, time_signature
+    """
+    job_data = redis_client.hgetall(f"job:{job_id}")
+
+    if not job_data or job_data.get('status') != 'completed':
+        raise HTTPException(status_code=404, detail="Metadata not available")
+
+    metadata_str = job_data.get('metadata')
+    if not metadata_str:
+        # Return defaults if metadata not stored (for older jobs)
+        return {
+            "tempo": 120.0,
+            "key_signature": "C",
+            "time_signature": {"numerator": 4, "denominator": 4},
+        }
+
+    try:
+        metadata = json.loads(metadata_str)
+        return metadata
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail="Invalid metadata format")
+
+
 # === WebSocket Endpoint ===
 
 @app.websocket("/api/v1/jobs/{job_id}/stream")
@@ -401,10 +435,19 @@ async def websocket_endpoint(websocket: WebSocket, job_id: str):
                     update = json.loads(message['data'])
                     await websocket.send_json(update)
 
-                    # Close connection if job completed or failed
-                    if update.get('type') in ['completed', 'error']:
+                    # Close connection if job completed
+                    if update.get('type') == 'completed':
                         break
 
+                    # Close connection if job failed with non-retryable error
+                    if update.get('type') == 'error':
+                        error_info = update.get('error', {})
+                        is_retryable = error_info.get('retryable', False)
+                        if not is_retryable:
+                            # Only close if error is permanent
+                            break
+                        # If retryable, keep connection open for retry progress updates
+
         # Send initial status
         job_data = redis_client.hgetall(f"job:{job_id}")
         if job_data:

backend/pipeline.py

@@ -54,6 +54,13 @@ class TranscriptionPipeline:
         else:
             self.config = config
 
+        # Store detected metadata for API access
+        self.metadata = {
+            "tempo": 120.0,
+            "time_signature": {"numerator": 4, "denominator": 4},
+            "key_signature": "C",
+        }
+
     def set_progress_callback(self, callback) -> None:
         """Set callback for progress updates: callback(percent, stage, message)"""
         self.progress_callback = callback
@@ -335,6 +342,8 @@ class TranscriptionPipeline:
             midi_path = transcriber.transcribe_audio(audio_path, output_dir)
 
             print(f"   ✓ YourMT3+ transcription complete")
+            print(f"   [DEBUG] MIDI path returned: {midi_path}")
+            print(f"   [DEBUG] MIDI exists at returned path: {midi_path.exists()}")
             return midi_path
 
         except Exception as e:
@@ -1269,10 +1278,23 @@ class TranscriptionPipeline:
         print(f"   Detected: {detected_tempo} BPM (confidence: {tempo_confidence:.2f})")
         print(f"   Detected: {time_sig_num}/{time_sig_denom} time (confidence: {ts_confidence:.2f})")
 
+        # Step 1.5: Validate and adjust metadata
+        detected_tempo, time_sig_num, time_sig_denom = self._validate_and_adjust_metadata(
+            midi_path,
+            detected_tempo,
+            tempo_confidence,
+            time_sig_num,
+            time_sig_denom,
+            ts_confidence
+        )
+
         self.progress(93, "musicxml", "Parsing MIDI")
 
         # Step 2: Parse MIDI
+        print(f"   [DEBUG] About to parse MIDI: {midi_path}")
+        print(f"   [DEBUG] MIDI exists before parsing: {midi_path.exists()}")
         score = converter.parse(midi_path)
+        print(f"   [DEBUG] MIDI exists after parsing: {midi_path.exists()}")
 
         self.progress(94, "musicxml", "Detecting key signature")
 
@@ -1280,10 +1302,22 @@ class TranscriptionPipeline:
         detected_key, key_confidence = self.detect_key_ensemble(score, source_audio)
         print(f"   Detected key: {detected_key} (confidence: {key_confidence:.2f})")
 
+        # Store metadata for API access
+        self.metadata = {
+            "tempo": float(detected_tempo),
+            "time_signature": {"numerator": int(time_sig_num), "denominator": int(time_sig_denom)},
+            "key_signature": str(detected_key),
+        }
+
+        # Step 3.5: Snap durations to prevent makeMeasures from creating impossible tuplets
+        print(f"   Snapping note durations to MusicXML-safe values...")
+        score = self._snap_all_durations_pre_measures(score)
+
         self.progress(96, "musicxml", "Creating measures")
 
-        # Step 4: Create measures
-        score = score.makeMeasures()
+        # Step 4: Create measures WITHOUT splitting notes
+        # Using custom function to prevent makeMeasures from splitting notes across measure boundaries
+        score = self._create_measures_without_splitting(score, time_sig_num, time_sig_denom)
 
         # Step 5: Grand staff split (optional)
         if self.config.enable_grand_staff:
@@ -1314,6 +1348,12 @@ class TranscriptionPipeline:
         # YourMT3+ output is clean, but music21 has limitations on complex durations
         score = self._remove_impossible_durations(score)
 
+        # Step 5.6: Split complex durations to make them exportable
+        # This is critical - music21 won't export notes with "complex" durations
+        # even if they're standard note values, if they don't fit cleanly in measures
+        print(f"   Splitting complex durations for MusicXML export...")
+        score = self._split_complex_durations_for_export(score)
+
         self.progress(98, "musicxml", "Exporting MusicXML")
 
         # Step 6: Export MusicXML
@@ -1322,12 +1362,15 @@ class TranscriptionPipeline:
         print(f"   Writing MusicXML to {output_path}...")
         try:
             score.write('musicxml', fp=str(output_path), makeNotation=False)
+            print(f"   ✓ Successfully exported with makeNotation=False (preserving exact durations)")
         except Exception as e:
-            # If export still fails due to complex durations, try with makeNotation=True
-            # This lets music21 handle the complex durations automatically
-            print(f"   WARNING: Export failed with makeNotation=False: {e}")
-            print(f"   Retrying with makeNotation=True (auto-notation)...")
+            # If export still fails, we have a fundamental problem
+            # Log the error but DON'T use makeNotation=True as it corrupts the data
+            print(f"   ERROR: Export failed even after duration splitting: {e}")
+            print(f"   This indicates a music21 limitation. Attempting export anyway...")
+            # Try one more time with makeNotation=True as last resort
             score.write('musicxml', fp=str(output_path), makeNotation=True)
+            print(f"   WARNING: Used makeNotation=True - timing may be corrupted")
 
         print(f"   ✓ MusicXML generation complete")
         return output_path
@@ -1721,28 +1764,244 @@ class TranscriptionPipeline:
 
         return score
 
-    def _remove_impossible_durations(self, score) -> stream.Score:
+    def _validate_and_adjust_metadata(
+        self,
+        midi_path: Path,
+        tempo: float,
+        tempo_confidence: float,
+        time_sig_num: int,
+        time_sig_denom: int,
+        ts_confidence: float,
+        confidence_threshold: float = 0.5
+    ) -> tuple[float, int, int]:
+        """
+        Validate detected metadata and adjust if confidence is low or values are unusual.
+
+        Wrong metadata (especially time signature) causes makeMeasures() to create
+        incorrect measure boundaries, leading to note splitting and duration corruption.
+
+        Args:
+            midi_path: Path to MIDI file (to check for embedded tempo)
+            tempo: Detected tempo in BPM
+            tempo_confidence: Confidence score (0.0-1.0)
+            time_sig_num: Time signature numerator
+            time_sig_denom: Time signature denominator
+            ts_confidence: Time signature confidence score (0.0-1.0)
+            confidence_threshold: Minimum confidence to trust detection
+
+        Returns:
+            Tuple of (adjusted_tempo, adjusted_time_sig_num, adjusted_time_sig_denom)
+        """
+        from music21 import converter, tempo as m21_tempo
+
+        adjusted_tempo = tempo
+        adjusted_time_sig_num = time_sig_num
+        adjusted_time_sig_denom = time_sig_denom
+
+        # Validate tempo
+        if tempo_confidence < confidence_threshold:
+            print(f"   WARNING: Low tempo confidence ({tempo_confidence:.2f}), checking MIDI for embedded tempo...")
+
+            # Try to extract tempo from MIDI file
+            try:
+                score = converter.parse(midi_path)
+                tempo_marks = score.flatten().getElementsByClass(m21_tempo.MetronomeMark)
+
+                if tempo_marks:
+                    midi_tempo = tempo_marks[0].number
+                    if midi_tempo and 40 <= midi_tempo <= 240:  # Reasonable tempo range
+                        print(f"   Using MIDI embedded tempo: {midi_tempo} BPM")
+                        adjusted_tempo = float(midi_tempo)
+                    else:
+                        print(f"   MIDI tempo {midi_tempo} out of range, using detected tempo")
+                else:
+                    print(f"   No MIDI tempo found, using detected tempo")
+            except Exception as e:
+                print(f"   Failed to extract MIDI tempo: {e}")
+
+        # Validate time signature
+        VALID_TIME_SIGS = [(4, 4), (3, 4), (6, 8), (2, 4), (12, 8), (2, 2), (3, 8), (5, 4), (7, 8)]
+
+        if (time_sig_num, time_sig_denom) not in VALID_TIME_SIGS:
+            print(f"   WARNING: Unusual time signature {time_sig_num}/{time_sig_denom}, defaulting to 4/4")
+            adjusted_time_sig_num, adjusted_time_sig_denom = 4, 4
+        elif ts_confidence < confidence_threshold:
+            print(f"   WARNING: Low time signature confidence ({ts_confidence:.2f}), defaulting to 4/4")
+            adjusted_time_sig_num, adjusted_time_sig_denom = 4, 4
+
+        # Final sanity checks
+        if not (40 <= adjusted_tempo <= 240):
+            print(f"   WARNING: Tempo {adjusted_tempo} out of range [40-240], defaulting to 120 BPM")
+            adjusted_tempo = 120.0
+
+        return adjusted_tempo, adjusted_time_sig_num, adjusted_time_sig_denom
+
+    def _create_measures_without_splitting(
+        self,
+        score,
+        time_sig_num: int,
+        time_sig_denom: int
+    ) -> stream.Score:
+        """
+        Create measures manually without using makeMeasures().
+
+        music21's makeMeasures() corrupts YourMT3+ output by:
+        1. Adding rests at the beginning to align with measure boundaries
+        2. Splitting notes across measure boundaries
+        3. Re-quantizing durations when exporting with makeNotation=True
+
+        This function manually creates measures by calculating boundaries
+        from the time signature and inserting measure markers WITHOUT
+        modifying note timing or durations.
+        """
+        from music21 import stream, meter, bar
+
+        print(f"   Creating measures manually to preserve note timing...")
+
+        # Calculate measure duration in quarter notes
+        # time_sig_num / time_sig_denom gives fraction of whole note
+        # Multiply by 4 to get quarter notes
+        measure_duration = (time_sig_num / time_sig_denom) * 4.0
+
+        # Get all notes from the score
+        all_notes = list(score.flatten().notesAndRests)
+        if not all_notes:
+            return score
+
+        # Find the end time of the last note
+        last_note = max(all_notes, key=lambda n: n.offset + n.quarterLength)
+        total_duration = last_note.offset + last_note.quarterLength
+
+        # Calculate number of measures needed
+        num_measures = int(total_duration / measure_duration) + 1
+
+        print(f"   Total duration: {total_duration:.2f} quarter notes")
+        print(f"   Measure duration: {measure_duration:.2f} quarter notes")
+        print(f"   Creating {num_measures} measures...")
+
+        # Create new score with measures
+        new_score = stream.Score()
+        ts = meter.TimeSignature(f'{time_sig_num}/{time_sig_denom}')
+
+        for part in score.parts:
+            new_part = stream.Part()
+            new_part.id = part.id
+            new_part.partName = getattr(part, 'partName', 'Piano')
+
+            # Create measures and distribute notes
+            for measure_num in range(num_measures):
+                measure_start = measure_num * measure_duration
+                measure_end = measure_start + measure_duration
+
+                new_measure = stream.Measure(number=measure_num + 1)
+
+                # Add time signature to first measure only
+                if measure_num == 0:
+                    new_measure.timeSignature = ts
+
+                # Find notes that START in this measure
+                # (Don't split notes that cross measure boundaries - just put them in the measure where they start)
+                for note in part.flatten().notesAndRests:
+                    note_start = note.offset
+                    if measure_start <= note_start < measure_end:
+                        # Calculate offset within measure
+                        measure_offset = note_start - measure_start
+                        # Insert note at its original offset within the measure
+                        new_measure.insert(measure_offset, note)
+
+                new_part.append(new_measure)
+
+            new_score.append(new_part)
+
+        notes_after = sum(1 for _ in new_score.flatten().notesAndRests)
+        print(f"   ✓ Created {num_measures} measures preserving all {notes_after} notes")
+
+        return new_score
+
+    def _split_complex_durations_for_export(self, score) -> stream.Score:
+        """
+        Skip duration splitting - it's causing note loss!
+
+        splitAtDurations() was removing notes instead of splitting them,
+        reducing the note count from 2,347 to 1,785 (24% data loss).
+
+        Since we're now successfully exporting with makeNotation=False,
+        we should preserve the exact durations from YourMT3+ without
+        any additional processing.
+
+        Args:
+            score: music21 Score with measures
+
+        Returns:
+            Score unchanged
+        """
+        print(f"   Skipping duration splitting to preserve YourMT3+ note data...")
+        return score
+
+    def _snap_all_durations_pre_measures(self, score) -> stream.Score:
         """
-        Remove notes/rests with durations too short for MusicXML export (<128th note).
+        Snap all note durations to MusicXML-safe values BEFORE makeMeasures().
+
+        This prevents music21's makeMeasures() from creating complex tuplets or
+        impossible durations when trying to fit notes into measure boundaries.
+
+        Args:
+            score: music21 Score (flat stream, before makeMeasures)
+
+        Returns:
+            Score with snapped durations
+        """
+        from music21 import stream
+
+        # MusicXML-safe durations (in quarter notes)
+        # whole, dotted half, half, dotted quarter, quarter, dotted eighth, eighth, dotted 16th, 16th, 32nd
+        SAFE_DURATIONS = [4.0, 3.0, 2.0, 1.5, 1.0, 0.75, 0.5, 0.375, 0.25, 0.125]
+
+        snapped_count = 0
+        total_diff = 0.0
+
+        for part in score.parts:
+            for element in part.flatten().notesAndRests:
+                current_dur = element.quarterLength
+
+                # Find nearest safe duration
+                best_dur = min(SAFE_DURATIONS, key=lambda x: abs(x - current_dur))
+
+                # Only snap if different (tolerance: 0.01 quarter notes)
+                if abs(best_dur - current_dur) > 0.01:
+                    diff = abs(best_dur - current_dur)
+                    total_diff += diff
+                    element.quarterLength = best_dur
+                    snapped_count += 1
+
+        if snapped_count > 0:
+            avg_diff = total_diff / snapped_count
+            print(f"   Snapped {snapped_count} note durations (avg change: {avg_diff:.4f} quarter notes)")
+
+        return score
+
+    def _remove_impossible_durations(self, score, log_removed: bool = True) -> stream.Score:
+        """
+        Remove notes/rests with durations too short for MusicXML export (<64th note).
 
         music21's makeMeasures() can create rests with impossible durations (2048th notes)
         when filling gaps. This removes them to prevent MusicXML export errors.
 
         Args:
             score: music21 Score with measures
+            log_removed: If True, log details of first few removed notes
 
         Returns:
             Cleaned score
         """
         from music21 import note, stream
 
-        # Remove notes shorter than 32nd note to prevent impossible tuplets
-        # basic-pitch can create very short notes that cause music21 to generate
-        # complex tuplets with impossible durations (2048th notes)
-        # 32nd note is a reasonable minimum for piano music
-        MIN_DURATION = 0.125  # 32nd note (1.0 / 8)
+        # Remove notes shorter than 64th note (lowered from 32nd)
+        # YourMT3+ produces cleaner output, so we can use a lower threshold
+        # 64th note = 0.0625 quarter notes (1.0 / 16)
+        MIN_DURATION = 0.0625  # 64th note
 
-        removed_count = 0
+        removed_notes = []
         for part in score.parts:
             for measure in part.getElementsByClass('Measure'):
                 # Collect elements to remove
@@ -1750,15 +2009,37 @@ class TranscriptionPipeline:
 
                 for element in measure.notesAndRests:
                     if element.quarterLength < MIN_DURATION:
+                        # Log note details before removing
+                        if log_removed and len(removed_notes) < 10:
+                            if hasattr(element, 'pitch'):
+                                pitch_name = element.pitch.nameWithOctave
+                            elif isinstance(element, note.Rest):
+                                pitch_name = 'Rest'
+                            else:
+                                pitch_name = 'Unknown'
+
+                            removed_notes.append({
+                                'pitch': pitch_name,
+                                'duration': element.quarterLength,
+                                'offset': element.offset,
+                                'measure': measure.number if hasattr(measure, 'number') else 0
+                            })
+
                         to_remove.append(element)
-                        removed_count += 1
 
                 # Remove impossible durations
                 for element in to_remove:
                     measure.remove(element)
 
-        if removed_count > 0:
-            print(f"   Removed {removed_count} notes/rests shorter than 32nd note to prevent tuplet errors")
+        if removed_notes:
+            print(f"   Removed {len(removed_notes)} notes/rests shorter than 64th note:")
+            for note_data in removed_notes[:5]:  # Show first 5
+                # Convert Fraction to float for formatting
+                duration_val = float(note_data['duration']) if hasattr(note_data['duration'], 'numerator') else note_data['duration']
+                offset_val = float(note_data['offset']) if hasattr(note_data['offset'], 'numerator') else note_data['offset']
+                print(f"     - Measure {note_data['measure']}: {note_data['pitch']} @ {offset_val:.4f} (dur: {duration_val:.6f})")
+            if len(removed_notes) > 5:
+                print(f"     ... and {len(removed_notes) - 5} more")
 
         return score
 

backend/scripts/diagnose_makemeasures.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+Diagnostic script to analyze what music21's makeMeasures() does to notes.
+
+Purpose: Understand how makeMeasures() transforms note durations and timing.
+
+Usage:
+    python diagnose_makemeasures.py <midi_file> [--time-sig 4/4]
+"""
+
+import argparse
+from pathlib import Path
+from typing import List, Dict, Any
+from music21 import converter, note, chord, meter
+
+
+def extract_note_data(element) -> List[Dict[str, Any]]:
+    """Extract note data from a note or chord element."""
+    notes = []
+
+    if isinstance(element, note.Note):
+        notes.append({
+            'pitch': element.pitch.midi,
+            'pitch_name': element.pitch.nameWithOctave,
+            'offset': float(element.offset),
+            'duration': float(element.quarterLength),
+            'type': 'note'
+        })
+    elif isinstance(element, chord.Chord):
+        for pitch in element.pitches:
+            notes.append({
+                'pitch': pitch.midi,
+                'pitch_name': pitch.nameWithOctave,
+                'offset': float(element.offset),
+                'duration': float(element.quarterLength),
+                'type': 'chord'
+            })
+    elif isinstance(element, note.Rest):
+        notes.append({
+            'pitch': None,
+            'pitch_name': 'Rest',
+            'offset': float(element.offset),
+            'duration': float(element.quarterLength),
+            'type': 'rest'
+        })
+
+    return notes
+
+
+def dump_score_notes(score, label: str) -> List[Dict[str, Any]]:
+    """Dump all notes from score with optional label."""
+    notes_list = []
+
+    for element in score.flatten().notesAndRests:
+        notes_list.extend(extract_note_data(element))
+
+    return sorted(notes_list, key=lambda x: (x['offset'], x['pitch'] if x['pitch'] is not None else -1))
+
+
+def analyze_makemeasures_changes(before_notes: List[Dict[str, Any]],
+                                 after_notes: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Analyze what changed between before and after makeMeasures().
+
+    Returns:
+    - note_count_change: Difference in note count
+    - duration_changes: Notes whose durations changed
+    - timing_changes: Notes whose offsets changed
+    - new_rests: Rests that were inserted
+    - split_notes: Notes that were split into multiple notes
+    """
+    report = {
+        'before_count': len(before_notes),
+        'after_count': len(after_notes),
+        'note_count_change': len(after_notes) - len(before_notes),
+        'duration_changes': [],
+        'timing_changes': [],
+        'new_rests': [],
+        'split_notes': [],
+        'impossible_durations': []
+    }
+
+    # Count rests
+    before_rests = [n for n in before_notes if n['type'] == 'rest']
+    after_rests = [n for n in after_notes if n['type'] == 'rest']
+
+    report['new_rests'] = [r for r in after_rests if r not in before_rests]
+
+    # Find impossible durations (< 64th note = 0.0625 quarter notes)
+    MIN_DURATION = 0.0625
+    for note_data in after_notes:
+        if note_data['duration'] < MIN_DURATION:
+            report['impossible_durations'].append({
+                'note': note_data['pitch_name'],
+                'offset': note_data['offset'],
+                'duration': note_data['duration'],
+                'type': note_data['type']
+            })
+
+    # Try to match before/after notes
+    after_matched = [False] * len(after_notes)
+
+    for before_note in before_notes:
+        if before_note['type'] == 'rest':
+            continue  # Skip rests for now
+
+        # Find matching note(s) in after_notes
+        matches = []
+        for i, after_note in enumerate(after_notes):
+            if after_matched[i]:
+                continue
+            if after_note['pitch'] == before_note['pitch']:
+                # Check if timing is close (within 0.1 quarter notes)
+                timing_diff = abs(after_note['offset'] - before_note['offset'])
+                if timing_diff < 0.1:
+                    matches.append((i, after_note, timing_diff))
+
+        if len(matches) == 0:
+            # Note disappeared?
+            report['duration_changes'].append({
+                'before': before_note,
+                'after': None,
+                'change': 'disappeared'
+            })
+        elif len(matches) == 1:
+            # One-to-one match
+            idx, after_note, _ = matches[0]
+            after_matched[idx] = True
+
+            # Check for duration change
+            duration_diff = abs(after_note['duration'] - before_note['duration'])
+            if duration_diff > 0.001:
+                report['duration_changes'].append({
+                    'note': before_note['pitch_name'],
+                    'before_duration': before_note['duration'],
+                    'after_duration': after_note['duration'],
+                    'difference': after_note['duration'] - before_note['duration'],
+                    'offset': before_note['offset']
+                })
+
+            # Check for timing change
+            timing_diff = abs(after_note['offset'] - before_note['offset'])
+            if timing_diff > 0.001:
+                report['timing_changes'].append({
+                    'note': before_note['pitch_name'],
+                    'before_offset': before_note['offset'],
+                    'after_offset': after_note['offset'],
+                    'difference': after_note['offset'] - before_note['offset']
+                })
+        else:
+            # Multiple matches - note was split
+            for idx, after_note, _ in matches:
+                after_matched[idx] = True
+
+            total_after_duration = sum(m[1]['duration'] for m in matches)
+            report['split_notes'].append({
+                'note': before_note['pitch_name'],
+                'before_duration': before_note['duration'],
+                'after_count': len(matches),
+                'after_total_duration': total_after_duration,
+                'after_notes': [m[1] for m in matches]
+            })
+
+    return report
+
+
+def print_forensics_report(report: Dict[str, Any]):
+    """Print forensics report in human-readable format."""
+    print("\n" + "="*80)
+    print("music21 makeMeasures() FORENSICS REPORT")
+    print("="*80)
+
+    print(f"\n📊 NOTE COUNT:")
+    print(f"  Before makeMeasures(): {report['before_count']}")
+    print(f"  After makeMeasures():  {report['after_count']}")
+    print(f"  Change:                {report['note_count_change']:+d}")
+
+    if report['new_rests']:
+        print(f"\n🎵 NEW RESTS INSERTED: {len(report['new_rests'])}")
+        for i, rest in enumerate(report['new_rests'][:10]):
+            print(f"  {i+1}. Rest at offset {rest['offset']:.4f}, duration {rest['duration']:.4f}")
+
+    if report['impossible_durations']:
+        print(f"\n⚠️  IMPOSSIBLE DURATIONS CREATED: {len(report['impossible_durations'])}")
+        print(f"   (notes shorter than 64th note = 0.0625 quarter notes)")
+        for i, note_data in enumerate(report['impossible_durations'][:10]):
+            print(f"  {i+1}. {note_data['note']} at {note_data['offset']:.4f}, duration {note_data['duration']:.6f}")
+
+    if report['duration_changes']:
+        print(f"\n⏱️  DURATION CHANGES: {len(report['duration_changes'])}")
+        for i, change in enumerate(report['duration_changes'][:10]):
+            if change.get('change') == 'disappeared':
+                print(f"  {i+1}. {change['before']['pitch_name']} DISAPPEARED")
+                print(f"      Before: offset {change['before']['offset']:.4f}, duration {change['before']['duration']:.4f}")
+            else:
+                print(f"  {i+1}. {change['note']} at offset {change['offset']:.4f}")
+                print(f"      Before: {change['before_duration']:.4f}  →  After: {change['after_duration']:.4f}")
+                print(f"      Difference: {change['difference']:+.4f}")
+
+    if report['timing_changes']:
+        print(f"\n📍 TIMING CHANGES: {len(report['timing_changes'])}")
+        for i, change in enumerate(report['timing_changes'][:10]):
+            print(f"  {i+1}. {change['note']}")
+            print(f"      Before: {change['before_offset']:.4f}  →  After: {change['after_offset']:.4f}")
+            print(f"      Difference: {change['difference']:+.4f}")
+
+    if report['split_notes']:
+        print(f"\n✂️  NOTES SPLIT: {len(report['split_notes'])}")
+        for i, split in enumerate(report['split_notes'][:5]):
+            print(f"  {i+1}. {split['note']} (duration {split['before_duration']:.4f}) split into {split['after_count']} notes:")
+            for j, after_note in enumerate(split['after_notes']):
+                print(f"      {j+1}. Offset {after_note['offset']:.4f}, duration {after_note['duration']:.4f}")
+
+    print("\n" + "="*80)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Analyze what music21.makeMeasures() does to notes'
+    )
+    parser.add_argument('midi_file', type=Path, help='Path to MIDI file')
+    parser.add_argument('--time-sig', '-t', type=str, default='4/4',
+                       help='Time signature to use (default: 4/4)')
+
+    args = parser.parse_args()
+
+    if not args.midi_file.exists():
+        print(f"ERROR: MIDI file not found: {args.midi_file}")
+        return 1
+
+    print(f"🔬 Analyzing makeMeasures() behavior...")
+    print(f"   MIDI file: {args.midi_file}")
+    print(f"   Time signature: {args.time_sig}")
+
+    # Parse MIDI
+    print(f"\n📝 Loading MIDI file...")
+    score = converter.parse(args.midi_file)
+
+    # Dump notes BEFORE makeMeasures
+    print(f"📝 Extracting notes BEFORE makeMeasures()...")
+    before_notes = dump_score_notes(score, "BEFORE")
+
+    # Apply makeMeasures
+    print(f"🔧 Calling makeMeasures()...")
+    time_sig_parts = args.time_sig.split('/')
+    time_sig = meter.TimeSignature(args.time_sig)
+
+    score_with_measures = score.makeMeasures()
+
+    # Dump notes AFTER makeMeasures
+    print(f"📝 Extracting notes AFTER makeMeasures()...")
+    after_notes = dump_score_notes(score_with_measures, "AFTER")
+
+    # Analyze changes
+    print(f"🔬 Analyzing changes...")
+    report = analyze_makemeasures_changes(before_notes, after_notes)
+
+    # Print report
+    print_forensics_report(report)
+
+    return 0
+
+
+if __name__ == '__main__':
+    exit(main())

backend/scripts/diagnose_musicxml.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""
+Diagnostic script to compare MIDI with generated MusicXML.
+
+Purpose: Identify where note data is lost or corrupted during MIDI → MusicXML conversion.
+
+Usage:
+    python diagnose_musicxml.py <midi_file> <musicxml_file> [--output report.json]
+"""
+
+import argparse
+import json
+from pathlib import Path
+from typing import List, Dict, Any, Tuple
+from music21 import converter, note, chord
+
+
+def extract_notes_from_midi(midi_path: Path) -> List[Dict[str, Any]]:
+    """
+    Extract all notes from MIDI file.
+
+    Returns list of note dictionaries with:
+    - pitch: MIDI note number (0-127)
+    - start: Start time in quarter notes
+    - duration: Duration in quarter notes
+    - velocity: MIDI velocity (0-127)
+    """
+    score = converter.parse(midi_path)
+    notes_list = []
+
+    for element in score.flatten().notesAndRests:
+        if isinstance(element, note.Note):
+            notes_list.append({
+                'pitch': element.pitch.midi,
+                'pitch_name': element.pitch.nameWithOctave,
+                'start': float(element.offset),
+                'duration': float(element.quarterLength),
+                'velocity': element.volume.velocity if element.volume.velocity else 64,
+                'is_rest': False
+            })
+        elif isinstance(element, chord.Chord):
+            # Expand chords into individual notes
+            for pitch in element.pitches:
+                notes_list.append({
+                    'pitch': pitch.midi,
+                    'pitch_name': pitch.nameWithOctave,
+                    'start': float(element.offset),
+                    'duration': float(element.quarterLength),
+                    'velocity': element.volume.velocity if element.volume.velocity else 64,
+                    'is_rest': False
+                })
+        elif isinstance(element, note.Rest):
+            notes_list.append({
+                'pitch': None,
+                'pitch_name': 'Rest',
+                'start': float(element.offset),
+                'duration': float(element.quarterLength),
+                'velocity': 0,
+                'is_rest': True
+            })
+
+    return sorted(notes_list, key=lambda x: (x['start'], x['pitch'] if x['pitch'] is not None else -1))
+
+
+def extract_notes_from_musicxml(musicxml_path: Path) -> List[Dict[str, Any]]:
+    """
+    Extract all notes from MusicXML file.
+
+    Returns same format as extract_notes_from_midi().
+    """
+    score = converter.parse(musicxml_path)
+    notes_list = []
+
+    for element in score.flatten().notesAndRests:
+        if isinstance(element, note.Note):
+            notes_list.append({
+                'pitch': element.pitch.midi,
+                'pitch_name': element.pitch.nameWithOctave,
+                'start': float(element.offset),
+                'duration': float(element.quarterLength),
+                'velocity': element.volume.velocity if element.volume.velocity else 64,
+                'is_rest': False
+            })
+        elif isinstance(element, chord.Chord):
+            # Expand chords into individual notes
+            for pitch in element.pitches:
+                notes_list.append({
+                    'pitch': pitch.midi,
+                    'pitch_name': pitch.nameWithOctave,
+                    'start': float(element.offset),
+                    'duration': float(element.quarterLength),
+                    'velocity': element.volume.velocity if element.volume.velocity else 64,
+                    'is_rest': False
+                })
+        elif isinstance(element, note.Rest):
+            notes_list.append({
+                'pitch': None,
+                'pitch_name': 'Rest',
+                'start': float(element.offset),
+                'duration': float(element.quarterLength),
+                'velocity': 0,
+                'is_rest': True
+            })
+
+    return sorted(notes_list, key=lambda x: (x['start'], x['pitch'] if x['pitch'] is not None else -1))
+
+
+def find_note_match(target_note: Dict[str, Any], candidates: List[Dict[str, Any]],
+                   tolerance: float = 0.05) -> Tuple[int, float]:
+    """
+    Find best matching note in candidates list.
+
+    Returns: (index, match_score) where match_score = 0.0 (perfect) to 1.0 (no match)
+    """
+    best_idx = -1
+    best_score = float('inf')
+
+    for idx, candidate in enumerate(candidates):
+        # Skip if rest/note mismatch
+        if target_note['is_rest'] != candidate['is_rest']:
+            continue
+
+        # For rests, only check timing
+        if target_note['is_rest']:
+            timing_diff = abs(target_note['start'] - candidate['start'])
+            duration_diff = abs(target_note['duration'] - candidate['duration'])
+            score = timing_diff + duration_diff
+        else:
+            # For notes, check pitch + timing + duration
+            if target_note['pitch'] != candidate['pitch']:
+                continue  # Pitch must match exactly
+
+            timing_diff = abs(target_note['start'] - candidate['start'])
+            duration_diff = abs(target_note['duration'] - candidate['duration'])
+            score = timing_diff + duration_diff
+
+        if score < best_score:
+            best_score = score
+            best_idx = idx
+
+    return best_idx, best_score
+
+
+def compare_note_lists(midi_notes: List[Dict[str, Any]],
+                      xml_notes: List[Dict[str, Any]],
+                      tolerance: float = 0.05) -> Dict[str, Any]:
+    """
+    Compare MIDI notes with MusicXML notes.
+
+    Returns diagnostic report with:
+    - total_midi_notes
+    - total_musicxml_notes
+    - missing_notes (in MIDI but not MusicXML)
+    - extra_notes (in MusicXML but not MIDI)
+    - duration_mismatches
+    - timing_mismatches
+    """
+    report = {
+        'total_midi_notes': len(midi_notes),
+        'total_musicxml_notes': len(xml_notes),
+        'missing_notes': [],
+        'extra_notes': [],
+        'duration_mismatches': [],
+        'timing_mismatches': [],
+        'perfect_matches': 0,
+        'tolerance': tolerance
+    }
+
+    # Track which XML notes have been matched
+    xml_matched = [False] * len(xml_notes)
+
+    # For each MIDI note, find matching XML note
+    for midi_note in midi_notes:
+        # Only search unmatched XML notes
+        unmatched_xml = [xml_notes[i] for i, matched in enumerate(xml_matched) if not matched]
+        unmatched_indices = [i for i, matched in enumerate(xml_matched) if not matched]
+
+        if not unmatched_xml:
+            report['missing_notes'].append(midi_note)
+            continue
+
+        rel_idx, match_score = find_note_match(midi_note, unmatched_xml, tolerance)
+
+        if rel_idx == -1 or match_score > tolerance * 2:
+            # No good match found
+            report['missing_notes'].append(midi_note)
+        else:
+            # Found a match
+            actual_idx = unmatched_indices[rel_idx]
+            xml_matched[actual_idx] = True
+            xml_note = xml_notes[actual_idx]
+
+            if match_score < 0.001:
+                report['perfect_matches'] += 1
+            else:
+                # Check what's different
+                if not midi_note['is_rest']:
+                    duration_diff = abs(midi_note['duration'] - xml_note['duration'])
+                    if duration_diff > tolerance:
+                        report['duration_mismatches'].append({
+                            'note': midi_note['pitch_name'],
+                            'midi_duration': midi_note['duration'],
+                            'xml_duration': xml_note['duration'],
+                            'difference': duration_diff,
+                            'midi_start': midi_note['start'],
+                            'xml_start': xml_note['start']
+                        })
+
+                    timing_diff = abs(midi_note['start'] - xml_note['start'])
+                    if timing_diff > tolerance:
+                        report['timing_mismatches'].append({
+                            'note': midi_note['pitch_name'],
+                            'midi_start': midi_note['start'],
+                            'xml_start': xml_note['start'],
+                            'difference': timing_diff
+                        })
+
+    # Any unmatched XML notes are "extra"
+    for idx, matched in enumerate(xml_matched):
+        if not matched:
+            report['extra_notes'].append(xml_notes[idx])
+
+    return report
+
+
+def print_report(report: Dict[str, Any]):
+    """Print diagnostic report in human-readable format."""
+    print("\n" + "="*80)
+    print("MIDI → MusicXML DIAGNOSTIC REPORT")
+    print("="*80)
+
+    print(f"\n📊 SUMMARY:")
+    print(f"  Total MIDI notes:     {report['total_midi_notes']}")
+    print(f"  Total MusicXML notes: {report['total_musicxml_notes']}")
+    print(f"  Perfect matches:      {report['perfect_matches']}")
+    print(f"  Missing notes:        {len(report['missing_notes'])} (in MIDI but not MusicXML)")
+    print(f"  Extra notes:          {len(report['extra_notes'])} (in MusicXML but not MIDI)")
+    print(f"  Duration mismatches:  {len(report['duration_mismatches'])}")
+    print(f"  Timing mismatches:    {len(report['timing_mismatches'])}")
+
+    # Calculate accuracy
+    if report['total_midi_notes'] > 0:
+        accuracy = (report['perfect_matches'] / report['total_midi_notes']) * 100
+        print(f"\n  ✅ Match accuracy: {accuracy:.1f}%")
+
+    # Show missing notes
+    if report['missing_notes']:
+        print(f"\n❌ MISSING NOTES (first 10):")
+        for i, note in enumerate(report['missing_notes'][:10]):
+            if note['is_rest']:
+                print(f"  {i+1}. Rest at {note['start']:.2f}, duration {note['duration']:.4f}")
+            else:
+                print(f"  {i+1}. {note['pitch_name']} (MIDI {note['pitch']}) at {note['start']:.2f}, duration {note['duration']:.4f}")
+
+    # Show extra notes
+    if report['extra_notes']:
+        print(f"\n➕ EXTRA NOTES (first 10):")
+        for i, note in enumerate(report['extra_notes'][:10]):
+            if note['is_rest']:
+                print(f"  {i+1}. Rest at {note['start']:.2f}, duration {note['duration']:.4f}")
+            else:
+                print(f"  {i+1}. {note['pitch_name']} (MIDI {note['pitch']}) at {note['start']:.2f}, duration {note['duration']:.4f}")
+
+    # Show duration mismatches
+    if report['duration_mismatches']:
+        print(f"\n⏱️  DURATION MISMATCHES (first 10):")
+        for i, mismatch in enumerate(report['duration_mismatches'][:10]):
+            print(f"  {i+1}. {mismatch['note']} at {mismatch['midi_start']:.2f}:")
+            print(f"      MIDI: {mismatch['midi_duration']:.4f}  →  MusicXML: {mismatch['xml_duration']:.4f}")
+            print(f"      Difference: {mismatch['difference']:.4f} quarter notes")
+
+    # Show timing mismatches
+    if report['timing_mismatches']:
+        print(f"\n📍 TIMING MISMATCHES (first 10):")
+        for i, mismatch in enumerate(report['timing_mismatches'][:10]):
+            print(f"  {i+1}. {mismatch['note']}:")
+            print(f"      MIDI: {mismatch['midi_start']:.4f}  →  MusicXML: {mismatch['xml_start']:.4f}")
+            print(f"      Difference: {mismatch['difference']:.4f} quarter notes")
+
+    print("\n" + "="*80)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Compare MIDI with MusicXML to diagnose conversion issues'
+    )
+    parser.add_argument('midi_file', type=Path, help='Path to MIDI file')
+    parser.add_argument('musicxml_file', type=Path, help='Path to MusicXML file')
+    parser.add_argument('--output', '-o', type=Path, help='Output JSON report file')
+    parser.add_argument('--tolerance', '-t', type=float, default=0.05,
+                       help='Timing/duration tolerance in quarter notes (default: 0.05)')
+
+    args = parser.parse_args()
+
+    # Validate input files
+    if not args.midi_file.exists():
+        print(f"ERROR: MIDI file not found: {args.midi_file}")
+        return 1
+
+    if not args.musicxml_file.exists():
+        print(f"ERROR: MusicXML file not found: {args.musicxml_file}")
+        return 1
+
+    print(f"🔍 Analyzing MIDI → MusicXML conversion...")
+    print(f"   MIDI: {args.midi_file}")
+    print(f"   MusicXML: {args.musicxml_file}")
+    print(f"   Tolerance: {args.tolerance} quarter notes")
+
+    # Extract notes
+    print("\n📝 Extracting notes from MIDI...")
+    midi_notes = extract_notes_from_midi(args.midi_file)
+
+    print(f"📝 Extracting notes from MusicXML...")
+    xml_notes = extract_notes_from_musicxml(args.musicxml_file)
+
+    # Compare
+    print(f"🔬 Comparing notes...")
+    report = compare_note_lists(midi_notes, xml_notes, args.tolerance)
+
+    # Print report
+    print_report(report)
+
+    # Save JSON if requested
+    if args.output:
+        with open(args.output, 'w') as f:
+            json.dump(report, f, indent=2)
+        print(f"\n💾 Full report saved to: {args.output}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    exit(main())

backend/tasks.py

@@ -99,10 +99,25 @@ def process_transcription_task(self, job_id: str):
         # Copy the MusicXML file to outputs
         shutil.copy(str(temp_output_path), str(output_path))
 
-        # Copy the cleaned MIDI file to outputs
-        temp_midi_path = pipeline.temp_dir / "piano_clean.mid"
+        # Copy the MIDI file to outputs (YourMT3+ or basic-pitch)
+        # transcribe_to_midi() renames all MIDI files to piano.mid for consistency
+        temp_midi_path = pipeline.temp_dir / "piano.mid"
+        print(f"[DEBUG] Checking for MIDI at: {temp_midi_path}")
+        print(f"[DEBUG] MIDI exists: {temp_midi_path.exists()}")
+
         if temp_midi_path.exists():
+            print(f"[DEBUG] Copying MIDI from {temp_midi_path} to {midi_path}")
             shutil.copy(str(temp_midi_path), str(midi_path))
+            print(f"[DEBUG] Copy complete, destination exists: {midi_path.exists()}")
+        else:
+            print(f"[DEBUG] WARNING: No MIDI file found at either location!")
+
+        # Store metadata for API access
+        metadata = getattr(pipeline, 'metadata', {
+            "tempo": 120.0,
+            "time_signature": {"numerator": 4, "denominator": 4},
+            "key_signature": "C",
+        })
 
         # Cleanup temp files (pipeline has its own cleanup method)
         pipeline.cleanup()
@@ -113,6 +128,7 @@ def process_transcription_task(self, job_id: str):
             "progress": 100,
             "output_path": str(output_path.absolute()),
             "midi_path": str(midi_path.absolute()) if temp_midi_path.exists() else "",
+            "metadata": json.dumps(metadata),
             "completed_at": datetime.utcnow().isoformat(),
         })
 
@@ -128,12 +144,25 @@ def process_transcription_task(self, job_id: str):
         return str(output_path)
 
     except Exception as e:
+        import traceback
+
+        # Determine if error is retryable (only retry transient errors, not code bugs)
+        RETRYABLE_EXCEPTIONS = (
+            ConnectionError,  # Network errors
+            TimeoutError,     # Timeout errors
+            IOError,          # I/O errors (file system, disk full, etc.)
+        )
+
+        is_retryable = isinstance(e, RETRYABLE_EXCEPTIONS) and self.request.retries < self.max_retries
+
         # Mark job as failed
         redis_client.hset(f"job:{job_id}", mapping={
             "status": "failed",
             "error": json.dumps({
                 "message": str(e),
-                "retryable": self.request.retries < self.max_retries,
+                "type": type(e).__name__,
+                "retryable": is_retryable,
+                "traceback": traceback.format_exc(),
             }),
             "failed_at": datetime.utcnow().isoformat(),
         })
@@ -144,16 +173,20 @@ def process_transcription_task(self, job_id: str):
             "job_id": job_id,
             "error": {
                 "message": str(e),
-                "retryable": self.request.retries < self.max_retries,
+                "type": type(e).__name__,
+                "retryable": is_retryable,
             },
             "timestamp": datetime.utcnow().isoformat(),
         }
         redis_client.publish(f"job:{job_id}:updates", json.dumps(error_msg))
 
-        # Retry if retryable
-        if self.request.retries < self.max_retries:
+        # Only retry if the error is transient (network, I/O, etc.)
+        if is_retryable:
+            print(f"[RETRY] Retrying job {job_id} (attempt {self.request.retries + 1}/{self.max_retries})")
             raise self.retry(exc=e, countdown=2 ** self.request.retries)
         else:
+            # Non-retryable error (code bug, validation error, etc.) - fail immediately
+            print(f"[ERROR] Non-retryable error for job {job_id}: {type(e).__name__}: {e}")
             raise
 
 

frontend/package-lock.json

@@ -8,6 +8,7 @@
       "name": "frontend",
       "version": "0.0.0",
       "dependencies": {
+        "@tonejs/midi": "^2.0.28",
         "@xmldom/xmldom": "^0.8.11",
         "react": "^19.2.0",
         "react-dom": "^19.2.0",
@@ -18,7 +19,7 @@
       "devDependencies": {
         "@eslint/js": "^9.39.1",
         "@testing-library/jest-dom": "^6.1.5",
-        "@testing-library/react": "^14.1.2",
+        "@testing-library/react": "^15.0.0",
         "@testing-library/user-event": "^14.5.1",
         "@types/node": "^24.10.1",
         "@types/react": "^19.2.5",
@@ -1596,33 +1597,33 @@
       "license": "MIT"
     },
     "node_modules/@testing-library/dom": {
-      "version": "9.3.4",
-      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-9.3.4.tgz",
-      "integrity": "sha512-FlS4ZWlp97iiNWig0Muq8p+3rVDjRiYE+YKGbAqXOu9nwJFFOdL00kFpz42M+4huzYi86vAK1sOOfyOG45muIQ==",
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/code-frame": "^7.10.4",
         "@babel/runtime": "^7.12.5",
         "@types/aria-query": "^5.0.1",
-        "aria-query": "5.1.3",
-        "chalk": "^4.1.0",
+        "aria-query": "5.3.0",
         "dom-accessibility-api": "^0.5.9",
         "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
         "pretty-format": "^27.0.2"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=18"
       }
     },
     "node_modules/@testing-library/dom/node_modules/aria-query": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz",
-      "integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "deep-equal": "^2.0.5"
+        "dequal": "^2.0.3"
       }
     },
     "node_modules/@testing-library/dom/node_modules/dom-accessibility-api": {
@@ -1653,22 +1654,28 @@
       }
     },
     "node_modules/@testing-library/react": {
-      "version": "14.3.1",
-      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-14.3.1.tgz",
-      "integrity": "sha512-H99XjUhWQw0lTgyMN05W3xQG1Nh4lq574D8keFf1dDoNTJgp66VbJozRaczoF+wsiaPJNt/TcnfpLGufGxSrZQ==",
+      "version": "15.0.7",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-15.0.7.tgz",
+      "integrity": "sha512-cg0RvEdD1TIhhkm1IeYMQxrzy0MtUNfa3minv4MjbgcYzJAZ7yD0i0lwoPOTPr+INtiXFezt2o8xMSnyHhEn2Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@babel/runtime": "^7.12.5",
-        "@testing-library/dom": "^9.0.0",
+        "@testing-library/dom": "^10.0.0",
         "@types/react-dom": "^18.0.0"
       },
       "engines": {
-        "node": ">=14"
+        "node": ">=18"
       },
       "peerDependencies": {
+        "@types/react": "^18.0.0",
         "react": "^18.0.0",
         "react-dom": "^18.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
       }
     },
     "node_modules/@testing-library/react/node_modules/@types/react-dom": {
@@ -1695,6 +1702,16 @@
         "@testing-library/dom": ">=7.21.4"
       }
     },
+    "node_modules/@tonejs/midi": {
+      "version": "2.0.28",
+      "resolved": "https://registry.npmjs.org/@tonejs/midi/-/midi-2.0.28.tgz",
+      "integrity": "sha512-RII6YpInPsOZ5t3Si/20QKpNqB1lZ2OCFJSOzJxz38YdY/3zqDr3uaml4JuCWkdixuPqP1/TBnXzhQ39csyoVg==",
+      "license": "MIT",
+      "dependencies": {
+        "array-flatten": "^3.0.0",
+        "midi-file": "^1.2.2"
+      }
+    },
     "node_modules/@types/aria-query": {
       "version": "5.0.4",
       "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
@@ -2419,22 +2436,11 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/array-buffer-byte-length": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz",
-      "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "is-array-buffer": "^3.0.5"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+    "node_modules/array-flatten": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-3.0.0.tgz",
+      "integrity": "sha512-zPMVc3ZYlGLNk4mpK1NzP2wg0ml9t7fUgDsayR5Y5rSzxQilzR9FGu/EH2jQOcKSAeAfWeylyW8juy3OkWRvNA==",
+      "license": "MIT"
     },
     "node_modules/assertion-error": {
       "version": "1.1.0",
@@ -2466,22 +2472,6 @@
         "node": ">=18.2.0"
       }
     },
-    "node_modules/available-typed-arrays": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",
-      "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "possible-typed-array-names": "^1.0.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
@@ -2577,25 +2567,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/call-bind": {
-      "version": "1.0.8",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
-      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.0",
-        "es-define-property": "^1.0.0",
-        "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/call-bind-apply-helpers": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
@@ -2610,23 +2581,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/call-bound": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
-      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind-apply-helpers": "^1.0.2",
-        "get-intrinsic": "^1.3.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -2877,39 +2831,6 @@
         "node": ">=6"
       }
     },
-    "node_modules/deep-equal": {
-      "version": "2.2.3",
-      "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.3.tgz",
-      "integrity": "sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "array-buffer-byte-length": "^1.0.0",
-        "call-bind": "^1.0.5",
-        "es-get-iterator": "^1.1.3",
-        "get-intrinsic": "^1.2.2",
-        "is-arguments": "^1.1.1",
-        "is-array-buffer": "^3.0.2",
-        "is-date-object": "^1.0.5",
-        "is-regex": "^1.1.4",
-        "is-shared-array-buffer": "^1.0.2",
-        "isarray": "^2.0.5",
-        "object-is": "^1.1.5",
-        "object-keys": "^1.1.1",
-        "object.assign": "^4.1.4",
-        "regexp.prototype.flags": "^1.5.1",
-        "side-channel": "^1.0.4",
-        "which-boxed-primitive": "^1.0.2",
-        "which-collection": "^1.0.1",
-        "which-typed-array": "^1.1.13"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -2917,42 +2838,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/define-data-property": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
-      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "gopd": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/define-properties": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
-      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.0.1",
-        "has-property-descriptors": "^1.0.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/delayed-stream": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
@@ -2963,6 +2848,16 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/diff-sequences": {
       "version": "29.6.3",
       "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",
@@ -3035,27 +2930,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/es-get-iterator": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz",
-      "integrity": "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.2",
-        "get-intrinsic": "^1.1.3",
-        "has-symbols": "^1.0.3",
-        "is-arguments": "^1.1.1",
-        "is-map": "^2.0.2",
-        "is-set": "^2.0.2",
-        "is-string": "^1.0.7",
-        "isarray": "^2.0.5",
-        "stop-iteration-iterator": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/es-object-atoms": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
@@ -3518,22 +3392,6 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/for-each": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz",
-      "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-callable": "^1.2.7"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/form-data": {
       "version": "4.0.5",
       "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
@@ -3583,16 +3441,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/functions-have-names": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz",
-      "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==",
-      "dev": true,
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/gensync": {
       "version": "1.0.0-beta.2",
       "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
@@ -3726,19 +3574,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-bigints": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
-      "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -3749,19 +3584,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/has-property-descriptors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
-      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-define-property": "^1.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/has-symbols": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
@@ -3958,322 +3780,59 @@
       "dev": true,
       "license": "ISC"
     },
-    "node_modules/internal-slot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
-      "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "hasown": "^2.0.2",
-        "side-channel": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/is-arguments": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz",
-      "integrity": "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-array-buffer": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz",
-      "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-bigint": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz",
-      "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "has-bigints": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-boolean-object": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz",
-      "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-callable": {
-      "version": "1.2.7",
-      "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz",
-      "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-date-object": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz",
-      "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-extglob": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-glob": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
-      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-extglob": "^2.1.1"
-      },
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/is-map": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz",
-      "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
-    "node_modules/is-number-object": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz",
-      "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-potential-custom-element-name": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
-      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/is-regex": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
-      "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2",
-        "hasown": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-set": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz",
-      "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-shared-array-buffer": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz",
-      "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/is-stream": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
-      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-string": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz",
-      "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==",
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "call-bound": "^1.0.3",
-        "has-tostringtag": "^1.0.2"
+        "is-extglob": "^2.1.1"
       },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=0.10.0"
       }
     },
-    "node_modules/is-symbol": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz",
-      "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==",
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "has-symbols": "^1.1.0",
-        "safe-regex-test": "^1.1.0"
-      },
       "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "node": ">=0.12.0"
       }
     },
-    "node_modules/is-weakmap": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
-      "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==",
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
       "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
+      "license": "MIT"
     },
-    "node_modules/is-weakset": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz",
-      "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==",
+    "node_modules/is-stream": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
+      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
       "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.3",
-        "get-intrinsic": "^1.2.6"
-      },
       "engines": {
-        "node": ">= 0.4"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/ljharb"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/isarray": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
-      "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -4649,6 +4208,12 @@
         "url": "https://github.com/sponsors/jonschlinkert"
       }
     },
+    "node_modules/midi-file": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/midi-file/-/midi-file-1.2.4.tgz",
+      "integrity": "sha512-B5SnBC6i2bwJIXTY9MElIydJwAmnKx+r5eJ1jknTLetzLflEl0GWveuBB6ACrQpecSRkOB6fhTx1PwXk2BVxnA==",
+      "license": "MIT"
+    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -4807,67 +4372,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/object-inspect": {
-      "version": "1.13.4",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
-      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-is": {
-      "version": "1.1.6",
-      "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz",
-      "integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.7",
-        "define-properties": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/object-keys": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
-      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/object.assign": {
-      "version": "4.1.7",
-      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz",
-      "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.3",
-        "define-properties": "^1.2.1",
-        "es-object-atoms": "^1.0.0",
-        "has-symbols": "^1.1.0",
-        "object-keys": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
@@ -5056,16 +4560,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/possible-typed-array-names": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
-      "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/postcss": {
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
@@ -5236,27 +4730,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/regexp.prototype.flags": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz",
-      "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bind": "^1.0.8",
-        "define-properties": "^1.2.1",
-        "es-errors": "^1.3.0",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "set-function-name": "^2.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/require-from-string": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
@@ -5368,24 +4841,6 @@
         "queue-microtask": "^1.2.2"
       }
     },
-    "node_modules/safe-regex-test": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz",
-      "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "is-regex": "^1.2.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
@@ -5422,40 +4877,6 @@
         "semver": "bin/semver.js"
       }
     },
-    "node_modules/set-function-length": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
-      "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
-        "get-intrinsic": "^1.2.4",
-        "gopd": "^1.0.1",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/set-function-name": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz",
-      "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "define-data-property": "^1.1.4",
-        "es-errors": "^1.3.0",
-        "functions-have-names": "^1.2.3",
-        "has-property-descriptors": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -5479,82 +4900,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
-        "side-channel-map": "^1.0.1",
-        "side-channel-weakmap": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-list": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
-      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-map": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
-      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/side-channel-weakmap": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
-      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "call-bound": "^1.0.2",
-        "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.5",
-        "object-inspect": "^1.13.3",
-        "side-channel-map": "^1.0.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/siginfo": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
@@ -5625,20 +4970,6 @@
       "dev": true,
       "license": "MIT"
     },
-    "node_modules/stop-iteration-iterator": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
-      "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "es-errors": "^1.3.0",
-        "internal-slot": "^1.1.0"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
     "node_modules/strip-final-newline": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
@@ -7221,67 +6552,6 @@
         "node": ">= 8"
       }
     },
-    "node_modules/which-boxed-primitive": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz",
-      "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-bigint": "^1.1.0",
-        "is-boolean-object": "^1.2.1",
-        "is-number-object": "^1.1.1",
-        "is-string": "^1.1.1",
-        "is-symbol": "^1.1.1"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-collection": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz",
-      "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "is-map": "^2.0.3",
-        "is-set": "^2.0.3",
-        "is-weakmap": "^2.0.2",
-        "is-weakset": "^2.0.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
-    "node_modules/which-typed-array": {
-      "version": "1.1.19",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz",
-      "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.8",
-        "call-bound": "^1.0.4",
-        "for-each": "^0.3.5",
-        "get-proto": "^1.0.1",
-        "gopd": "^1.2.0",
-        "has-tostringtag": "^1.0.2"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/why-is-node-running": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",

frontend/package.json

@@ -13,6 +13,7 @@
     "test:coverage": "vitest --coverage"
   },
   "dependencies": {
+    "@tonejs/midi": "^2.0.28",
     "@xmldom/xmldom": "^0.8.11",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
@@ -29,6 +30,7 @@
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.1.1",
+    "@vitest/coverage-v8": "^1.1.0",
     "@vitest/ui": "^1.1.0",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",
@@ -38,7 +40,6 @@
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
     "vite": "^7.2.4",
-    "vitest": "^1.1.0",
-    "@vitest/coverage-v8": "^1.1.0"
+    "vitest": "^1.1.0"
   }
 }

frontend/src/api/client.ts

@@ -141,3 +141,29 @@ export async function getJobStatus(jobId: string) {
 export async function downloadScore(jobId: string) {
   return api.getScore(jobId);
 }
+
+export async function getMidiFile(jobId: string): Promise<ArrayBuffer> {
+  const response = await fetch(`${API_BASE_URL}/api/v1/scores/${jobId}/midi`);
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch MIDI file');
+  }
+
+  return response.arrayBuffer();
+}
+
+export interface ScoreMetadata {
+  tempo: number;
+  key_signature: string;
+  time_signature: { numerator: number; denominator: number };
+}
+
+export async function getMetadata(jobId: string): Promise<ScoreMetadata> {
+  const response = await fetch(`${API_BASE_URL}/api/v1/scores/${jobId}/metadata`);
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch metadata');
+  }
+
+  return response.json();
+}

frontend/src/components/NotationCanvas.tsx

@@ -10,7 +10,6 @@ import type { Note, Part } from '../store/notation';
 import './NotationCanvas.css';
 
 interface NotationCanvasProps {
-  musicXML: string;
   showControls?: boolean;
   interactive?: boolean;
   onNoteSelect?: (id: string) => void;
@@ -20,7 +19,7 @@ interface NotationCanvasProps {
   height?: number;
 }
 
-export function NotationCanvas({ musicXML, showControls, interactive, onNoteSelect, selectedNotes, showMeasureNumbers, width, height }: NotationCanvasProps) {
+export function NotationCanvas({ showControls, interactive, onNoteSelect, selectedNotes, showMeasureNumbers, width, height }: NotationCanvasProps) {
   const containerRef = useRef<HTMLDivElement>(null);
   const score = useNotationStore((state) => state.score);
   const playingNoteIds = useNotationStore((state) => state.playingNoteIds);
@@ -58,13 +57,6 @@ export function NotationCanvas({ musicXML, showControls, interactive, onNoteSele
       containerRef.current.appendChild(label);
     }
 
-    // Show simple error when XML is obviously invalid
-    if (musicXML && musicXML.includes('<invalid')) {
-      const err = document.createElement('div');
-      err.textContent = 'Invalid MusicXML';
-      containerRef.current.appendChild(err);
-    }
-
     if (!score || !score.parts.length) {
       return;
     }
@@ -93,7 +85,7 @@ export function NotationCanvas({ musicXML, showControls, interactive, onNoteSele
       // Single staff fallback
       renderSingleStaff(context, score.parts[0], measuresPerRow, staveWidth, staveHeight, score);
     }
-  }, [musicXML, score]);
+  }, [score]);
 
   // Highlight playing notes
   useEffect(() => {
@@ -132,6 +124,16 @@ export function NotationCanvas({ musicXML, showControls, interactive, onNoteSele
 
 export default NotationCanvas;
 
+/**
+ * Convert key signature from music21 format (e.g., "A major", "F# minor")
+ * to VexFlow format (e.g., "A", "F#")
+ */
+function convertKeySignature(key: string): string {
+  if (!key) return 'C';
+  // Remove " major" or " minor" suffix
+  return key.replace(/ major| minor/gi, '').trim();
+}
+
 /**
  * Render grand staff with treble and bass clefs connected by brace
  */
@@ -160,8 +162,9 @@ function renderGrandStaff(
     if (col === 0) {
       trebleStave.addClef('treble');
       trebleStave.addTimeSignature(score.timeSignature);
-      if (score.key && score.key !== 'C') {
-        trebleStave.addKeySignature(score.key);
+      const vexflowKey = convertKeySignature(score.key);
+      if (vexflowKey && vexflowKey !== 'C') {
+        trebleStave.addKeySignature(vexflowKey);
       }
     }
     trebleStave.setContext(context).draw();
@@ -171,8 +174,9 @@ function renderGrandStaff(
     if (col === 0) {
       bassStave.addClef('bass');
       bassStave.addTimeSignature(score.timeSignature);
-      if (score.key && score.key !== 'C') {
-        bassStave.addKeySignature(score.key);
+      const vexflowKey = convertKeySignature(score.key);
+      if (vexflowKey && vexflowKey !== 'C') {
+        bassStave.addKeySignature(vexflowKey);
       }
     }
     bassStave.setContext(context).draw();
@@ -222,8 +226,9 @@ function renderSingleStaff(
     if (idx === 0) {
       stave.addClef(part.clef);
       stave.addTimeSignature(score.timeSignature);
-      if (score.key && score.key !== 'C') {
-        stave.addKeySignature(score.key);
+      const vexflowKey = convertKeySignature(score.key);
+      if (vexflowKey && vexflowKey !== 'C') {
+        stave.addKeySignature(vexflowKey);
       }
     }
 
@@ -245,58 +250,54 @@ function renderMeasureNotes(
   timeSignature: string
 ): void {
   try {
-    // Group notes by startTime to identify chords (notes with same duration/timing)
-    // Since our parser now keeps chord notes sequential, we need to identify them
-    // by checking if consecutive notes have the same duration and are pitched
+    // Group notes by chordId (trust the parser's chord grouping from MusicXML <chord/> tags)
+    // This is more accurate than re-detecting chords by duration
+    const noteGroups: Record<string, Note[]> = notes.reduce((groups, note) => {
+      const groupId = note.chordId || `single-${note.id}`;
+      if (!groups[groupId]) groups[groupId] = [];
+      groups[groupId].push(note);
+      return groups;
+    }, {} as Record<string, Note[]>);
+
+    // Convert each group to VexFlow note
     const vexNotes: StaveNote[] = [];
-    let i = 0;
-
-    while (i < notes.length) {
-      const currentNote = notes[i];
-
-      if (currentNote.isRest) {
-        // Rests are always single
-        try {
-          vexNotes.push(convertToVexNote(currentNote));
-        } catch (err) {
-          // Skip invalid rest
-        }
-        i++;
-        continue;
-      }
-
-      // Look ahead to find all notes with same duration (potential chord)
-      const chordNotes: Note[] = [currentNote];
-      let j = i + 1;
-
-      // Collect consecutive notes with same duration as a chord
-      while (j < notes.length &&
-             !notes[j].isRest &&
-             notes[j].duration === currentNote.duration &&
-             notes[j].dotted === currentNote.dotted) {
-        chordNotes.push(notes[j]);
-        j++;
-
-        // Limit chord size to reasonable amount (max 10 notes)
-        if (chordNotes.length >= 10) break;
-      }
-
-      // Create VexFlow note (single or chord)
+    for (const group of Object.values(noteGroups)) {
       try {
-        if (chordNotes.length === 1) {
-          vexNotes.push(convertToVexNote(chordNotes[0]));
+        if (group[0].isRest) {
+          // Rests are always single
+          vexNotes.push(convertToVexNote(group[0]));
+        } else if (group.length === 1) {
+          // Single note
+          vexNotes.push(convertToVexNote(group[0]));
         } else {
-          vexNotes.push(convertToVexChord(chordNotes));
+          // Chord (multiple notes with same chordId)
+          vexNotes.push(convertToVexChord(group));
         }
       } catch (err) {
         // Skip invalid note/chord
+        console.warn('Failed to convert note/chord:', err);
       }
-
-      i = j;
     }
 
+    // Handle empty measures by rendering a whole rest
     if (vexNotes.length === 0) {
-      return; // No valid notes to render
+      const [beats, beatValue] = timeSignature.split('/').map(Number);
+      // Use whole rest for 4/4, half rest for 2/4, etc.
+      const restDuration = beats >= 4 ? 'w' : beats >= 2 ? 'h' : 'q';
+
+      const wholeRest = new StaveNote({
+        keys: ['b/4'],
+        duration: restDuration + 'r',
+      });
+
+      const voice = new Voice({ num_beats: beats, beat_value: beatValue });
+      voice.setMode(Voice.Mode.SOFT);
+      voice.addTickables([wholeRest]);
+
+      const formatter = new Formatter();
+      formatter.joinVoices([voice]).format([voice], stave.getWidth() - 20);
+      voice.draw(context, stave);
+      return;
     }
 
     // Create voice - use SOFT mode for now to handle incomplete measures gracefully

frontend/src/components/ScoreEditor.tsx

@@ -2,7 +2,7 @@
  * Main score editor component integrating notation, playback, and export.
  */
 import { useState, useEffect } from 'react';
-import { api } from '../api/client';
+import { getMidiFile, getMetadata } from '../api/client';
 import { useNotationStore } from '../store/notation';
 import { NotationCanvas } from './NotationCanvas';
 import { PlaybackControls } from './PlaybackControls';
@@ -13,9 +13,9 @@ interface ScoreEditorProps {
 }
 
 export function ScoreEditor({ jobId }: ScoreEditorProps) {
-  const [musicXML, setMusicXML] = useState('');
   const [loading, setLoading] = useState(true);
-  const loadFromMusicXML = useNotationStore((state) => state.loadFromMusicXML);
+  const [error, setError] = useState<string | null>(null);
+  const loadFromMidi = useNotationStore((state) => state.loadFromMidi);
 
   useEffect(() => {
     loadScore();
@@ -23,36 +23,66 @@ export function ScoreEditor({ jobId }: ScoreEditorProps) {
 
   const loadScore = async () => {
     try {
-      const xml = await api.getScore(jobId);
-      setMusicXML(xml);
-      loadFromMusicXML(xml);
+      setLoading(true);
+      setError(null);
+
+      // Fetch MIDI file and metadata in parallel
+      const [midiData, metadata] = await Promise.all([
+        getMidiFile(jobId),
+        getMetadata(jobId),
+      ]);
+
+      // Load MIDI into notation store
+      await loadFromMidi(midiData, {
+        tempo: metadata.tempo,
+        keySignature: metadata.key_signature,
+        timeSignature: metadata.time_signature,
+      });
+
       setLoading(false);
     } catch (err) {
       console.error('Failed to load score:', err);
+      setError(err instanceof Error ? err.message : 'Failed to load score');
       setLoading(false);
     }
   };
 
   const handleExportMusicXML = () => {
-    const blob = new Blob([musicXML], {
-      type: 'application/vnd.recordare.musicxml+xml',
-    });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = `score_${jobId}.musicxml`;
-    a.click();
-    URL.revokeObjectURL(url);
+    // TODO: Generate MusicXML from edited score state
+    alert('MusicXML export coming soon - will generate from your edited notation');
   };
 
-  const handleExportMIDI = () => {
-    alert('MIDI export not yet implemented');
+  const handleExportMIDI = async () => {
+    try {
+      // Download the original MIDI file
+      const midiData = await getMidiFile(jobId);
+      const blob = new Blob([midiData], { type: 'audio/midi' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `score_${jobId}.mid`;
+      a.click();
+      URL.revokeObjectURL(url);
+    } catch (err) {
+      console.error('Failed to export MIDI:', err);
+      alert('Failed to export MIDI file');
+    }
   };
 
   if (loading) {
     return <div className="score-editor loading">Loading score...</div>;
   }
 
+  if (error) {
+    return (
+      <div className="score-editor error">
+        <h2>Error Loading Score</h2>
+        <p>{error}</p>
+        <button onClick={loadScore}>Retry</button>
+      </div>
+    );
+  }
+
   return (
     <div className="score-editor">
       <div className="editor-toolbar">
@@ -65,7 +95,7 @@ export function ScoreEditor({ jobId }: ScoreEditorProps) {
 
       <PlaybackControls />
 
-      <NotationCanvas musicXML={musicXML} />
+      <NotationCanvas />
 
       <div className="editor-instructions">
         <h3>Editing Instructions (MVP)</h3>

frontend/src/store/notation.ts

@@ -3,6 +3,7 @@
  */
 import { create } from 'zustand';
 import { parseMusicXML } from '../utils/musicxml-parser';
+import { parseMidiFile, assignChordIds } from '../utils/midi-parser';
 
 export interface Note {
   id: string;
@@ -13,6 +14,7 @@ export interface Note {
   dotted: boolean;
   accidental?: 'sharp' | 'flat' | 'natural';
   isRest: boolean;
+  chordId?: string; // Group chord notes together (notes with same chordId are rendered as single VexFlow chord)
 }
 
 export interface Measure {
@@ -48,6 +50,14 @@ interface NotationState {
 
   // Actions
   loadFromMusicXML: (xml: string) => void;
+  loadFromMidi: (
+    midiData: ArrayBuffer,
+    metadata?: {
+      tempo?: number;
+      keySignature?: string;
+      timeSignature?: { numerator: number; denominator: number };
+    }
+  ) => Promise<void>;
   exportToMusicXML: () => string;
   addNote: (measureId: string, note: Note) => void;
   deleteNote: (noteId: string) => void;
@@ -88,6 +98,40 @@ export const useNotationStore = create<NotationState>((set, _get) => ({
     }
   },
 
+  loadFromMidi: async (midiData, metadata) => {
+    try {
+      let score = await parseMidiFile(midiData, {
+        tempo: metadata?.tempo,
+        timeSignature: metadata?.timeSignature,
+        keySignature: metadata?.keySignature,
+        splitAtMiddleC: true,
+        middleCNote: 60,
+      });
+
+      // Assign chord IDs to simultaneous notes
+      score = assignChordIds(score);
+
+      set({ score });
+    } catch (error) {
+      console.error('Failed to parse MIDI:', error);
+      // Fallback to empty score
+      set({
+        score: {
+          id: 'score-1',
+          title: 'Transcribed Score',
+          composer: 'YourMT3+',
+          key: metadata?.keySignature || 'C',
+          timeSignature: metadata?.timeSignature
+            ? `${metadata.timeSignature.numerator}/${metadata.timeSignature.denominator}`
+            : '4/4',
+          tempo: metadata?.tempo || 120,
+          parts: [],
+          measures: [],
+        },
+      });
+    }
+  },
+
   exportToMusicXML: () => {
     // TODO: Implement MusicXML generation
     return '<?xml version="1.0"?><score-partwise></score-partwise>';

frontend/src/utils/midi-parser.ts

@@ -0,0 +1,291 @@
+/**
+ * MIDI Parser - Converts MIDI files to internal Score format
+ *
+ * This bypasses MusicXML entirely to preserve YourMT3+ transcription accuracy.
+ */
+
+import { Midi } from '@tonejs/midi';
+import type { Score, Part, Measure, Note } from '../store/notation';
+
+export interface MidiParseOptions {
+  tempo?: number;
+  timeSignature?: { numerator: number; denominator: number };
+  keySignature?: string;
+  splitAtMiddleC?: boolean; // For grand staff (treble + bass)
+  middleCNote?: number; // MIDI note number for staff split (default: 60)
+}
+
+/**
+ * Parse MIDI file into Score format
+ */
+export async function parseMidiFile(
+  midiData: ArrayBuffer,
+  options: MidiParseOptions = {}
+): Promise<Score> {
+  const midi = new Midi(midiData);
+
+  // Extract metadata
+  const tempo = options.tempo || midi.header.tempos[0]?.bpm || 120;
+  const timeSignature = options.timeSignature || {
+    numerator: midi.header.timeSignatures[0]?.timeSignature[0] || 4,
+    denominator: midi.header.timeSignatures[0]?.timeSignature[1] || 4,
+  };
+  const keySignature = options.keySignature || 'C';
+
+  // Parse all tracks into single note list
+  const allNotes = extractNotesFromMidi(midi);
+
+  // Create measures from notes
+  const measureDuration = (timeSignature.numerator / timeSignature.denominator) * 4; // in quarter notes
+  const parts = createPartsFromNotes(
+    allNotes,
+    measureDuration,
+    options.splitAtMiddleC ?? true,
+    options.middleCNote ?? 60,
+    tempo
+  );
+
+  return {
+    id: 'score-1',
+    title: midi.name || 'Transcribed Score',
+    composer: 'YourMT3+',
+    key: keySignature,
+    timeSignature: `${timeSignature.numerator}/${timeSignature.denominator}`,
+    tempo,
+    parts,
+    measures: parts[0]?.measures || [], // Legacy compatibility
+  };
+}
+
+interface MidiNote {
+  midi: number;
+  time: number;
+  duration: number;
+  velocity: number;
+}
+
+/**
+ * Extract all notes from MIDI tracks
+ */
+function extractNotesFromMidi(midi: Midi): MidiNote[] {
+  const notes: MidiNote[] = [];
+
+  for (const track of midi.tracks) {
+    for (const note of track.notes) {
+      notes.push({
+        midi: note.midi,
+        time: note.time,
+        duration: note.duration,
+        velocity: note.velocity,
+      });
+    }
+  }
+
+  // Sort by time
+  notes.sort((a, b) => a.time - b.time);
+
+  return notes;
+}
+
+/**
+ * Create grand staff parts (treble + bass) or single part
+ */
+function createPartsFromNotes(
+  notes: MidiNote[],
+  measureDuration: number,
+  splitStaff: boolean,
+  middleCNote: number,
+  tempo: number
+): Part[] {
+  if (splitStaff) {
+    // Split into treble (>= middle C) and bass (< middle C)
+    const trebleNotes = notes.filter((n) => n.midi >= middleCNote);
+    const bassNotes = notes.filter((n) => n.midi < middleCNote);
+
+    return [
+      {
+        id: 'part-treble',
+        name: 'Piano Right Hand',
+        clef: 'treble',
+        measures: createMeasures(trebleNotes, measureDuration, tempo),
+      },
+      {
+        id: 'part-bass',
+        name: 'Piano Left Hand',
+        clef: 'bass',
+        measures: createMeasures(bassNotes, measureDuration, tempo),
+      },
+    ];
+  } else {
+    // Single staff
+    return [
+      {
+        id: 'part-1',
+        name: 'Piano',
+        clef: 'treble',
+        measures: createMeasures(notes, measureDuration, tempo),
+      },
+    ];
+  }
+}
+
+/**
+ * Create measures from notes
+ */
+function createMeasures(notes: MidiNote[], measureDuration: number, tempo: number = 120): Measure[] {
+  if (notes.length === 0) {
+    return [
+      {
+        id: 'measure-1',
+        number: 1,
+        notes: [],
+      },
+    ];
+  }
+
+  // Calculate total duration and number of measures
+  const maxTime = Math.max(...notes.map((n) => n.time + n.duration));
+  const numMeasures = Math.ceil(maxTime / measureDuration);
+
+  const measures: Measure[] = [];
+
+  for (let i = 0; i < numMeasures; i++) {
+    const measureStart = i * measureDuration;
+    const measureEnd = (i + 1) * measureDuration;
+
+    // Find notes that start in this measure
+    const measureNotes = notes
+      .filter((n) => n.time >= measureStart && n.time < measureEnd)
+      .map((midiNote, idx) => convertMidiNoteToNote(midiNote, `m${i + 1}-n${idx}`, measureStart, tempo));
+
+    measures.push({
+      id: `measure-${i + 1}`,
+      number: i + 1,
+      notes: measureNotes,
+    });
+  }
+
+  return measures;
+}
+
+/**
+ * Convert MIDI note to internal Note format
+ */
+function convertMidiNoteToNote(midiNote: MidiNote, id: string, measureStart: number, tempo: number): Note {
+  const { pitch, octave, accidental } = midiNumberToPitch(midiNote.midi);
+  const { duration, dotted } = durationToNoteName(midiNote.duration, tempo);
+
+  return {
+    id,
+    pitch: `${pitch}${octave}`,
+    duration,
+    octave,
+    startTime: midiNote.time - measureStart, // Relative to measure start
+    dotted,
+    accidental,
+    isRest: false,
+    // chordId will be assigned by grouping simultaneous notes
+  };
+}
+
+/**
+ * Convert MIDI note number to pitch name, octave, and accidental
+ */
+function midiNumberToPitch(midiNumber: number): {
+  pitch: string;
+  octave: number;
+  accidental?: 'sharp' | 'flat' | 'natural';
+} {
+  const pitchClasses = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+  const pitchClass = midiNumber % 12;
+  const octave = Math.floor(midiNumber / 12) - 1;
+  const pitchName = pitchClasses[pitchClass];
+
+  let accidental: 'sharp' | 'flat' | 'natural' | undefined;
+  if (pitchName.includes('#')) {
+    accidental = 'sharp';
+  }
+
+  return {
+    pitch: pitchName.replace('#', ''),
+    octave,
+    accidental,
+  };
+}
+
+/**
+ * Convert duration (in seconds) to note name (whole, half, quarter, etc.)
+ */
+function durationToNoteName(duration: number, tempo: number): { duration: string; dotted: boolean } {
+  // Calculate quarter note duration based on actual tempo
+  // At tempo BPM: 1 quarter note = 60/BPM seconds
+  const quarterNoteDuration = 60 / tempo;
+
+  const durationInQuarters = duration / quarterNoteDuration;
+
+  // Find closest standard duration (including dotted notes)
+  const durations: [number, string, boolean][] = [
+    [4, 'whole', false],
+    [3, 'half', true],     // dotted half
+    [2, 'half', false],
+    [1.5, 'quarter', true], // dotted quarter
+    [1, 'quarter', false],
+    [0.75, 'eighth', true], // dotted eighth
+    [0.5, 'eighth', false],
+    [0.375, '16th', true],  // dotted 16th
+    [0.25, '16th', false],
+    [0.125, '32nd', false],
+  ];
+
+  let closestDuration = durations[0];
+  let minDiff = Math.abs(durationInQuarters - durations[0][0]);
+
+  for (const [value, name, dotted] of durations) {
+    const diff = Math.abs(durationInQuarters - value);
+    if (diff < minDiff) {
+      minDiff = diff;
+      closestDuration = [value, name, dotted];
+    }
+  }
+
+  return {
+    duration: closestDuration[1],
+    dotted: closestDuration[2],
+  };
+}
+
+/**
+ * Group simultaneous notes into chords
+ */
+export function assignChordIds(score: Score): Score {
+  const CHORD_TOLERANCE = 0.05; // Notes within 50ms are considered simultaneous
+
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      const notes = measure.notes;
+
+      // Group notes by start time
+      const groups: Record<string, Note[]> = {};
+
+      for (const note of notes) {
+        const timeKey = Math.round(note.startTime / CHORD_TOLERANCE).toString();
+        if (!groups[timeKey]) {
+          groups[timeKey] = [];
+        }
+        groups[timeKey].push(note);
+      }
+
+      // Assign chordId to groups with multiple notes
+      for (const [timeKey, groupNotes] of Object.entries(groups)) {
+        if (groupNotes.length > 1) {
+          const chordId = `chord-${measure.id}-${timeKey}`;
+          groupNotes.forEach((note) => {
+            note.chordId = chordId;
+          });
+        }
+      }
+    }
+  }
+
+  return score;
+}

frontend/src/utils/musicxml-parser.ts

@@ -72,14 +72,21 @@ export function parseMusicXML(xml: string): Score {
 
     const noteElements = measureEl.querySelectorAll('note');
     let currentChord: Note[] = [];
+    let currentChordId: string | null = null;
 
-    noteElements.forEach((noteEl) => {
+    noteElements.forEach((noteEl, noteIdx) => {
       const parsedNote = parseNoteElement(noteEl);
       if (!parsedNote) return;
 
       // Check if this note is part of a chord (simultaneous with previous note)
       const isChordMember = noteEl.querySelector('chord') !== null;
 
+      // Assign chord ID for chord grouping
+      if (!isChordMember) {
+        // Start new chord group (or single note)
+        currentChordId = `chord-${measureNumber}-${noteIdx}`;
+      }
+
       if (parsedNote.isRest) {
         // Flush any pending chord before adding rest
         if (currentChord.length > 0) {
@@ -87,7 +94,7 @@ export function parseMusicXML(xml: string): Score {
           currentChord = [];
         }
 
-        // Include rests
+        // Include rests (rests don't have chordId)
         notes.push({
           id: `note-${measureNumber}-${notes.length}`,
           pitch: '',
@@ -96,6 +103,7 @@ export function parseMusicXML(xml: string): Score {
           startTime: 0,
           dotted: parsedNote.dotted,
           isRest: true,
+          chordId: undefined, // Rests are never part of chords
         });
       } else {
         // Build full pitch string for pitched notes
@@ -113,6 +121,7 @@ export function parseMusicXML(xml: string): Score {
           dotted: parsedNote.dotted,
           accidental: parsedNote.accidental as 'sharp' | 'flat' | 'natural' | undefined,
           isRest: false,
+          chordId: currentChordId || undefined, // Assign chord ID for grouping
         };
 
         if (isChordMember) {
@@ -205,12 +214,16 @@ function parseNoteElement(noteEl: Element): ParsedNote | null {
 
   const step = pitchEl.querySelector('step')?.textContent;
   const octave = pitchEl.querySelector('octave')?.textContent;
-  const alter = pitchEl.querySelector('alter')?.textContent;
+  const alter = pitchEl.querySelector('alter')?.textContent; // Semantic pitch alteration
+  const accidentalEl = noteEl.querySelector('accidental'); // Visual accidental display
   const dotEl = noteEl.querySelector('dot');
 
   if (!step || !octave) return null;
 
+  // Parse accidental from both <alter> (semantic) and <accidental> (visual) tags
   let accidental: string | undefined;
+
+  // Priority 1: Use <alter> for pitch accuracy (indicates actual pitch)
   if (alter) {
     const alterValue = parseInt(alter);
     if (alterValue === 1) accidental = 'sharp';
@@ -218,6 +231,14 @@ function parseNoteElement(noteEl: Element): ParsedNote | null {
     else if (alterValue === 0) accidental = 'natural';
   }
 
+  // Priority 2: If no <alter>, check <accidental> tag (visual notation)
+  if (!accidental && accidentalEl) {
+    const accType = accidentalEl.textContent;
+    if (accType === 'sharp') accidental = 'sharp';
+    else if (accType === 'flat') accidental = 'flat';
+    else if (accType === 'natural') accidental = 'natural';
+  }
+
   return {
     pitch: step,
     octave: parseInt(octave),

frontend/src/utils/validate-musicxml.ts

@@ -0,0 +1,289 @@
+/**
+ * MusicXML Parsing Validation Utility
+ *
+ * Purpose: Verify that the parser correctly extracts all MusicXML data
+ * by comparing raw XML elements with parsed Score object.
+ */
+
+import { parseMusicXML, Score } from './musicxml-parser';
+
+export interface ValidationReport {
+  totalXMLNotes: number;
+  totalParsedNotes: number;
+  totalXMLMeasures: number;
+  totalParsedMeasures: number;
+  missingNotes: Array<{
+    measureNumber: number;
+    pitch?: string;
+    octave?: number;
+    duration?: string;
+    isRest: boolean;
+  }>;
+  parsingErrors: string[];
+  warnings: string[];
+  success: boolean;
+}
+
+interface XMLNoteData {
+  measureNumber: number;
+  pitch?: string;
+  octave?: number;
+  alter?: number;
+  duration?: string;
+  isRest: boolean;
+  isChordMember: boolean;
+}
+
+/**
+ * Extract raw note data from MusicXML string
+ */
+function extractRawXMLNotes(xml: string): XMLNoteData[] {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, 'text/xml');
+
+  const notes: XMLNoteData[] = [];
+  const measures = doc.querySelectorAll('measure');
+
+  measures.forEach((measureEl) => {
+    const measureNumber = parseInt(measureEl.getAttribute('number') || '0');
+    const noteElements = measureEl.querySelectorAll('note');
+
+    noteElements.forEach((noteEl) => {
+      const pitchEl = noteEl.querySelector('pitch');
+      const rest = noteEl.querySelector('rest');
+      const isChordMember = noteEl.querySelector('chord') !== null;
+
+      if (rest) {
+        // Rest
+        const durationEl = noteEl.querySelector('duration');
+        const typeEl = noteEl.querySelector('type');
+
+        notes.push({
+          measureNumber,
+          duration: typeEl?.textContent || undefined,
+          isRest: true,
+          isChordMember,
+        });
+      } else if (pitchEl) {
+        // Pitched note
+        const step = pitchEl.querySelector('step')?.textContent;
+        const octave = pitchEl.querySelector('octave')?.textContent;
+        const alter = pitchEl.querySelector('alter')?.textContent;
+        const typeEl = noteEl.querySelector('type');
+
+        notes.push({
+          measureNumber,
+          pitch: step || undefined,
+          octave: octave ? parseInt(octave) : undefined,
+          alter: alter ? parseInt(alter) : undefined,
+          duration: typeEl?.textContent || undefined,
+          isRest: false,
+          isChordMember,
+        });
+      }
+    });
+  });
+
+  return notes;
+}
+
+/**
+ * Extract parsed note data from Score object
+ */
+function extractParsedNotes(score: Score): XMLNoteData[] {
+  const notes: XMLNoteData[] = [];
+
+  score.parts.forEach((part) => {
+    part.measures.forEach((measure) => {
+      measure.notes.forEach((note) => {
+        if (note.isRest) {
+          notes.push({
+            measureNumber: measure.number,
+            duration: note.duration,
+            isRest: true,
+            isChordMember: false, // Parsed notes don't preserve chord info yet
+          });
+        } else {
+          // Extract pitch from full pitch string (e.g., "C4" → "C", octave 4)
+          const pitchMatch = note.pitch.match(/([A-G][#b]?)(\d)/);
+          if (pitchMatch) {
+            const [, pitchName, octaveStr] = pitchMatch;
+            const step = pitchName[0]; // Just letter
+            const alter = pitchName.includes('#') ? 1 : pitchName.includes('b') ? -1 : 0;
+
+            notes.push({
+              measureNumber: measure.number,
+              pitch: step,
+              octave: parseInt(octaveStr),
+              alter: alter !== 0 ? alter : undefined,
+              duration: note.duration,
+              isRest: false,
+              isChordMember: false,
+            });
+          }
+        }
+      });
+    });
+  });
+
+  return notes;
+}
+
+/**
+ * Compare two note data objects for equality
+ */
+function notesEqual(a: XMLNoteData, b: XMLNoteData): boolean {
+  if (a.isRest !== b.isRest) return false;
+  if (a.measureNumber !== b.measureNumber) return false;
+
+  if (a.isRest) {
+    // For rests, just check duration
+    return a.duration === b.duration;
+  } else {
+    // For pitched notes, check pitch, octave, and duration
+    return (
+      a.pitch === b.pitch &&
+      a.octave === b.octave &&
+      a.duration === b.duration
+      // Note: We don't check alter here because parser may handle it differently
+    );
+  }
+}
+
+/**
+ * Validate MusicXML parsing
+ */
+export function validateMusicXMLParsing(xml: string): ValidationReport {
+  const report: ValidationReport = {
+    totalXMLNotes: 0,
+    totalParsedNotes: 0,
+    totalXMLMeasures: 0,
+    totalParsedMeasures: 0,
+    missingNotes: [],
+    parsingErrors: [],
+    warnings: [],
+    success: true,
+  };
+
+  try {
+    // Extract raw XML data
+    const rawNotes = extractRawXMLNotes(xml);
+    report.totalXMLNotes = rawNotes.length;
+
+    // Parse with our parser
+    const score = parseMusicXML(xml);
+    const parsedNotes = extractParsedNotes(score);
+    report.totalParsedNotes = parsedNotes.length;
+
+    // Count measures
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(xml, 'text/xml');
+    report.totalXMLMeasures = doc.querySelectorAll('measure').length;
+    report.totalParsedMeasures = score.parts.reduce(
+      (sum, part) => sum + part.measures.length,
+      0
+    );
+
+    // Check note count
+    if (rawNotes.length !== parsedNotes.length) {
+      report.warnings.push(
+        `Note count mismatch: XML has ${rawNotes.length} notes, parsed ${parsedNotes.length}`
+      );
+    }
+
+    // Find missing notes
+    const parsedMatched = new Array(parsedNotes.length).fill(false);
+
+    for (const rawNote of rawNotes) {
+      // Find matching parsed note
+      const matchIdx = parsedNotes.findIndex(
+        (parsed, idx) => !parsedMatched[idx] && notesEqual(rawNote, parsed)
+      );
+
+      if (matchIdx === -1) {
+        // No match found
+        report.missingNotes.push(rawNote);
+      } else {
+        // Mark as matched
+        parsedMatched[matchIdx] = true;
+      }
+    }
+
+    // Check for critical errors
+    if (report.totalXMLNotes === 0 && report.totalParsedNotes === 0) {
+      report.warnings.push('No notes found in MusicXML');
+    }
+
+    if (report.totalParsedNotes === 0 && report.totalXMLNotes > 0) {
+      report.parsingErrors.push('Parser failed to extract any notes from MusicXML');
+      report.success = false;
+    }
+
+    if (report.missingNotes.length > report.totalXMLNotes * 0.1) {
+      // More than 10% notes missing
+      report.parsingErrors.push(
+        `Significant note loss: ${report.missingNotes.length} / ${report.totalXMLNotes} notes missing (${((report.missingNotes.length / report.totalXMLNotes) * 100).toFixed(1)}%)`
+      );
+      report.success = false;
+    }
+  } catch (error) {
+    report.parsingErrors.push(`Exception during parsing: ${error}`);
+    report.success = false;
+  }
+
+  return report;
+}
+
+/**
+ * Print validation report to console
+ */
+export function printValidationReport(report: ValidationReport): void {
+  console.log('\n' + '='.repeat(80));
+  console.log('MUSICXML PARSING VALIDATION REPORT');
+  console.log('='.repeat(80));
+
+  console.log('\n📊 SUMMARY:');
+  console.log(`  Total XML notes:     ${report.totalXMLNotes}`);
+  console.log(`  Total parsed notes:  ${report.totalParsedNotes}`);
+  console.log(`  Total XML measures:  ${report.totalXMLMeasures}`);
+  console.log(`  Total parsed measures: ${report.totalParsedMeasures}`);
+  console.log(`  Missing notes:       ${report.missingNotes.length}`);
+
+  if (report.totalXMLNotes > 0) {
+    const accuracy =
+      ((report.totalXMLNotes - report.missingNotes.length) / report.totalXMLNotes) * 100;
+    console.log(`\n  ${report.success ? '✅' : '❌'} Parsing accuracy: ${accuracy.toFixed(1)}%`);
+  }
+
+  if (report.parsingErrors.length > 0) {
+    console.log('\n❌ PARSING ERRORS:');
+    report.parsingErrors.forEach((error, i) => {
+      console.log(`  ${i + 1}. ${error}`);
+    });
+  }
+
+  if (report.warnings.length > 0) {
+    console.log('\n⚠️  WARNINGS:');
+    report.warnings.forEach((warning, i) => {
+      console.log(`  ${i + 1}. ${warning}`);
+    });
+  }
+
+  if (report.missingNotes.length > 0) {
+    console.log(`\n❌ MISSING NOTES (first 10):`);
+    report.missingNotes.slice(0, 10).forEach((note, i) => {
+      if (note.isRest) {
+        console.log(
+          `  ${i + 1}. Rest in measure ${note.measureNumber}, duration ${note.duration}`
+        );
+      } else {
+        const accidental = note.alter === 1 ? '#' : note.alter === -1 ? 'b' : '';
+        console.log(
+          `  ${i + 1}. ${note.pitch}${accidental}${note.octave} in measure ${note.measureNumber}, duration ${note.duration}`
+        );
+      }
+    });
+  }
+
+  console.log('\n' + '='.repeat(80));
+}