@scorelabs/core 1.0.10 → 1.0.13

package/dist/importers/MusicXMLParser.js

@@ -1,6 +1,6 @@
 import JSZip from 'jszip';
-import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument';
-import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, DURATION_VALUES, Duration, GlissandoType, HairpinType, NoteheadShape, Ornament, OttavaType, StemDirection, decomposeDuration, } from '../models/types';
+import { getInstrumentByProgram, guessInstrumentByName } from '../models/Instrument.js';
+import { Accidental, Arpeggio, Articulation, BarlineStyle, Bowing, Clef, Duration, GlissandoType, HairpinType, HarmonicType, NoteheadShape, Ornament, OttavaType, StemDirection, calculateDurationValue, decomposeDuration, } from '../models/types.js';
 /**
  * MusicXML Parser
  *
@@ -14,6 +14,7 @@ export class MusicXMLParser {
     currentSymbol = 'normal';
     instrumentPitchMap = new Map();
     _domParser;
+    activeWedgeTypes = new Map();
     constructor(domParserInstance) {
         this._domParser =
             domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
@@ -81,7 +82,7 @@ export class MusicXMLParser {
             if (!_parser)
                 throw new Error('No DOMParser available');
             const containerDoc = _parser.parseFromString(containerXml, 'application/xml');
-            const rootfile = (new MusicXMLParser(_parser)).querySelector(containerDoc, 'rootfile');
+            const rootfile = new MusicXMLParser(_parser).querySelector(containerDoc, 'rootfile');
             const fullPath = rootfile?.getAttribute('full-path');
             if (!fullPath)
                 throw new Error('Invalid MXL: Could not find main score file path');
@@ -120,6 +121,7 @@ export class MusicXMLParser {
         const title = this.parseTitle(doc);
         const subtitle = this.parseSubtitle(doc);
         const composer = this.parseComposer(doc);
+        const lyricist = this.parseLyricist(doc);
         const copyright = this.parseCopyright(doc);
         const partInfo = this.parsePartList(doc);
         const parts = this.parseParts(doc, partInfo);
@@ -127,13 +129,15 @@ export class MusicXMLParser {
         let globalTempoDuration = Duration.Quarter;
         let globalTempoIsDotted = false;
         let globalTempoText = '';
+        let globalTempoDotCount = 0;
         if (parts.length > 0 && parts[0].staves.length > 0 && parts[0].staves[0].measures.length > 0) {
             const firstMeasure = parts[0].staves[0].measures[0];
             if (firstMeasure.tempo) {
                 globalBpm = firstMeasure.tempo.bpm;
                 globalTempoDuration = firstMeasure.tempo.duration;
-                globalTempoIsDotted = firstMeasure.tempo.isDotted;
                 globalTempoText = firstMeasure.tempo.text || '';
+                globalTempoDotCount = firstMeasure.tempo.dotCount || 0;
+                globalTempoIsDotted = globalTempoDotCount > 0;
             }
         }
         const score = {
@@ -149,9 +153,10 @@ export class MusicXMLParser {
             parts,
             bpm: globalBpm,
             tempoDuration: globalTempoDuration,
-            tempoIsDotted: globalTempoIsDotted,
             tempoText: globalTempoText,
+            tempoDotCount: globalTempoDotCount || (globalTempoIsDotted ? 1 : 0),
             copyright,
+            lyricist,
         };
         return this.postProcess(score);
     }
@@ -210,7 +215,38 @@ export class MusicXMLParser {
             if (creator.getAttribute('type') === 'composer')
                 return creator.textContent ?? 'Unknown';
         }
-        return this.querySelector(doc, 'identification creator')?.textContent ?? 'Unknown';
+        // If no type="composer", but there is only one creator, assume it's the composer
+        if (creators.length === 1)
+            return creators[0].textContent ?? 'Unknown';
+        // Check credits for composer type
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'composer') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return creators.length > 0 ? (creators[0].textContent ?? 'Unknown') : 'Unknown';
+    }
+    parseLyricist(doc) {
+        const creators = this.querySelectorAll(doc, 'identification creator');
+        for (const creator of Array.from(creators)) {
+            if (creator.getAttribute('type') === 'lyricist')
+                return creator.textContent ?? '';
+        }
+        // Check credits for lyricist type
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'lyricist') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return '';
     }
     parsePartList(doc) {
         const partInfo = new Map();
@@ -281,10 +317,16 @@ export class MusicXMLParser {
         const staffClefs = Array(numStaves).fill(Clef.Treble);
         const lastVoicePerStaff = new Map();
         let divisions = 1;
+        let initialClefsSet = false;
         for (const [mIdx, measureElement] of Array.from(measureElements).entries()) {
             let measureTimeSignature;
             let measureKeySignature;
+            let multiMeasureRestCount;
             let isPickup = measureElement.getAttribute('implicit') === 'yes';
+            let currentSystemDistance;
+            let currentTopSystemDistance;
+            const currentStaffDistances = new Map();
+            const explicitClefs = Array(numStaves).fill(undefined);
             const attributes = this.querySelector(measureElement, 'attributes');
             if (attributes) {
                 const divNode = this.querySelector(attributes, 'divisions');
@@ -325,7 +367,9 @@ export class MusicXMLParser {
                     if (sign && number <= numStaves) {
                         const line = this.getNumber(clef, 'line') || 0;
                         const octaveChange = this.getNumber(clef, 'clef-octave-change') || 0;
-                        staffClefs[number - 1] = this.mapClef(sign, line, octaveChange);
+                        const mapped = this.mapClef(sign, line, octaveChange);
+                        staffClefs[number - 1] = mapped;
+                        explicitClefs[number - 1] = mapped;
                     }
                 });
                 const staffDetails = this.querySelectorAll(attributes, 'staff-details');
@@ -335,10 +379,15 @@ export class MusicXMLParser {
                     if (lines !== null && number <= numStaves)
                         staves[number - 1].lineCount = lines;
                 });
+                const multipleRest = this.getNumber(attributes, 'measure-style multiple-rest');
+                if (multipleRest !== null && multipleRest > 1) {
+                    multiMeasureRestCount = multipleRest;
+                }
             }
             let measureTempo = undefined;
             let rehearsalMark = undefined;
             let systemText = undefined;
+            const roadmapDirections = [];
             let contextDynamic = undefined;
             const { repeats, volta, barlineStyle } = this.parseBarlines(measureElement);
             // Map of staffIndex -> Map of voiceId -> NoteSetJSON[]
@@ -347,10 +396,12 @@ export class MusicXMLParser {
                 staffVoices.set(i, new Map());
             const children = this.getChildren(measureElement);
             let pendingChord = undefined;
-            let currentNoteSetMap = new Map();
+            const currentNoteSetMap = new Map();
             const beamGroupIdMap = new Map();
+            const beamGroupIdByVoice = new Map();
             let globalBeamId = 1;
-            let currentHairpin = undefined;
+            const currentHairpins = new Map();
+            const lastNoteOnStaff = new Map();
             let currentOttava = undefined;
             let currentPedal = undefined;
             children.forEach((child) => {
@@ -364,27 +415,88 @@ export class MusicXMLParser {
                     if (metronome) {
                         const beatUnit = this.getText(metronome, 'beat-unit') || 'quarter';
                         const bpm = parseInt(this.getText(metronome, 'per-minute') || '120');
-                        const isDotted = this.querySelector(metronome, 'beat-unit-dot') !== null;
-                        measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
+                        const dotCount = this.querySelectorAll(metronome, 'beat-unit-dot').length;
+                        measureTempo = { bpm, duration: this.mapDuration(beatUnit), dotCount };
                     }
                     const rehearsal = this.querySelector(child, 'rehearsal');
                     if (rehearsal)
                         rehearsalMark = rehearsal.textContent || undefined;
-                    const words = this.querySelector(child, 'words');
-                    if (words) {
-                        if (measureTempo)
-                            measureTempo.text = words.textContent || undefined;
-                        else
-                            systemText = words.textContent || undefined;
+                    const wordsNodes = this.querySelectorAll(child, 'words');
+                    wordsNodes.forEach((words) => {
+                        const wordsText = (words.textContent || '').trim();
+                        const normalizedWords = wordsText.toLowerCase().replace(/\s+/g, ' ');
+                        let roadmapWord;
+                        if (/\bd\.?\s*c\.?\b|\bdacapo\b/.test(normalizedWords)) {
+                            roadmapWord = 'D.C.';
+                        }
+                        else if (/\bd\.?\s*s\.?\b|\bdal segno\b|\bdalsegno\b/.test(normalizedWords)) {
+                            roadmapWord = 'D.S.';
+                        }
+                        else if (/\bto coda\b|\bal coda\b/.test(normalizedWords)) {
+                            roadmapWord = 'To Coda';
+                        }
+                        else if (/\bfine\b/.test(normalizedWords)) {
+                            roadmapWord = 'Fine';
+                        }
+                        if (roadmapWord && !roadmapDirections.includes(roadmapWord)) {
+                            roadmapDirections.push(roadmapWord);
+                        }
+                        else if (measureTempo && !measureTempo.text) {
+                            measureTempo.text = wordsText || undefined;
+                        }
+                        else if (!systemText) {
+                            systemText = wordsText || undefined;
+                        }
+                    });
+                    if (this.querySelector(child, 'segno') && !roadmapDirections.includes('𝄋 Segno')) {
+                        roadmapDirections.push('𝄋 Segno');
+                    }
+                    if (this.querySelector(child, 'coda') && !roadmapDirections.includes('𝄌 Coda')) {
+                        roadmapDirections.push('𝄌 Coda');
+                    }
+                    const soundNode = this.querySelector(child, 'sound');
+                    if (soundNode) {
+                        if (soundNode.getAttribute('dacapo') === 'yes' && !roadmapDirections.includes('D.C.')) {
+                            roadmapDirections.push('D.C.');
+                        }
+                        if (soundNode.getAttribute('dalsegno') === 'yes' &&
+                            !roadmapDirections.includes('D.S.')) {
+                            roadmapDirections.push('D.S.');
+                        }
+                        if (soundNode.getAttribute('tocoda') === 'yes' &&
+                            !roadmapDirections.includes('To Coda')) {
+                            roadmapDirections.push('To Coda');
+                        }
+                        if (soundNode.getAttribute('fine') === 'yes' && !roadmapDirections.includes('Fine')) {
+                            roadmapDirections.push('Fine');
+                        }
                     }
                     const wedge = this.querySelector(child, 'wedge');
                     if (wedge) {
                         const typeAttr = wedge.getAttribute('type');
-                        if (typeAttr === 'crescendo' || typeAttr === 'diminuendo' || typeAttr === 'stop') {
-                            currentHairpin = {
-                                type: typeAttr === 'crescendo' ? HairpinType.Crescendo : HairpinType.Decrescendo,
+                        const staffIdx = this.getNumber(child, 'staff') || 1;
+                        if (typeAttr === 'crescendo' ||
+                            typeAttr === 'diminuendo' ||
+                            typeAttr === 'stop' ||
+                            typeAttr === 'continue') {
+                            if (typeAttr === 'crescendo') {
+                                this.activeWedgeTypes.set(staffIdx, HairpinType.Crescendo);
+                            }
+                            else if (typeAttr === 'diminuendo') {
+                                this.activeWedgeTypes.set(staffIdx, HairpinType.Decrescendo);
+                            }
+                            const type = this.activeWedgeTypes.get(staffIdx) || HairpinType.Crescendo;
+                            const hp = {
+                                type,
                                 placement: typeAttr === 'stop' ? 'stop' : 'start',
                             };
+                            // If it's a stop, and we just had a note on this staff, attach it immediately.
+                            if (typeAttr === 'stop' && lastNoteOnStaff.has(staffIdx)) {
+                                lastNoteOnStaff.get(staffIdx).hairpin = hp;
+                            }
+                            else {
+                                currentHairpins.set(staffIdx, hp);
+                            }
                         }
                     }
                     const octShift = this.querySelector(child, 'octave-shift');
@@ -407,37 +519,118 @@ export class MusicXMLParser {
                     const pedalNode = this.querySelector(child, 'pedal');
                     if (pedalNode) {
                         const typeAttr = pedalNode.getAttribute('type');
-                        if (typeAttr === 'start' || typeAttr === 'stop') {
-                            currentPedal = { type: 'sustain', placement: typeAttr };
+                        const hasLine = pedalNode.getAttribute('line') === 'yes';
+                        const hasSign = pedalNode.getAttribute('sign') === 'yes';
+                        if (typeAttr === 'start' ||
+                            typeAttr === 'stop' ||
+                            typeAttr === 'change' ||
+                            typeAttr === 'continue') {
+                            let style = 'text';
+                            if (hasLine && hasSign)
+                                style = 'mixed';
+                            else if (hasLine)
+                                style = 'bracket';
+                            currentPedal = {
+                                type: 'sustain',
+                                placement: typeAttr,
+                                style,
+                            };
                         }
                     }
                     const dynamics = this.querySelector(child, 'dynamics');
                     if (dynamics) {
                         const firstChild = this.getFirstElementChild(dynamics);
-                        if (firstChild)
-                            contextDynamic = firstChild.nodeName.toLowerCase();
+                        if (firstChild) {
+                            const dyn = firstChild.nodeName.toLowerCase();
+                            const staffIdx = this.getNumber(child, 'staff') || 1;
+                            if (lastNoteOnStaff.has(staffIdx)) {
+                                lastNoteOnStaff.get(staffIdx).dynamic = dyn;
+                            }
+                            else {
+                                contextDynamic = dyn;
+                            }
+                        }
+                    }
+                }
+                else if (child.nodeName === 'print') {
+                    const newSystem = child.getAttribute('new-system') === 'yes';
+                    const newPage = child.getAttribute('new-page') === 'yes';
+                    if (mIdx > 0) {
+                        if (newSystem || newPage) {
+                            staves.forEach((s) => {
+                                const prev = s.measures[mIdx - 1];
+                                if (prev) {
+                                    if (newSystem)
+                                        prev.systemBreak = true;
+                                    if (newPage)
+                                        prev.pageBreak = true;
+                                }
+                            });
+                        }
+                    }
+                    const systemLayout = this.querySelector(child, 'system-layout');
+                    if (systemLayout) {
+                        const systemDistance = this.getNumber(systemLayout, 'system-distance');
+                        if (systemDistance !== null)
+                            currentSystemDistance = systemDistance;
+                        const topSystemDistance = this.getNumber(systemLayout, 'top-system-distance');
+                        if (topSystemDistance !== null)
+                            currentTopSystemDistance = topSystemDistance;
                     }
+                    const staffLayouts = this.querySelectorAll(child, 'staff-layout');
+                    staffLayouts.forEach((sl) => {
+                        const staffNum = parseInt(sl.getAttribute('number') || '1');
+                        const staffDistance = this.getNumber(sl, 'staff-distance');
+                        if (staffDistance !== null)
+                            currentStaffDistances.set(staffNum, staffDistance);
+                    });
                 }
                 else if (child.nodeName === 'note') {
                     const staffNum = parseInt(this.getText(child, 'staff') || '1');
                     const staffIdx = Math.min(Math.max(staffNum - 1, 0), numStaves - 1);
+                    const voiceId = this.getText(child, 'voice') || '1';
                     const isChord = this.querySelector(child, 'chord') !== null;
-                    const note = this.parseNote(child);
+                    const note = this.parseNote(child, divisions);
                     if (note) {
-                        const beamEl = this.querySelector(child, 'beam[number="1"]');
-                        if (beamEl) {
-                            const beamType = beamEl.textContent;
-                            if (beamType === 'begin') {
+                        lastNoteOnStaff.set(staffNum, note);
+                        const beamElements = this.querySelectorAll(child, 'beam');
+                        const beamLevels = {};
+                        beamElements.forEach((beamEl) => {
+                            const numberAttr = beamEl.getAttribute('number');
+                            const level = numberAttr ? parseInt(numberAttr, 10) : 1;
+                            if (!Number.isFinite(level) || level < 1)
+                                return;
+                            const beamTypeRaw = (beamEl.textContent || '').trim().toLowerCase();
+                            if (beamTypeRaw === 'begin' ||
+                                beamTypeRaw === 'continue' ||
+                                beamTypeRaw === 'end' ||
+                                beamTypeRaw === 'forward hook' ||
+                                beamTypeRaw === 'backward hook') {
+                                beamLevels[level] = beamTypeRaw;
+                            }
+                        });
+                        if (Object.keys(beamLevels).length > 0) {
+                            note.beamLevels = beamLevels;
+                        }
+                        const primaryBeamType = beamLevels[1];
+                        if (primaryBeamType) {
+                            if (primaryBeamType === 'begin') {
                                 const newId = globalBeamId++;
                                 beamGroupIdMap.set(staffIdx, newId);
+                                beamGroupIdByVoice.set(voiceId, newId);
                                 note.beamGroup = newId;
                             }
-                            else if (beamType === 'continue' || beamType === 'end') {
-                                const currentId = beamGroupIdMap.get(staffIdx);
+                            else if (primaryBeamType === 'continue' || primaryBeamType === 'end') {
+                                const currentId = beamGroupIdMap.get(staffIdx) ?? beamGroupIdByVoice.get(voiceId);
                                 if (currentId !== undefined) {
                                     note.beamGroup = currentId;
-                                    if (beamType === 'end')
+                                    beamGroupIdMap.set(staffIdx, currentId);
+                                    if (primaryBeamType === 'end') {
                                         beamGroupIdMap.delete(staffIdx);
+                                        if (beamGroupIdByVoice.get(voiceId) === currentId) {
+                                            beamGroupIdByVoice.delete(voiceId);
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -451,9 +644,9 @@ export class MusicXMLParser {
                             note.dynamic = contextDynamic;
                             contextDynamic = undefined;
                         }
-                        if (currentHairpin) {
-                            note.hairpin = currentHairpin;
-                            currentHairpin = undefined;
+                        if (currentHairpins.has(staffNum)) {
+                            note.hairpin = currentHairpins.get(staffNum);
+                            currentHairpins.delete(staffNum);
                         }
                         if (currentOttava) {
                             note.ottava = currentOttava;
@@ -463,7 +656,6 @@ export class MusicXMLParser {
                             note.pedal = currentPedal;
                             currentPedal = undefined;
                         }
-                        const voiceId = this.getText(child, 'voice') || '1';
                         lastVoicePerStaff.set(staffIdx, voiceId);
                         const voiceMap = staffVoices.get(staffIdx);
                         if (!voiceMap.has(voiceId))
@@ -514,12 +706,13 @@ export class MusicXMLParser {
                 const v1 = vMap0.get('1') || vMap0.get(Array.from(vMap0.keys())[0]);
                 if (v1) {
                     // Check duration of first voice in first staff
-                    const expectedDivisions = this.currentBeats * (divisions * 4 / this.currentBeatType);
+                    const expectedDivisions = this.currentBeats * ((divisions * 4) / this.currentBeatType);
                     let totalMeasureDivs = 0;
                     const notes = this.querySelectorAll(measureElement, 'note');
                     // Find first voice in first staff
                     for (const n of notes) {
-                        if ((this.getText(n, 'staff') || '1') === '1' && (this.getText(n, 'voice') || '1') === (Array.from(vMap0.keys())[0] || '1')) {
+                        if ((this.getText(n, 'staff') || '1') === '1' &&
+                            (this.getText(n, 'voice') || '1') === (Array.from(vMap0.keys())[0] || '1')) {
                             if (this.querySelector(n, 'chord'))
                                 continue;
                             totalMeasureDivs += this.getNumber(n, 'duration') || 0;
@@ -535,26 +728,37 @@ export class MusicXMLParser {
                 let voicesIndices = Array.from(vMap.keys()).sort();
                 if (voicesIndices.length === 0)
                     voicesIndices = ['1'];
-                const voices = voicesIndices.map(id => vMap.get(id) || []);
+                const voices = voicesIndices.map((id) => vMap.get(id) || []);
                 const measure = {
                     voices: voices,
                     timeSignature: measureTimeSignature,
                     keySignature: measureKeySignature,
                     isPickup: isPickup || undefined,
+                    clef: explicitClefs[i],
                     tempo: i === 0 ? measureTempo : undefined,
                     repeats: repeats.length > 0 ? repeats : undefined,
-                    volta,
+                    volta: i === 0 ? volta : undefined,
                     rehearsalMark: i === 0 ? rehearsalMark : undefined,
                     systemText: i === 0 ? systemText : undefined,
+                    multiMeasureRestCount,
+                    roadmapDirections: i === 0 && roadmapDirections.length > 0 ? roadmapDirections : undefined,
                     barlineStyle,
+                    systemDistance: i === 0 ? currentSystemDistance : undefined,
+                    staffDistance: currentStaffDistances.get(i + 1),
+                    topSystemDistance: i === 0 ? currentTopSystemDistance : undefined,
                 };
+                if (mIdx === 0 && !initialClefsSet) {
+                    staves[i].clef = staffClefs[i];
+                    if (i === numStaves - 1)
+                        initialClefsSet = true;
+                }
                 // Padding with rests if not a pickup
                 if (!isPickup) {
                     const targetDur = (this.currentBeats * 4) / this.currentBeatType;
                     measure.voices = measure.voices.map((v) => {
                         const currentDur = v.reduce((sum, ns) => {
-                            const base = DURATION_VALUES[ns.notes[0].duration];
-                            return sum + (ns.notes[0].isDotted ? base * 1.5 : base);
+                            return (sum +
+                                calculateDurationValue(ns.notes[0].duration, ns.notes[0].dotCount || (ns.notes[0].dotCount ? 1 : 0)));
                         }, 0);
                         if (currentDur < targetDur - 0.001) {
                             const gap = targetDur - currentDur;
@@ -563,7 +767,7 @@ export class MusicXMLParser {
                                     {
                                         duration: d.duration,
                                         isRest: true,
-                                        isDotted: d.isDotted,
+                                        dotCount: d.dotCount,
                                     },
                                 ],
                             }));
@@ -573,19 +777,97 @@ export class MusicXMLParser {
                     });
                 }
                 staves[i].measures.push(measure);
-                staves[i].clef = staffClefs[i];
             }
         }
         return staves;
     }
-    parseNote(noteElement) {
+    parseNote(noteElement, divisions) {
         const isRest = this.querySelector(noteElement, 'rest') !== null;
-        const isGrace = this.querySelector(noteElement, 'grace') !== null;
+        const restNode = this.querySelector(noteElement, 'rest');
+        const graceEl = this.querySelector(noteElement, 'grace');
+        const isGrace = graceEl !== null;
         const type = this.getText(noteElement, 'type');
-        const duration = type ? this.mapDuration(type) : Duration.Quarter;
-        const isDotted = this.querySelector(noteElement, 'dot') !== null;
-        if (isRest)
-            return { duration, isRest: true, isDotted };
+        const typeEl = this.querySelector(noteElement, 'type');
+        const isCue = this.querySelector(noteElement, 'cue') !== null || typeEl?.getAttribute('size') === 'cue';
+        let duration = type ? this.mapDuration(type) : Duration.Quarter;
+        let dotCount = this.querySelectorAll(noteElement, 'dot').length;
+        if (!type && !isGrace) {
+            const numDuration = this.getNumber(noteElement, 'duration');
+            if (numDuration !== null && divisions > 0) {
+                const qBeats = numDuration / divisions;
+                if (qBeats >= 4) {
+                    duration = Duration.Whole;
+                    dotCount = 0;
+                }
+                else if (qBeats >= 3) {
+                    duration = Duration.Half;
+                    dotCount = 1;
+                }
+                else if (qBeats >= 2) {
+                    duration = Duration.Half;
+                    dotCount = 0;
+                }
+                else if (qBeats >= 1.5) {
+                    duration = Duration.Quarter;
+                    dotCount = 1;
+                }
+                else if (qBeats >= 1) {
+                    duration = Duration.Quarter;
+                    dotCount = 0;
+                }
+                else if (qBeats >= 0.75) {
+                    duration = Duration.Eighth;
+                    dotCount = 1;
+                }
+                else if (qBeats >= 0.5) {
+                    duration = Duration.Eighth;
+                    dotCount = 0;
+                }
+                else if (qBeats >= 0.25) {
+                    duration = Duration.Sixteenth;
+                    dotCount = 0;
+                }
+            }
+        }
+        if (isRest) {
+            const displayStepText = this.getText(restNode || noteElement, 'display-step');
+            const displayOctave = this.getNumber(restNode || noteElement, 'display-octave') ?? undefined;
+            const placement = this.getPlacement(noteElement);
+            const restDisplay = displayStepText ||
+                displayOctave !== undefined ||
+                placement?.defaultY !== undefined ||
+                placement?.relativeY !== undefined
+                ? {
+                    displayStep: displayStepText ? this.stepToNumber(displayStepText) : undefined,
+                    displayOctave,
+                    defaultY: placement?.defaultY,
+                    relativeY: placement?.relativeY,
+                }
+                : undefined;
+            return { duration, isRest: true, dotCount, restDisplay, placement };
+        }
+        let grace;
+        if (graceEl) {
+            const slashAttr = graceEl.getAttribute('slash');
+            const stealTimePreviousAttr = graceEl.getAttribute('steal-time-previous');
+            const stealTimeFollowingAttr = graceEl.getAttribute('steal-time-following');
+            const makeTimeAttr = graceEl.getAttribute('make-time');
+            const stealTimePrevious = stealTimePreviousAttr
+                ? parseInt(stealTimePreviousAttr, 10)
+                : undefined;
+            const stealTimeFollowing = stealTimeFollowingAttr
+                ? parseInt(stealTimeFollowingAttr, 10)
+                : undefined;
+            const makeTime = makeTimeAttr ? parseInt(makeTimeAttr, 10) : undefined;
+            const cueSize = typeEl?.getAttribute('size') === 'cue';
+            grace = {
+                slash: slashAttr === 'yes',
+                stealTimePrevious: Number.isFinite(stealTimePrevious) ? stealTimePrevious : undefined,
+                stealTimeFollowing: Number.isFinite(stealTimeFollowing) ? stealTimeFollowing : undefined,
+                makeTime: Number.isFinite(makeTime) ? makeTime : undefined,
+                cueSize: cueSize || undefined,
+            };
+        }
         let step = 'C', octave = 4, alter = 0;
         const unpitched = this.querySelector(noteElement, 'unpitched');
         if (unpitched) {
@@ -608,7 +890,16 @@ export class MusicXMLParser {
                 midiNumber = this.instrumentPitchMap.get(instId);
         }
         let accidental = this.mapAccidental(alter);
-        const accidentalEl = this.getText(noteElement, 'accidental');
+        const accidentalNode = this.querySelector(noteElement, 'accidental');
+        const accidentalEl = accidentalNode?.textContent?.trim() || '';
+        const accidentalDisplay = accidentalNode
+            ? {
+                cautionary: accidentalNode.getAttribute('cautionary') === 'yes' || undefined,
+                editorial: accidentalNode.getAttribute('editorial') === 'yes' || undefined,
+                parenthesized: accidentalNode.getAttribute('parentheses') === 'yes' || undefined,
+                bracketed: accidentalNode.getAttribute('bracket') === 'yes' || undefined,
+            }
+            : undefined;
         if (accidentalEl) {
             if (accidentalEl === 'sharp')
                 accidental = Accidental.Sharp;
@@ -636,7 +927,7 @@ export class MusicXMLParser {
         else if (stem === 'down')
             stemDirection = StemDirection.Down;
         const notations = this.querySelector(noteElement, 'notations');
-        // Tuplet ratio
+        // Tuplet ratio and engraving metadata
         let tuplet = undefined;
         const timeMod = this.querySelector(noteElement, 'time-modification');
         if (timeMod) {
@@ -652,22 +943,81 @@ export class MusicXMLParser {
                     tuplet.type = 'start';
                 else if (type === 'stop')
                     tuplet.type = 'stop';
+                const numberAttr = tupletEl.getAttribute('number');
+                const number = numberAttr ? parseInt(numberAttr, 10) : undefined;
+                if (Number.isFinite(number)) {
+                    tuplet.number = number;
+                }
+                const placement = tupletEl.getAttribute('placement');
+                if (placement === 'above' || placement === 'below') {
+                    tuplet.placement = placement;
+                }
+                const bracket = tupletEl.getAttribute('bracket');
+                if (bracket === 'yes' || bracket === 'no') {
+                    tuplet.bracket = bracket;
+                }
+                else {
+                    tuplet.bracket = 'auto';
+                }
+                const showNumber = tupletEl.getAttribute('show-number');
+                if (showNumber === 'none' || showNumber === 'actual' || showNumber === 'both') {
+                    tuplet.showNumber = showNumber;
+                }
+                else {
+                    tuplet.showNumber = 'actual';
+                }
+                const actualDisplay = this.getNumber(tupletEl, 'tuplet-actual tuplet-number');
+                if (actualDisplay !== null) {
+                    tuplet.actualDisplay = actualDisplay;
+                }
+                const normalDisplay = this.getNumber(tupletEl, 'tuplet-normal tuplet-number');
+                if (normalDisplay !== null) {
+                    tuplet.normalDisplay = normalDisplay;
+                }
             }
         }
-        let slur = undefined;
-        const slurEl = notations ? this.querySelector(notations, 'slur') : null;
-        if (slurEl) {
-            const type = slurEl.getAttribute('type');
-            if (type === 'start' || type === 'stop') {
-                slur = { placement: type };
+        const slurs = [];
+        if (notations) {
+            this.querySelectorAll(notations, 'slur').forEach((slurEl) => {
+                const type = slurEl.getAttribute('type');
+                if (type !== 'start' && type !== 'stop')
+                    return;
                 const orientation = slurEl.getAttribute('orientation');
-                if (orientation === 'over')
-                    slur.direction = 'up';
-                else if (orientation === 'under')
-                    slur.direction = 'down';
+                const direction = orientation === 'over' ? 'up' : orientation === 'under' ? 'down' : undefined;
+                const numberAttr = slurEl.getAttribute('number');
+                const number = numberAttr ? parseInt(numberAttr, 10) : undefined;
+                slurs.push({ placement: type, direction, number: Number.isFinite(number) ? number : 1 });
+            });
+        }
+        const slur = slurs.find((s) => s.placement === 'start') || slurs[0];
+        const tieSpans = [];
+        this.querySelectorAll(noteElement, 'tie').forEach((tieEl) => {
+            const type = tieEl.getAttribute('type');
+            if (type === 'start' || type === 'stop' || type === 'continue') {
+                tieSpans.push({ placement: type, number: 1 });
             }
+        });
+        if (notations) {
+            this.querySelectorAll(notations, 'tied').forEach((tiedEl) => {
+                const type = tiedEl.getAttribute('type');
+                if (type !== 'start' && type !== 'stop' && type !== 'continue')
+                    return;
+                const numberAttr = tiedEl.getAttribute('number');
+                const number = numberAttr ? parseInt(numberAttr, 10) : 1;
+                tieSpans.push({ placement: type, number: Number.isFinite(number) ? number : 1 });
+            });
         }
-        const tie = this.querySelector(noteElement, 'tie')?.getAttribute('type') === 'start' || undefined;
+        const dedupedTieSpans = [];
+        const tieSpanKeys = new Set();
+        tieSpans.forEach((span) => {
+            const key = `${span.placement}:${span.number || 1}`;
+            if (!tieSpanKeys.has(key)) {
+                tieSpanKeys.add(key);
+                dedupedTieSpans.push(span);
+            }
+        });
+        const tie = dedupedTieSpans.some((span) => span.placement === 'start' || span.placement === 'continue') ||
+            undefined;
         const articulations = [];
         const articEl = notations ? this.querySelector(notations, 'articulations') : null;
         if (articEl) {
@@ -690,6 +1040,7 @@ export class MusicXMLParser {
             articulations.push(Articulation.Fermata);
         let arpeggio = undefined;
         const arpeggiateEl = notations ? this.querySelector(notations, 'arpeggiate') : null;
+        const nonArpeggiateEl = notations ? this.querySelector(notations, 'non-arpeggiate') : null;
         if (arpeggiateEl) {
             const dir = arpeggiateEl.getAttribute('direction');
             if (dir === 'up')
@@ -699,8 +1050,13 @@ export class MusicXMLParser {
             else
                 arpeggio = Arpeggio.Normal;
         }
+        else if (nonArpeggiateEl) {
+            arpeggio = Arpeggio.NonArpeggiate;
+        }
         const ornaments = notations ? this.querySelector(notations, 'ornaments') : null;
         let ornament = undefined;
+        let ornamentDetails = undefined;
+        let vibrato = undefined;
         if (ornaments) {
             if (this.querySelector(ornaments, 'trill-mark'))
                 ornament = Ornament.Trill;
@@ -708,12 +1064,85 @@ export class MusicXMLParser {
                 ornament = Ornament.Mordent;
             else if (this.querySelector(ornaments, 'inverted-mordent'))
                 ornament = Ornament.InvertedMordent;
+            else if (this.querySelector(ornaments, 'delayed-turn'))
+                ornament = Ornament.DelayedTurn;
             else if (this.querySelector(ornaments, 'turn'))
                 ornament = Ornament.Turn;
             else if (this.querySelector(ornaments, 'inverted-turn'))
                 ornament = Ornament.InvertedTurn;
-            else if (this.querySelector(ornaments, 'tremolo'))
-                ornament = Ornament.Tremolo;
+            else if (this.querySelector(ornaments, 'tremolo')) {
+                const tremoloEl = this.querySelector(ornaments, 'tremolo');
+                const type = tremoloEl?.getAttribute('type') || 'single';
+                const rawStrokes = parseInt((tremoloEl?.textContent || '3').trim(), 10);
+                const strokes = Number.isFinite(rawStrokes) ? Math.max(1, Math.min(4, rawStrokes)) : 3;
+                if (type === 'start' || type === 'stop' || type === 'continue') {
+                    const measuredMap = {
+                        1: Ornament.TremoloMeasured1,
+                        2: Ornament.TremoloMeasured2,
+                        3: Ornament.TremoloMeasured3,
+                        4: Ornament.TremoloMeasured4,
+                    };
+                    ornament = measuredMap[strokes];
+                }
+                else {
+                    const unmeasuredMap = {
+                        1: Ornament.Tremolo1,
+                        2: Ornament.Tremolo2,
+                        3: Ornament.Tremolo3,
+                        4: Ornament.Tremolo4,
+                    };
+                    ornament = unmeasuredMap[strokes] || Ornament.Tremolo;
+                }
+            }
+            const wavyLineEl = this.querySelector(ornaments, 'wavy-line');
+            if (wavyLineEl) {
+                const typeAttr = wavyLineEl.getAttribute('type');
+                const type = typeAttr === 'start' || typeAttr === 'stop' || typeAttr === 'continue'
+                    ? typeAttr
+                    : undefined;
+                const numberAttr = wavyLineEl.getAttribute('number');
+                const number = numberAttr ? parseInt(numberAttr, 10) : undefined;
+                if (type) {
+                    ornamentDetails = {
+                        ...(ornamentDetails || {}),
+                        wavyLine: {
+                            type,
+                            number: Number.isFinite(number) ? number : undefined,
+                        },
+                    };
+                }
+            }
+            const accidentalMarks = [];
+            this.querySelectorAll(ornaments, 'accidental-mark').forEach((markEl) => {
+                const text = (markEl.textContent || '').trim();
+                let accidental;
+                if (text === 'sharp')
+                    accidental = Accidental.Sharp;
+                else if (text === 'flat')
+                    accidental = Accidental.Flat;
+                else if (text === 'natural')
+                    accidental = Accidental.Natural;
+                else if (text === 'double-sharp')
+                    accidental = Accidental.DoubleSharp;
+                else if (text === 'flat-flat')
+                    accidental = Accidental.DoubleFlat;
+                if (!accidental)
+                    return;
+                const placementAttr = markEl.getAttribute('placement');
+                const placement = placementAttr === 'above' || placementAttr === 'below' ? placementAttr : undefined;
+                accidentalMarks.push({ accidental, placement });
+            });
+            if (this.querySelector(ornaments, 'vibrato')) {
+                const vibEl = this.querySelector(ornaments, 'vibrato');
+                const type = vibEl?.getAttribute('type');
+                vibrato = type === 'start' || type === 'stop' ? type : 'single';
+            }
+            if (accidentalMarks.length > 0) {
+                ornamentDetails = {
+                    ...(ornamentDetails || {}),
+                    accidentalMarks,
+                };
+            }
         }
         const technical = notations ? this.querySelector(notations, 'technical') : null;
         let bowing = undefined;
@@ -724,6 +1153,8 @@ export class MusicXMLParser {
         let palmMute = undefined;
         let hammerOn = undefined;
         let pullOff = undefined;
+        let harmonic = undefined;
+        let bend = undefined;
         if (technical) {
             if (this.querySelector(technical, 'up-bow'))
                 bowing = Bowing.UpBow;
@@ -749,9 +1180,23 @@ export class MusicXMLParser {
             const pullOffEl = this.querySelector(technical, 'pull-off');
             if (pullOffEl)
                 pullOff = pullOffEl.getAttribute('type') || 'start';
+            const harmonicEl = this.querySelector(technical, 'harmonic');
+            if (harmonicEl) {
+                const natural = this.querySelector(harmonicEl, 'natural');
+                harmonic = { type: natural ? HarmonicType.Natural : HarmonicType.Artificial };
+            }
+            const bendEl = this.querySelector(technical, 'bend');
+            if (bendEl) {
+                const alterEl = this.querySelector(bendEl, 'bend-alter');
+                const alter = alterEl ? parseFloat(alterEl.textContent || '0') : 0;
+                const release = this.querySelector(technical, 'release');
+                bend = { alter, release: !!release };
+            }
         }
         let glissando = undefined;
-        const glissEl = notations ? (this.querySelector(notations, 'glissando') || this.querySelector(notations, 'slide')) : null;
+        const glissEl = notations
+            ? this.querySelector(notations, 'glissando') || this.querySelector(notations, 'slide')
+            : null;
         if (glissEl) {
             const type = glissEl.getAttribute('type');
             if (type === 'start' || type === 'stop') {
@@ -775,24 +1220,31 @@ export class MusicXMLParser {
                     text,
                     syllabic: syllabic || undefined,
                     isExtension: extend || undefined,
+                    placement: this.getPlacement(lyricEl),
                 };
             }
         });
         return {
             duration,
             pitch: { midiNumber, step: this.stepToNumber(step), alter, octave },
-            isDotted,
+            dotCount,
             accidental,
+            accidentalDisplay,
             slur,
             tie,
+            tieSpans: dedupedTieSpans.length > 0 ? dedupedTieSpans : undefined,
+            slurs: slurs.length > 0 ? slurs : undefined,
             articulations: articulations.length > 0 ? articulations : undefined,
             dynamic,
             arpeggio,
             lyrics: lyrics.length > 0 ? lyrics : undefined,
             notehead,
             isGrace: isGrace || undefined,
+            isCue: isCue || undefined,
+            grace,
             tuplet,
             ornament,
+            ornamentDetails,
             bowing,
             fingering,
             stemDirection,
@@ -803,6 +1255,10 @@ export class MusicXMLParser {
             palmMute,
             hammerOn,
             pullOff,
+            harmonic,
+            bend,
+            vibrato,
+            placement: this.getPlacement(noteElement),
         };
     }
     parseHarmony(harmonyElement) {
@@ -965,18 +1421,21 @@ export class MusicXMLParser {
             const ending = this.querySelector(barline, 'ending');
             if (ending) {
                 const type = ending.getAttribute('type');
-                const numberAttr = ending.getAttribute('number') || '1';
+                const numberAttr = ending.getAttribute('number');
                 // Handle "1,2" or "1 2"
                 const numbers = numberAttr
-                    .split(/[,\s]+/)
-                    .map((n) => parseInt(n))
-                    .filter((n) => !isNaN(n));
+                    ? numberAttr
+                        .split(/[,\s]+/)
+                        .map((n) => parseInt(n))
+                        .filter((n) => !isNaN(n))
+                    : [];
+                const placement = ending.getAttribute('placement');
                 if (type === 'start')
-                    volta = { type: 'start', numbers };
+                    volta = { type: 'start', numbers, placement: placement || undefined };
                 else if (type === 'stop')
-                    volta = { type: 'stop', numbers };
+                    volta = { type: 'stop', numbers, placement: placement || undefined };
                 else if (type === 'discontinue')
-                    volta = { type: 'both', numbers };
+                    volta = { type: 'both', numbers, placement: placement || undefined };
             }
         });
         return { repeats, volta, barlineStyle };
@@ -1011,8 +1470,17 @@ export class MusicXMLParser {
                                     return;
                                 const step = stepNames[note.pitch.step];
                                 const alter = note.pitch.alter ?? 0;
+                                const hasIncomingTie = (note.tieSpans || []).some((span) => span.placement === 'stop' || span.placement === 'continue');
+                                const isCourtesyAccidental = !!note.accidentalDisplay?.cautionary ||
+                                    !!note.accidentalDisplay?.editorial ||
+                                    !!note.accidentalDisplay?.parenthesized;
+                                if (hasIncomingTie && !isCourtesyAccidental) {
+                                    note.accidental = undefined;
+                                    state[step] = alter;
+                                    return;
+                                }
                                 if (note.accidental) {
-                                    if (state[step] === alter)
+                                    if (state[step] === alter && !isCourtesyAccidental)
                                         note.accidental = undefined;
                                     else
                                         state[step] = alter;
@@ -1090,4 +1558,25 @@ export class MusicXMLParser {
         const text = this.getText(element, tagName);
         return text !== null ? parseFloat(text) : null;
     }
+    getPlacement(element) {
+        const defaultX = element.getAttribute('default-x');
+        const defaultY = element.getAttribute('default-y');
+        const relativeX = element.getAttribute('relative-x');
+        const relativeY = element.getAttribute('relative-y');
+        const placement = element.getAttribute('placement');
+        if (defaultX === null &&
+            defaultY === null &&
+            relativeX === null &&
+            relativeY === null &&
+            placement === null) {
+            return undefined;
+        }
+        return {
+            defaultX: defaultX !== null ? parseFloat(defaultX) : undefined,
+            defaultY: defaultY !== null ? parseFloat(defaultY) : undefined,
+            relativeX: relativeX !== null ? parseFloat(relativeX) : undefined,
+            relativeY: relativeY !== null ? parseFloat(relativeY) : undefined,
+            aboveBelow: placement === 'above' || placement === 'below' ? placement : undefined,
+        };
+    }
 }