@scorelabs/core 1.0.9 → 1.0.10

package/dist/importers/MusicXMLParser.d.ts

@@ -13,12 +13,17 @@ export declare class MusicXMLParser {
     private instrumentPitchMap;
     private _domParser;
     constructor(domParserInstance?: DOMParser | unknown);
+    private querySelector;
+    private getChildren;
+    private getFirstElementChild;
+    private querySelectorAll;
     private parseFromString;
     static getXMLFromBinary(data: ArrayBuffer, domParser?: DOMParser | unknown): Promise<string>;
     parseBinary(data: ArrayBuffer): Promise<ScoreJSON>;
     parse(xmlString: string): ScoreJSON;
     private parseSubtitle;
     private parseTitle;
+    private parseCopyright;
     private parseComposer;
     private parsePartList;
     private parseParts;

package/dist/importers/MusicXMLParser.js

@@ -18,6 +18,52 @@ export class MusicXMLParser {
         this._domParser =
             domParserInstance || (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
     }
+    querySelector(el, selector) {
+        if (el.querySelector)
+            return el.querySelector(selector);
+        const parts = selector.split(' ');
+        let current = el;
+        for (const part of parts) {
+            if (!current)
+                return null;
+            const results = current.getElementsByTagName(part);
+            if (results.length === 0)
+                return null;
+            current = results[0];
+        }
+        return current;
+    }
+    getChildren(el) {
+        const parent = el;
+        if (parent.children)
+            return Array.from(parent.children);
+        return Array.from(el.childNodes).filter((node) => node.nodeType === 1);
+    }
+    getFirstElementChild(el) {
+        if (el.firstElementChild)
+            return el.firstElementChild;
+        const children = this.getChildren(el);
+        return children.length > 0 ? children[0] : null;
+    }
+    querySelectorAll(el, selector) {
+        if (el.querySelectorAll)
+            return Array.from(el.querySelectorAll(selector));
+        const parts = selector.split(' ');
+        if (parts.length === 1) {
+            return Array.from(el.getElementsByTagName(parts[0]));
+        }
+        // Simple nested selector support (only two levels for now as needed)
+        if (parts.length === 2) {
+            const firstLevel = Array.from(el.getElementsByTagName(parts[0]));
+            const results = [];
+            firstLevel.forEach((parent) => {
+                const children = Array.from(parent.getElementsByTagName(parts[1]));
+                results.push(...children);
+            });
+            return results;
+        }
+        return [];
+    }
     parseFromString(xmlString) {
         if (!this._domParser) {
             throw new Error('No DOMParser available. Please provide one in the constructor for Node.js environments.');
@@ -35,7 +81,7 @@ export class MusicXMLParser {
             if (!_parser)
                 throw new Error('No DOMParser available');
             const containerDoc = _parser.parseFromString(containerXml, 'application/xml');
-            const rootfile = containerDoc.querySelector('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');
@@ -63,7 +109,7 @@ export class MusicXMLParser {
         }
         xmlString = xmlString.substring(firstBracket).trim();
         const doc = this.parseFromString(xmlString);
-        const parseError = doc.querySelector('parsererror');
+        const parseError = this.querySelector(doc, 'parsererror');
         if (parseError) {
             const preview = xmlString.substring(0, 100).replace(/\n/g, ' ');
             throw new Error(`XML parsing error: ${parseError.textContent}. Content preview: "${preview}..."`);
@@ -74,6 +120,7 @@ export class MusicXMLParser {
         const title = this.parseTitle(doc);
         const subtitle = this.parseSubtitle(doc);
         const composer = this.parseComposer(doc);
+        const copyright = this.parseCopyright(doc);
         const partInfo = this.parsePartList(doc);
         const parts = this.parseParts(doc, partInfo);
         let globalBpm = 120;
@@ -104,6 +151,7 @@ export class MusicXMLParser {
             tempoDuration: globalTempoDuration,
             tempoIsDotted: globalTempoIsDotted,
             tempoText: globalTempoText,
+            copyright,
         };
         return this.postProcess(score);
     }
@@ -111,7 +159,7 @@ export class MusicXMLParser {
         let subtitle = this.getText(doc.documentElement, 'movement-subtitle');
         if (subtitle)
             return subtitle;
-        const work = doc.querySelector('work');
+        const work = this.querySelector(doc, 'work');
         if (work) {
             subtitle = this.getText(work, 'work-subtitle');
             if (subtitle)
@@ -120,11 +168,11 @@ export class MusicXMLParser {
             if (subtitle)
                 return subtitle;
         }
-        const credits = doc.querySelectorAll('credit');
+        const credits = this.querySelectorAll(doc, 'credit');
         for (const credit of Array.from(credits)) {
-            const type = credit.querySelector('credit-type');
+            const type = this.querySelector(credit, 'credit-type');
             if (type?.textContent?.toLowerCase() === 'subtitle') {
-                const words = credit.querySelector('credit-words');
+                const words = this.querySelector(credit, 'credit-words');
                 if (words?.textContent)
                     return words.textContent;
             }
@@ -137,23 +185,42 @@ export class MusicXMLParser {
             title = this.getText(doc.documentElement, 'movement-title');
         return title ?? 'Untitled';
     }
+    parseCopyright(doc) {
+        const identification = this.querySelector(doc, 'identification');
+        if (identification) {
+            const rights = this.getText(identification, 'rights');
+            if (rights)
+                return rights;
+        }
+        const credits = this.querySelectorAll(doc, 'credit');
+        for (const credit of Array.from(credits)) {
+            const type = this.querySelector(credit, 'credit-type');
+            if (type?.textContent?.toLowerCase() === 'rights' ||
+                type?.textContent?.toLowerCase() === 'copyright') {
+                const words = this.querySelector(credit, 'credit-words');
+                if (words?.textContent)
+                    return words.textContent;
+            }
+        }
+        return '';
+    }
     parseComposer(doc) {
-        const creators = doc.querySelectorAll('identification creator');
+        const creators = this.querySelectorAll(doc, 'identification creator');
         for (const creator of Array.from(creators)) {
             if (creator.getAttribute('type') === 'composer')
                 return creator.textContent ?? 'Unknown';
         }
-        return doc.querySelector('identification creator')?.textContent ?? 'Unknown';
+        return this.querySelector(doc, 'identification creator')?.textContent ?? 'Unknown';
     }
     parsePartList(doc) {
         const partInfo = new Map();
-        const scoreParts = doc.querySelectorAll('part-list score-part');
+        const scoreParts = this.querySelectorAll(doc, 'part-list score-part');
         for (const scorePart of Array.from(scoreParts)) {
             const id = scorePart.getAttribute('id');
             const name = this.getText(scorePart, 'part-name') || 'Part';
             let instrument;
             // Find first midi-instrument to determine main instrument
-            const firstMidiInst = scorePart.querySelector('midi-instrument');
+            const firstMidiInst = this.querySelector(scorePart, 'midi-instrument');
             if (firstMidiInst) {
                 const programStr = this.getText(firstMidiInst, 'midi-program');
                 if (programStr) {
@@ -176,7 +243,7 @@ export class MusicXMLParser {
             if (id) {
                 partInfo.set(id, { name: name.trim(), instrument });
             }
-            const midiInstruments = scorePart.querySelectorAll('midi-instrument');
+            const midiInstruments = this.querySelectorAll(scorePart, 'midi-instrument');
             for (const midiInst of Array.from(midiInstruments)) {
                 const instId = midiInst.getAttribute('id');
                 const unpitched = this.getNumber(midiInst, 'midi-unpitched');
@@ -188,7 +255,7 @@ export class MusicXMLParser {
     }
     parseParts(doc, partInfo) {
         const parts = [];
-        const partElements = doc.querySelectorAll('part');
+        const partElements = this.querySelectorAll(doc, 'part');
         for (const partElement of Array.from(partElements)) {
             const id = partElement.getAttribute('id');
             const info = partInfo.get(id ?? '');
@@ -199,11 +266,11 @@ export class MusicXMLParser {
         return parts;
     }
     parsePart(partElement) {
-        const measureElements = partElement.querySelectorAll('measure');
+        const measureElements = this.querySelectorAll(partElement, 'measure');
         let numStaves = 1;
-        const firstMeasure = partElement.querySelector('measure');
+        const firstMeasure = this.querySelector(partElement, 'measure');
         if (firstMeasure) {
-            const stavesNode = firstMeasure.querySelector('attributes staves');
+            const stavesNode = this.querySelector(firstMeasure, 'attributes staves');
             if (stavesNode)
                 numStaves = parseInt(stavesNode.textContent || '1');
         }
@@ -212,12 +279,17 @@ export class MusicXMLParser {
             measures: [],
         }));
         const staffClefs = Array(numStaves).fill(Clef.Treble);
-        for (const measureElement of Array.from(measureElements)) {
+        const lastVoicePerStaff = new Map();
+        let divisions = 1;
+        for (const [mIdx, measureElement] of Array.from(measureElements).entries()) {
             let measureTimeSignature;
             let measureKeySignature;
-            const isPickup = measureElement.getAttribute('implicit') === 'yes';
-            const attributes = measureElement.querySelector('attributes');
+            let isPickup = measureElement.getAttribute('implicit') === 'yes';
+            const attributes = this.querySelector(measureElement, 'attributes');
             if (attributes) {
+                const divNode = this.querySelector(attributes, 'divisions');
+                if (divNode)
+                    divisions = parseInt(divNode.textContent || '1');
                 const fifths = this.getNumber(attributes, 'key fifths');
                 if (fifths !== null) {
                     this.currentKeyFifths = fifths;
@@ -229,7 +301,7 @@ export class MusicXMLParser {
                     this.currentBeats = beats;
                     if (beatType !== null)
                         this.currentBeatType = beatType;
-                    const timeElement = attributes.querySelector('time');
+                    const timeElement = this.querySelector(attributes, 'time');
                     if (timeElement) {
                         const symAttr = timeElement.getAttribute('symbol');
                         if (symAttr === 'common')
@@ -245,9 +317,10 @@ export class MusicXMLParser {
                         symbol: this.currentSymbol !== 'normal' ? this.currentSymbol : undefined,
                     };
                 }
-                const clefElements = attributes.querySelectorAll('clef');
+                const clefElements = this.querySelectorAll(attributes, 'clef');
                 clefElements.forEach((clef) => {
-                    const number = parseInt(clef.getAttribute('number') || '1');
+                    const numberAttrs = clef.getAttribute('number');
+                    const number = numberAttrs ? parseInt(numberAttrs) : 1;
                     const sign = this.getText(clef, 'sign');
                     if (sign && number <= numStaves) {
                         const line = this.getNumber(clef, 'line') || 0;
@@ -255,7 +328,7 @@ export class MusicXMLParser {
                         staffClefs[number - 1] = this.mapClef(sign, line, octaveChange);
                     }
                 });
-                const staffDetails = attributes.querySelectorAll('staff-details');
+                const staffDetails = this.querySelectorAll(attributes, 'staff-details');
                 staffDetails.forEach((sd) => {
                     const number = parseInt(sd.getAttribute('number') || '1');
                     const lines = this.getNumber(sd, 'staff-lines');
@@ -272,7 +345,7 @@ export class MusicXMLParser {
             const staffVoices = new Map();
             for (let i = 0; i < numStaves; i++)
                 staffVoices.set(i, new Map());
-            const children = Array.from(measureElement.children);
+            const children = this.getChildren(measureElement);
             let pendingChord = undefined;
             let currentNoteSetMap = new Map();
             const beamGroupIdMap = new Map();
@@ -287,24 +360,24 @@ export class MusicXMLParser {
                         pendingChord = harmonyData;
                 }
                 else if (child.nodeName === 'direction') {
-                    const metronome = child.querySelector('metronome');
+                    const metronome = this.querySelector(child, 'metronome');
                     if (metronome) {
                         const beatUnit = this.getText(metronome, 'beat-unit') || 'quarter';
                         const bpm = parseInt(this.getText(metronome, 'per-minute') || '120');
-                        const isDotted = metronome.querySelector('beat-unit-dot') !== null;
+                        const isDotted = this.querySelector(metronome, 'beat-unit-dot') !== null;
                         measureTempo = { bpm, duration: this.mapDuration(beatUnit), isDotted };
                     }
-                    const rehearsal = child.querySelector('rehearsal');
+                    const rehearsal = this.querySelector(child, 'rehearsal');
                     if (rehearsal)
                         rehearsalMark = rehearsal.textContent || undefined;
-                    const words = child.querySelector('words');
+                    const words = this.querySelector(child, 'words');
                     if (words) {
                         if (measureTempo)
                             measureTempo.text = words.textContent || undefined;
                         else
                             systemText = words.textContent || undefined;
                     }
-                    const wedge = child.querySelector('wedge');
+                    const wedge = this.querySelector(child, 'wedge');
                     if (wedge) {
                         const typeAttr = wedge.getAttribute('type');
                         if (typeAttr === 'crescendo' || typeAttr === 'diminuendo' || typeAttr === 'stop') {
@@ -314,7 +387,7 @@ export class MusicXMLParser {
                             };
                         }
                     }
-                    const octShift = child.querySelector('octave-shift');
+                    const octShift = this.querySelector(child, 'octave-shift');
                     if (octShift) {
                         const typeAttr = octShift.getAttribute('type');
                         const size = parseInt(octShift.getAttribute('size') || '8');
@@ -331,25 +404,27 @@ export class MusicXMLParser {
                             };
                         }
                     }
-                    const pedalNode = child.querySelector('pedal');
+                    const pedalNode = this.querySelector(child, 'pedal');
                     if (pedalNode) {
                         const typeAttr = pedalNode.getAttribute('type');
                         if (typeAttr === 'start' || typeAttr === 'stop') {
                             currentPedal = { type: 'sustain', placement: typeAttr };
                         }
                     }
-                    const dynamics = child.querySelector('dynamics');
-                    if (dynamics && dynamics.firstElementChild) {
-                        contextDynamic = dynamics.firstElementChild.nodeName.toLowerCase();
+                    const dynamics = this.querySelector(child, 'dynamics');
+                    if (dynamics) {
+                        const firstChild = this.getFirstElementChild(dynamics);
+                        if (firstChild)
+                            contextDynamic = firstChild.nodeName.toLowerCase();
                     }
                 }
                 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 isChord = child.querySelector('chord') !== null;
+                    const isChord = this.querySelector(child, 'chord') !== null;
                     const note = this.parseNote(child);
                     if (note) {
-                        const beamEl = child.querySelector('beam[number="1"]');
+                        const beamEl = this.querySelector(child, 'beam[number="1"]');
                         if (beamEl) {
                             const beamType = beamEl.textContent;
                             if (beamType === 'begin') {
@@ -389,6 +464,7 @@ export class MusicXMLParser {
                             currentPedal = undefined;
                         }
                         const voiceId = this.getText(child, 'voice') || '1';
+                        lastVoicePerStaff.set(staffIdx, voiceId);
                         const voiceMap = staffVoices.get(staffIdx);
                         if (!voiceMap.has(voiceId))
                             voiceMap.set(voiceId, []);
@@ -411,7 +487,7 @@ export class MusicXMLParser {
                 else if (child.nodeName === 'backup' || child.nodeName === 'forward') {
                     for (const [sIdx, notes] of currentNoteSetMap.entries()) {
                         if (notes.length > 0) {
-                            const voiceId = this.getText(child.previousElementSibling, 'voice') || '1';
+                            const voiceId = lastVoicePerStaff.get(sIdx) || '1';
                             const voiceMap = staffVoices.get(sIdx);
                             if (!voiceMap.has(voiceId))
                                 voiceMap.set(voiceId, []);
@@ -421,16 +497,39 @@ export class MusicXMLParser {
                     currentNoteSetMap.clear();
                 }
             });
+            // Cleanup: push remaining notes
             for (const [sIdx, notes] of currentNoteSetMap.entries()) {
                 if (notes.length > 0) {
-                    // Last note in measure
-                    const voiceId = '1'; // Defaulting to 1 for final push if not tracked
+                    const voiceId = lastVoicePerStaff.get(sIdx) || '1';
                     const voiceMap = staffVoices.get(sIdx);
                     if (!voiceMap.has(voiceId))
                         voiceMap.set(voiceId, []);
                     voiceMap.get(voiceId).push({ notes });
                 }
             }
+            // Check if it's a pickup measure if mIdx is 0 and implicit is not set
+            if (mIdx === 0 && !isPickup) {
+                // Calculate the actual duration of the first staff's first voice
+                const vMap0 = staffVoices.get(0);
+                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);
+                    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.querySelector(n, 'chord'))
+                                continue;
+                            totalMeasureDivs += this.getNumber(n, 'duration') || 0;
+                        }
+                    }
+                    if (totalMeasureDivs > 0 && totalMeasureDivs < expectedDivisions - 1) {
+                        isPickup = true;
+                    }
+                }
+            }
             for (let i = 0; i < numStaves; i++) {
                 const vMap = staffVoices.get(i);
                 let voicesIndices = Array.from(vMap.keys()).sort();
@@ -480,21 +579,21 @@ export class MusicXMLParser {
         return staves;
     }
     parseNote(noteElement) {
-        const isRest = noteElement.querySelector('rest') !== null;
-        const isGrace = noteElement.querySelector('grace') !== null;
+        const isRest = this.querySelector(noteElement, 'rest') !== null;
+        const isGrace = this.querySelector(noteElement, 'grace') !== null;
         const type = this.getText(noteElement, 'type');
         const duration = type ? this.mapDuration(type) : Duration.Quarter;
-        const isDotted = noteElement.querySelector('dot') !== null;
+        const isDotted = this.querySelector(noteElement, 'dot') !== null;
         if (isRest)
             return { duration, isRest: true, isDotted };
         let step = 'C', octave = 4, alter = 0;
-        const unpitched = noteElement.querySelector('unpitched');
+        const unpitched = this.querySelector(noteElement, 'unpitched');
         if (unpitched) {
             step = this.getText(unpitched, 'display-step') || 'C';
             octave = this.getNumber(unpitched, 'display-octave') ?? 4;
         }
         else {
-            const pitch = noteElement.querySelector('pitch');
+            const pitch = this.querySelector(noteElement, 'pitch');
             if (!pitch)
                 return null;
             step = this.getText(pitch, 'step') || 'C';
@@ -502,7 +601,7 @@ export class MusicXMLParser {
             alter = this.getNumber(pitch, 'alter') ?? 0;
         }
         let midiNumber = this.pitchToMidi(step, octave, alter);
-        const instrument = noteElement.querySelector('instrument');
+        const instrument = this.querySelector(noteElement, 'instrument');
         if (instrument) {
             const instId = instrument.getAttribute('id');
             if (instId && this.instrumentPitchMap.has(instId))
@@ -536,17 +635,17 @@ export class MusicXMLParser {
             stemDirection = StemDirection.Up;
         else if (stem === 'down')
             stemDirection = StemDirection.Down;
-        const notations = noteElement.querySelector('notations');
+        const notations = this.querySelector(noteElement, 'notations');
         // Tuplet ratio
         let tuplet = undefined;
-        const timeMod = noteElement.querySelector('time-modification');
+        const timeMod = this.querySelector(noteElement, 'time-modification');
         if (timeMod) {
             const actual = this.getNumber(timeMod, 'actual-notes') || 3;
             const normal = this.getNumber(timeMod, 'normal-notes') || 2;
             tuplet = { actual, normal, type: 'middle' };
         }
         if (notations) {
-            const tupletEl = notations.querySelector('tuplet');
+            const tupletEl = this.querySelector(notations, 'tuplet');
             if (tupletEl && tuplet) {
                 const type = tupletEl.getAttribute('type');
                 if (type === 'start')
@@ -556,7 +655,7 @@ export class MusicXMLParser {
             }
         }
         let slur = undefined;
-        const slurEl = notations?.querySelector('slur');
+        const slurEl = notations ? this.querySelector(notations, 'slur') : null;
         if (slurEl) {
             const type = slurEl.getAttribute('type');
             if (type === 'start' || type === 'stop') {
@@ -568,29 +667,29 @@ export class MusicXMLParser {
                     slur.direction = 'down';
             }
         }
-        const tie = noteElement.querySelector('tie')?.getAttribute('type') === 'start' || undefined;
+        const tie = this.querySelector(noteElement, 'tie')?.getAttribute('type') === 'start' || undefined;
         const articulations = [];
-        const articEl = notations?.querySelector('articulations');
+        const articEl = notations ? this.querySelector(notations, 'articulations') : null;
         if (articEl) {
-            if (articEl.querySelector('staccato'))
+            if (this.querySelector(articEl, 'staccato'))
                 articulations.push(Articulation.Staccato);
-            if (articEl.querySelector('accent'))
+            if (this.querySelector(articEl, 'accent'))
                 articulations.push(Articulation.Accent);
-            if (articEl.querySelector('tenuto'))
+            if (this.querySelector(articEl, 'tenuto'))
                 articulations.push(Articulation.Tenuto);
-            if (articEl.querySelector('marcato'))
+            if (this.querySelector(articEl, 'marcato'))
                 articulations.push(Articulation.Marcato);
-            if (articEl.querySelector('staccatissimo'))
+            if (this.querySelector(articEl, 'staccatissimo'))
                 articulations.push(Articulation.Staccatissimo);
-            if (articEl.querySelector('caesura'))
+            if (this.querySelector(articEl, 'caesura'))
                 articulations.push(Articulation.Caesura);
-            if (articEl.querySelector('breath-mark'))
+            if (this.querySelector(articEl, 'breath-mark'))
                 articulations.push(Articulation.BreathMark);
         }
-        if (notations?.querySelector('fermata'))
+        if (notations && this.querySelector(notations, 'fermata'))
             articulations.push(Articulation.Fermata);
         let arpeggio = undefined;
-        const arpeggiateEl = notations?.querySelector('arpeggiate');
+        const arpeggiateEl = notations ? this.querySelector(notations, 'arpeggiate') : null;
         if (arpeggiateEl) {
             const dir = arpeggiateEl.getAttribute('direction');
             if (dir === 'up')
@@ -600,23 +699,23 @@ export class MusicXMLParser {
             else
                 arpeggio = Arpeggio.Normal;
         }
-        const ornaments = notations?.querySelector('ornaments');
+        const ornaments = notations ? this.querySelector(notations, 'ornaments') : null;
         let ornament = undefined;
         if (ornaments) {
-            if (ornaments.querySelector('trill-mark'))
+            if (this.querySelector(ornaments, 'trill-mark'))
                 ornament = Ornament.Trill;
-            else if (ornaments.querySelector('mordent'))
+            else if (this.querySelector(ornaments, 'mordent'))
                 ornament = Ornament.Mordent;
-            else if (ornaments.querySelector('inverted-mordent'))
+            else if (this.querySelector(ornaments, 'inverted-mordent'))
                 ornament = Ornament.InvertedMordent;
-            else if (ornaments.querySelector('turn'))
+            else if (this.querySelector(ornaments, 'turn'))
                 ornament = Ornament.Turn;
-            else if (ornaments.querySelector('inverted-turn'))
+            else if (this.querySelector(ornaments, 'inverted-turn'))
                 ornament = Ornament.InvertedTurn;
-            else if (ornaments.querySelector('tremolo'))
+            else if (this.querySelector(ornaments, 'tremolo'))
                 ornament = Ornament.Tremolo;
         }
-        const technical = notations?.querySelector('technical');
+        const technical = notations ? this.querySelector(notations, 'technical') : null;
         let bowing = undefined;
         let fingering = undefined;
         let fret = undefined;
@@ -626,33 +725,33 @@ export class MusicXMLParser {
         let hammerOn = undefined;
         let pullOff = undefined;
         if (technical) {
-            if (technical.querySelector('up-bow'))
+            if (this.querySelector(technical, 'up-bow'))
                 bowing = Bowing.UpBow;
-            else if (technical.querySelector('down-bow'))
+            else if (this.querySelector(technical, 'down-bow'))
                 bowing = Bowing.DownBow;
-            const fingeringEl = technical.querySelector('fingering');
+            const fingeringEl = this.querySelector(technical, 'fingering');
             if (fingeringEl)
                 fingering = parseInt(fingeringEl.textContent || '0');
-            const fretEl = technical.querySelector('fret');
+            const fretEl = this.querySelector(technical, 'fret');
             if (fretEl)
                 fret = parseInt(fretEl.textContent || '0');
-            const stringEl = technical.querySelector('string');
+            const stringEl = this.querySelector(technical, 'string');
             if (stringEl) {
                 stringNumber = parseInt(stringEl.textContent || '0');
                 isStringCircled = true;
             }
-            const palmMuteEl = technical.querySelector('palm-mute');
+            const palmMuteEl = this.querySelector(technical, 'palm-mute');
             if (palmMuteEl)
                 palmMute = palmMuteEl.getAttribute('type') || 'start';
-            const hammerOnEl = technical.querySelector('hammer-on');
+            const hammerOnEl = this.querySelector(technical, 'hammer-on');
             if (hammerOnEl)
                 hammerOn = hammerOnEl.getAttribute('type') || 'start';
-            const pullOffEl = technical.querySelector('pull-off');
+            const pullOffEl = this.querySelector(technical, 'pull-off');
             if (pullOffEl)
                 pullOff = pullOffEl.getAttribute('type') || 'start';
         }
         let glissando = undefined;
-        const glissEl = notations?.querySelector('glissando') || notations?.querySelector('slide');
+        const glissEl = notations ? (this.querySelector(notations, 'glissando') || this.querySelector(notations, 'slide')) : null;
         if (glissEl) {
             const type = glissEl.getAttribute('type');
             if (type === 'start' || type === 'stop') {
@@ -662,13 +761,14 @@ export class MusicXMLParser {
                 };
             }
         }
-        const notesDyn = notations?.querySelector('dynamics');
-        const dynamic = notesDyn?.firstElementChild?.nodeName.toLowerCase();
+        const notesDyn = notations ? this.querySelector(notations, 'dynamics') : null;
+        const firstChild = notesDyn ? this.getFirstElementChild(notesDyn) : null;
+        const dynamic = firstChild?.nodeName.toLowerCase();
         const lyrics = [];
-        noteElement.querySelectorAll('lyric').forEach((lyricEl) => {
+        this.querySelectorAll(noteElement, 'lyric').forEach((lyricEl) => {
             const text = this.getText(lyricEl, 'text') || '';
             const syllabic = this.getText(lyricEl, 'syllabic');
-            const extend = lyricEl.querySelector('extend') !== null;
+            const extend = this.querySelector(lyricEl, 'extend') !== null;
             const number = parseInt(lyricEl.getAttribute('number') || '1');
             if (text || extend) {
                 lyrics[number - 1] = {
@@ -706,7 +806,7 @@ export class MusicXMLParser {
         };
     }
     parseHarmony(harmonyElement) {
-        const root = harmonyElement.querySelector('root');
+        const root = this.querySelector(harmonyElement, 'root');
         if (!root)
             return null;
         const step = this.getText(root, 'root-step');
@@ -767,11 +867,11 @@ export class MusicXMLParser {
         }
         // Parse Frame (Fretboard Diagram)
         let diagram = undefined;
-        const frame = harmonyElement.querySelector('frame');
+        const frame = this.querySelector(harmonyElement, 'frame');
         if (frame) {
             diagram = this.parseFrame(frame);
         }
-        const bass = harmonyElement.querySelector('bass');
+        const bass = this.querySelector(harmonyElement, 'bass');
         let bassPart = '';
         if (bass) {
             const bStep = this.getText(bass, 'bass-step');
@@ -796,11 +896,11 @@ export class MusicXMLParser {
         const openStrings = [];
         const mutedStrings = [];
         const openBarres = new Map(); // fret -> startString
-        frame.querySelectorAll('frame-note').forEach((fn) => {
+        this.querySelectorAll(frame, 'frame-note').forEach((fn) => {
             const string = this.getNumber(fn, 'string');
             const fret = this.getNumber(fn, 'fret');
             const fingering = this.getText(fn, 'fingering');
-            const barre = fn.querySelector('barre')?.getAttribute('type'); // start/stop
+            const barre = this.querySelector(fn, 'barre')?.getAttribute('type'); // start/stop
             if (string !== null && fret !== null) {
                 if (fret === 0) {
                     openStrings.push(string);
@@ -842,7 +942,7 @@ export class MusicXMLParser {
         const repeats = [];
         let volta = undefined;
         let barlineStyle = BarlineStyle.Regular;
-        measureElement.querySelectorAll('barline').forEach((barline) => {
+        this.querySelectorAll(measureElement, 'barline').forEach((barline) => {
             const location = barline.getAttribute('location') || 'right';
             const barStyle = this.getText(barline, 'bar-style');
             if (location === 'right') {
@@ -853,7 +953,7 @@ export class MusicXMLParser {
                 else if (barStyle === 'dotted')
                     barlineStyle = BarlineStyle.Dotted;
             }
-            const repeatEl = barline.querySelector('repeat');
+            const repeatEl = this.querySelector(barline, 'repeat');
             if (repeatEl) {
                 const direction = repeatEl.getAttribute('direction');
                 const times = repeatEl.getAttribute('times');
@@ -862,7 +962,7 @@ export class MusicXMLParser {
                     times: times ? parseInt(times) : undefined,
                 });
             }
-            const ending = barline.querySelector('ending');
+            const ending = this.querySelector(barline, 'ending');
             if (ending) {
                 const type = ending.getAttribute('type');
                 const numberAttr = ending.getAttribute('number') || '1';
@@ -983,7 +1083,7 @@ export class MusicXMLParser {
         return map[step.toUpperCase()] ?? 0;
     }
     getText(element, tagName) {
-        const child = element.querySelector(tagName);
+        const child = this.querySelector(element, tagName);
         return child?.textContent ?? null;
     }
     getNumber(element, tagName) {

package/dist/models/Measure.d.ts

@@ -29,7 +29,7 @@ export declare class Measure {
     replaceNoteSet(index: number, newNoteSet: NoteSet, voiceIndex?: number): Measure;
     replaceNote(noteIndex: number, newNote: Note, voiceIndex?: number): Measure;
     deleteNote(noteIndex: number, voiceIndex?: number): Measure;
-    autoBeam(timeSign: TimeSignature): Measure;
+    autoBeam(timeSign?: TimeSignature): Measure;
     withTimeSignature(timeSignature?: TimeSignature): Measure;
     withKeySignature(keySignature?: KeySignature): Measure;
     withClef(clef?: Clef): Measure;
@@ -46,6 +46,8 @@ export declare class Measure {
     withSystemText(text?: string): Measure;
     withBarlineStyle(style: BarlineStyle): Measure;
     fillVoiceWithRests(voiceIndex: number, targetDuration: number): Measure;
+    simplifyRests(voiceIndex?: number): Measure;
+    private decomposeToRests;
     toJSON(): MeasureJSON;
 }
 export interface MeasureJSON {

package/dist/models/Measure.js

@@ -1,6 +1,6 @@
 import { Note } from './Note';
 import { NoteSet } from './NoteSet';
-import { BarlineStyle, DURATION_VALUES, decomposeDuration, } from './types';
+import { BarlineStyle, DURATION_VALUES, Duration, decomposeDuration, } from './types';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -94,7 +94,11 @@ export class Measure {
         }
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = updatedVoice;
-        return this.withVoices(newVoices);
+        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        if (this.timeSignature) {
+            result = result.autoBeam(this.timeSignature);
+        }
+        return result;
     }
     getTotalDuration(voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
@@ -141,10 +145,56 @@ export class Measure {
         const voice = [...this.voices[voiceIndex]];
         if (index >= voice.length)
             return this;
-        voice[index] = newNoteSet;
+        const oldVal = voice[index].getDurationValue();
+        const newVal = newNoteSet.getDurationValue();
+        // Use a copy for modifications
+        const updatedVoice = [...voice];
+        if (Math.abs(oldVal - newVal) < 0.001) {
+            updatedVoice[index] = newNoteSet;
+        }
+        else if (newVal < oldVal) {
+            const gap = oldVal - newVal;
+            updatedVoice[index] = newNoteSet;
+            const rests = this.decomposeToRests(gap);
+            updatedVoice.splice(index + 1, 0, ...rests);
+        }
+        else {
+            const delta = newVal - oldVal;
+            let available = 0;
+            for (let i = index + 1; i < updatedVoice.length; i++) {
+                available += updatedVoice[i].getDurationValue();
+            }
+            // If there's enough space to consume, do it. 
+            // If not, we still replace it but it will overflow (which simplifyRests might fix or layout will handle)
+            updatedVoice[index] = newNoteSet;
+            let consumed = 0;
+            let removeCount = 0;
+            const replacements = [];
+            for (let i = index + 1; i < voice.length; i++) {
+                const ns = voice[i];
+                const val = ns.getDurationValue();
+                if (consumed + val <= delta + 0.001) {
+                    consumed += val;
+                    removeCount++;
+                    if (consumed >= delta - 0.001)
+                        break;
+                }
+                else {
+                    const remaining = consumed + val - delta;
+                    replacements.push(...this.decomposeToRests(remaining));
+                    removeCount++;
+                    break;
+                }
+            }
+            updatedVoice.splice(index + 1, removeCount, ...replacements);
+        }
         const newVoices = [...this.voices];
-        newVoices[voiceIndex] = voice;
-        return this.withVoices(newVoices);
+        newVoices[voiceIndex] = updatedVoice;
+        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        if (this.timeSignature) {
+            result = result.autoBeam(this.timeSignature);
+        }
+        return result;
     }
     replaceNote(noteIndex, newNote, voiceIndex = 0) {
         return this.replaceNoteSet(noteIndex, new NoteSet([newNote]), voiceIndex);
@@ -155,13 +205,20 @@ export class Measure {
         const voice = [...this.voices[voiceIndex]];
         if (noteIndex < 0 || noteIndex >= voice.length)
             return this;
-        voice.splice(noteIndex, 1);
+        // Instead of splicing, replace with a rest of the same duration
+        const target = voice[noteIndex];
+        voice[noteIndex] = target.withRest(true);
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = voice;
-        return this.withVoices(newVoices);
+        return this.withVoices(newVoices).simplifyRests(voiceIndex);
     }
     autoBeam(timeSign) {
+        const ts = timeSign || this.timeSignature;
+        if (!ts)
+            return this;
         const newVoices = this.voices.map((voice) => {
+            if (voice.length === 0)
+                return [];
             let currentOffset = 0;
             let lastGroupId = undefined;
             let lastGroupStartTime = 0;
@@ -171,28 +228,38 @@ export class Measure {
                 const noteDuration = ns.getDurationValue();
                 let groupToAssign = undefined;
                 if (ns.isBeamable()) {
-                    const isSixteenth = noteDuration < 0.5;
-                    let currentBeatLength = 4 / timeSign.beatType;
-                    if (timeSign.beatType === 8 && timeSign.beats % 3 === 0) {
-                        currentBeatLength = 1.5;
-                    }
-                    else if (timeSign.beatType === 4 && (timeSign.beats === 4 || timeSign.beats === 2)) {
-                        currentBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
+                    const isSixteenth = noteDuration < 0.5 - 0.001;
+                    // Determine the logical "beat length" for beaming purposes
+                    let beamBeatLength = 4 / ts.beatType; // Default is one beat
+                    if (ts.beatType === 4) {
+                        if (ts.beats === 4 || ts.beats === 2) {
+                            // In 4/4 or 2/4, eighth notes are often beamed in groups of 2 beats (length 2.0)
+                            // unless there are sixteenth notes which force 1-beat groupings.
+                            beamBeatLength = (lastGroupHasSixteenths || isSixteenth) ? 1.0 : 2.0;
+                        }
                     }
-                    else if (timeSign.beatType === 2 && timeSign.beats === 2) {
-                        currentBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
+                    else if (ts.beatType === 8) {
+                        if (ts.beats % 3 === 0) {
+                            // Compound meter (6/8, 9/8, 12/8): Beam by 3 eighth notes (1.5 length)
+                            beamBeatLength = 1.5;
+                        }
+                        else {
+                            // Simple meter in 8 (e.g. 2/8, 4/8): Beam by quarter note (1.0 length)
+                            beamBeatLength = 1.0;
+                        }
                     }
-                    const currentBeatId = Math.floor(currentOffset / currentBeatLength + 0.001);
+                    const currentBeatId = Math.floor(currentOffset / beamBeatLength + 0.001);
                     const endOffset = currentOffset + noteDuration;
-                    const crossesBeat = Math.floor(endOffset / currentBeatLength - 0.001) !== currentBeatId;
+                    const crossesBeat = Math.floor(endOffset / beamBeatLength - 0.001) !== currentBeatId;
                     const sameBeatAsLast = lastGroupId !== undefined &&
-                        Math.floor(lastGroupStartTime / currentBeatLength + 0.001) === currentBeatId;
+                        Math.floor(lastGroupStartTime / beamBeatLength + 0.001) === currentBeatId;
                     if (sameBeatAsLast && !crossesBeat) {
                         groupToAssign = lastGroupId;
                         if (isSixteenth)
                             lastGroupHasSixteenths = true;
                     }
                     else {
+                        // Start a new group
                         lastGroupId = Math.floor(Math.random() * 1000000) + 1;
                         lastGroupStartTime = currentOffset;
                         lastGroupHasSixteenths = isSixteenth;
@@ -200,12 +267,14 @@ export class Measure {
                     }
                 }
                 else {
+                    // Non-beamable note (Quarter, Half, etc.) or Rest
                     lastGroupId = undefined;
                     lastGroupHasSixteenths = false;
                 }
                 tempNoteSets.push(ns.withBeamGroup(groupToAssign));
                 currentOffset += noteDuration;
             }
+            // Cleanup: groups of 1 note are not beamed
             const groupCounts = new Map();
             for (const ns of tempNoteSets) {
                 if (ns.beamGroup !== undefined) {
@@ -294,6 +363,44 @@ export class Measure {
         }
         return this.withVoices(newVoices);
     }
+    simplifyRests(voiceIndex = 0) {
+        const voice = this.voices[voiceIndex];
+        if (!voice || voice.length === 0)
+            return this;
+        const totalDur = this.getTotalDuration(voiceIndex);
+        const expectedDur = this.timeSignature ? (this.timeSignature.beats * 4) / this.timeSignature.beatType : 4.0;
+        // Special Case: If the whole measure is rests, just return a single whole rest (or appropriate duration)
+        const allRests = voice.every(ns => ns.isRest);
+        if (allRests && Math.abs(totalDur - expectedDur) < 0.001) {
+            const newVoice = [new NoteSet([new Note(Duration.Whole, undefined, true)])];
+            const newVoices = [...this.voices];
+            newVoices[voiceIndex] = newVoice;
+            return this.withVoices(newVoices);
+        }
+        const newVoice = [];
+        let currentRestSum = 0;
+        for (const ns of voice) {
+            if (ns.isRest) {
+                currentRestSum += ns.getDurationValue();
+            }
+            else {
+                if (currentRestSum > 0.001) {
+                    newVoice.push(...this.decomposeToRests(currentRestSum));
+                    currentRestSum = 0;
+                }
+                newVoice.push(ns);
+            }
+        }
+        if (currentRestSum > 0.001) {
+            newVoice.push(...this.decomposeToRests(currentRestSum));
+        }
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = newVoice;
+        return this.withVoices(newVoices);
+    }
+    decomposeToRests(value) {
+        return decomposeDuration(value).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+    }
     toJSON() {
         return {
             voices: this.voices.map((v) => v.map((ns) => ns.toJSON())),

package/dist/models/Note.d.ts

@@ -17,7 +17,7 @@ export declare class Note {
     readonly tuplet?: Tuplet | undefined;
     readonly hairpin?: Hairpin | undefined;
     readonly isGrace: boolean;
-    readonly lyric?: string | undefined;
+    readonly lyric?: Lyric | undefined;
     readonly chord?: string | undefined;
     readonly glissando?: Glissando | undefined;
     readonly arpeggio?: Arpeggio | undefined;
@@ -27,7 +27,7 @@ export declare class Note {
     readonly fret?: number | undefined;
     readonly string?: number | undefined;
     readonly fretboardDiagram?: FretboardDiagram | undefined;
-    readonly lyrics?: (string | Lyric)[] | undefined;
+    readonly lyrics?: Lyric[] | undefined;
     readonly staffText?: string | undefined;
     readonly color?: string | undefined;
     readonly notehead?: NoteheadShape | undefined;
@@ -40,7 +40,7 @@ export declare class Note {
     readonly pullOff?: "start" | "stop" | undefined;
     constructor(duration: Duration, pitch?: Pitch | undefined, // undefined for rests
     isRest?: boolean, isDotted?: boolean, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
-    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: string | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: (string | Lyric)[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined);
+    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: Lyric | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: Lyric[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined);
     /**
      * Get all lyrics as standardized objects
      */
@@ -70,8 +70,8 @@ export declare class Note {
     withTie(tie?: boolean): Note;
     withSlur(slur?: Slur): Note;
     withTuplet(tuplet?: Tuplet): Note;
-    withLyric(lyric?: string): Note;
-    withLyrics(lyrics: (string | Lyric)[]): Note;
+    withLyric(lyric?: Lyric): Note;
+    withLyrics(lyrics: Lyric[]): Note;
     withHairpin(hairpin?: Hairpin): Note;
     withAccidental(accidental?: Accidental): Note;
     withDuration(duration: Duration, isDotted?: boolean): Note;
@@ -117,7 +117,7 @@ export interface NoteJSON {
     tuplet?: Tuplet;
     hairpin?: Hairpin;
     isGrace?: boolean;
-    lyric?: string;
+    lyric?: Lyric;
     chord?: string;
     glissando?: Glissando;
     arpeggio?: Arpeggio;
@@ -127,7 +127,7 @@ export interface NoteJSON {
     fret?: number;
     string?: number;
     fretboardDiagram?: FretboardDiagram;
-    lyrics?: (string | Lyric)[];
+    lyrics?: Lyric[];
     staffText?: string;
     color?: string;
     notehead?: string;

package/dist/models/Note.js

@@ -81,10 +81,10 @@ export class Note {
      */
     get allLyrics() {
         if (this.lyrics) {
-            return this.lyrics.map((l) => (typeof l === 'string' ? { text: l } : l));
+            return this.lyrics;
         }
         if (this.lyric) {
-            return [{ text: this.lyric }];
+            return [this.lyric];
         }
         return [];
     }

package/dist/models/NoteSet.d.ts

@@ -14,7 +14,7 @@ export declare class NoteSet {
     withDuration(duration: Duration, isDotted?: boolean): NoteSet;
     withBeamGroup(group?: number): NoteSet;
     withNotes(notes: Note[]): NoteSet;
-    withLyrics(lyrics: (string | Lyric)[]): NoteSet;
+    withLyrics(lyrics: Lyric[]): NoteSet;
     withTuplet(tuplet?: Tuplet): NoteSet;
     withPitch(pitch: Pitch): NoteSet;
     withAccidental(accidental?: Accidental): NoteSet;
@@ -45,14 +45,14 @@ export declare class NoteSet {
     withPalmMute(type?: 'start' | 'stop'): NoteSet;
     withStringCircled(isStringCircled?: boolean): NoteSet;
     withStemDirection(dir?: StemDirection): NoteSet;
-    withLyric(lyric?: string): NoteSet;
+    withLyric(lyric?: Lyric): NoteSet;
     withStaffText(text?: string): NoteSet;
     withFretboardDiagram(diagram?: FretboardDiagram): NoteSet;
     get pitch(): Pitch | undefined;
     get accidental(): Accidental | undefined;
     get tie(): boolean | undefined;
     get slur(): Slur | undefined;
-    get articulations(): Articulation[];
+    get articulations(): Articulation[] | undefined;
     get articulation(): Articulation | undefined;
     get ornament(): Ornament | undefined;
     get dynamic(): Dynamic | undefined;
@@ -68,14 +68,14 @@ export declare class NoteSet {
     get bowing(): Bowing | undefined;
     get fingering(): number | undefined;
     get allLyrics(): Lyric[];
-    get lyrics(): (string | Lyric)[] | undefined;
-    get lyric(): string | undefined;
+    get lyrics(): Lyric[] | undefined;
+    get lyric(): Lyric | undefined;
     get chord(): string | undefined;
     get fretboardDiagram(): FretboardDiagram | undefined;
     get staffText(): string | undefined;
-    get hammerOn(): "start" | "stop" | undefined;
-    get pullOff(): "start" | "stop" | undefined;
-    get palmMute(): "start" | "stop" | undefined;
+    get hammerOn(): 'start' | 'stop' | undefined;
+    get pullOff(): 'start' | 'stop' | undefined;
+    get palmMute(): 'start' | 'stop' | undefined;
     get isStringCircled(): boolean | undefined;
     get stemDirection(): StemDirection | undefined;
     toJSON(): NoteSetJSON;

package/dist/models/Score.d.ts

@@ -19,13 +19,13 @@ export declare class Score {
     readonly lyricist: string;
     readonly swing: boolean;
     readonly subtitle: string;
-    readonly genre: Genre | string;
+    readonly genre: Genre;
     readonly tempoText: string;
-    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre | string, tempoText?: string);
+    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre, tempoText?: string);
     withTitle(title: string): Score;
     withComposer(composer: string): Score;
     withSubtitle(subtitle: string): Score;
-    withGenre(genre: Genre | string): Score;
+    withGenre(genre: Genre): Score;
     getMeasureCount(): number;
     getTimeSignatureAt(measureIndex: number): TimeSignature;
     getKeySignatureAt(measureIndex: number): KeySignature;
@@ -85,6 +85,6 @@ export interface ScoreJSON {
     lyricist?: string;
     swing?: boolean;
     subtitle?: string;
-    genre?: Genre | string;
+    genre?: Genre;
     tempoText?: string;
 }

package/dist/types/User.d.ts

@@ -0,0 +1,21 @@
+/**
+ * WARNING: DO NOT ADD SENSITIVE LOGIC OR PRIVATE CONSTANTS TO THIS FILE.
+ * This package (@scorelabs/core) is used in public-facing frontend applications
+ * and could be exposed. Keep all token generation, verification, and encryption
+ * logic in the 'backend' or 'website' utilities.
+ */
+export type UserTier = 'free' | 'premium';
+export interface UserData {
+    accessToken?: string;
+    access_token?: string;
+    uuid?: string | number;
+    name?: string;
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    email?: string;
+    is_admin?: number | boolean;
+    id?: string | number;
+    tier?: UserTier | string;
+    picture?: string;
+}

package/dist/types/User.js

@@ -0,0 +1,7 @@
+/**
+ * WARNING: DO NOT ADD SENSITIVE LOGIC OR PRIVATE CONSTANTS TO THIS FILE.
+ * This package (@scorelabs/core) is used in public-facing frontend applications
+ * and could be exposed. Keep all token generation, verification, and encryption
+ * logic in the 'backend' or 'website' utilities.
+ */
+export {};

package/dist/types/index.d.ts

@@ -24,3 +24,4 @@ export * from './Pedal.js';
 export * from './Slur.js';
 export * from './Tuplet.js';
 export * from './Repeat.js';
+export * from './User.js';

package/dist/types/index.js

@@ -24,3 +24,4 @@ export * from './Pedal.js';
 export * from './Slur.js';
 export * from './Tuplet.js';
 export * from './Repeat.js';
+export * from './User.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scorelabs/core",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Core logic and models for ScoreLabs music notation",
   "type": "module",
   "files": [
@@ -24,6 +24,7 @@
     "release:major": "npm version major && npm publish --access public",
     "release": "npm run release:patch",
     "test": "vitest",
+    "test:coverage": "vitest run --coverage",
     "lint": "eslint ."
   },
   "dependencies": {
@@ -32,6 +33,7 @@
   "devDependencies": {
     "@types/jszip": "^3.4.0",
     "@types/node": "^25.2.3",
+    "@vitest/coverage-v8": "^4.0.18",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   }