@k-l-lambda/lilylet 0.1.75 → 0.1.78

package/lib/lilylet/musicXmlDecoder.js

@@ -5,7 +5,7 @@
  * Improves upon musicxml2ly by properly tracking spanners (slurs, ties, wedges) by number attribute.
  */
 import { DOMParser } from '@xmldom/xmldom';
-import { HairpinType, NavigationMarkType, Placement, } from "./types.js";
+import { HairpinType, NavigationMarkType, OrnamentType, Placement, } from "./types.js";
 import { getElementText, getElementInt, getElements, getDirectChildren, getChildElements, getAttribute, getAttributeNumber, hasElement, convertPitch, convertDuration, convertKeySignature, convertClef, convertStemDirection, convertArticulation, convertOrnament, convertDynamic, convertPedal, convertBarlineStyle, convertHarmonyToText, createFraction, TYPE_TO_DIVISION, } from "./musicXmlUtils.js";
 import { measureLayoutFromPart } from "./measureLayoutFromXml.js";
 // ============ Spanner Tracker ============
@@ -197,12 +197,13 @@ class VoiceTracker {
             });
             this.currentStaff.set(voiceNum, staff);
         }
-        const voice = this.voices.get(voiceNum);
-        // Update staff if specified
-        if (staff > 0) {
-            voice.staff = staff;
-        }
-        return voice;
+        // NOTE: do NOT overwrite voice.staff on later notes. voice.staff is the voice's
+        // HOME staff — the staff of its first note — matching the parser, which fixes
+        // voice.staff to the first leading \staff (so `\staff "1" … \staff "2" …` gives
+        // voice.staff=1, with the switch carried by an inline ctx(staff=2) event). The
+        // previous code clobbered it to every note's staff, so a voice that ended on a
+        // different staff round-tripped with the wrong home staff.
+        return this.voices.get(voiceNum);
     }
     addEvent(voiceNum, event, duration, staff = 1) {
         const voice = this.getOrCreateVoice(voiceNum, staff);
@@ -303,9 +304,11 @@ const parseNotations = (notationsEl) => {
             result.ornaments = ornaments;
         }
     }
-    // Fermata
-    if (hasElement(notationsEl, 'fermata')) {
-        result.fermata = true;
+    // Fermata. The "angled" shape is LilyPond's \shortfermata; everything else
+    // (normal/square/unset) is the ordinary \fermata.
+    const fermataEl = getElements(notationsEl, 'fermata')[0];
+    if (fermataEl) {
+        result.fermata = (fermataEl.textContent || '').trim() === 'angled' ? 'short' : 'normal';
     }
     // Arpeggiate
     if (hasElement(notationsEl, 'arpeggiate')) {
@@ -326,6 +329,13 @@ const parseNotations = (notationsEl) => {
             number: getAttributeNumber(tupletEl, 'number') || 1,
         };
     }
+    // Glissando / slide — both are note-to-note slide lines. Only the START note
+    // carries the mark (LilyPond \glissando auto-connects to the next note), so we
+    // record presence of any start; stops are ignored.
+    const slideEls = [...getElements(notationsEl, 'glissando'), ...getElements(notationsEl, 'slide')];
+    if (slideEls.some(el => getAttribute(el, 'type') === 'start')) {
+        result.glissando = true;
+    }
     return result;
 };
 /**
@@ -570,6 +580,17 @@ const parseDirection = (dirEl) => {
     if (hasElement(dirTypeEl, 'segno')) {
         result.segno = true;
     }
+    // Rehearsal mark (<direction-type><rehearsal>A</rehearsal>). May be split into
+    // multiple <rehearsal> (e.g. "A" + a Chinese gloss "段"); join them. Collected
+    // from the whole direction so it is found regardless of which direction-type it
+    // sits in. Surfaced as text → markup by directionToMarks (per the text-as-markup
+    // convention; LilyPond's musicxml2ly emits \mark \markup { \box { … } }).
+    const rehearsalEls = Array.from(dirEl.getElementsByTagName('rehearsal'));
+    if (rehearsalEls.length > 0) {
+        const text = rehearsalEls.map(el => el.textContent?.trim() || '').filter(Boolean).join(' ');
+        if (text)
+            result.rehearsal = text;
+    }
     return result;
 };
 /**
@@ -640,6 +661,23 @@ const parseMetadata = (doc) => {
     if (movementTitleEl?.textContent && !metadata.title) {
         metadata.title = movementTitleEl.textContent.trim();
     }
+    // Subtitle: MusicXML has no <subtitle> element — it lives in a page <credit>
+    // tagged <credit-type>subtitle</credit-type>, with the text in <credit-words>.
+    const creditEls = doc.getElementsByTagName('credit');
+    for (let i = 0; i < creditEls.length; i++) {
+        const credit = creditEls[i];
+        const typeEl = credit.getElementsByTagName('credit-type')[0];
+        if (typeEl?.textContent?.trim().toLowerCase() === 'subtitle') {
+            const words = Array.from(credit.getElementsByTagName('credit-words'))
+                .map(w => w.textContent?.trim() || '')
+                .filter(Boolean)
+                .join(' ');
+            if (words) {
+                metadata.subtitle = words;
+                break;
+            }
+        }
+    }
     // Identification (composer, arranger, lyricist)
     const identificationEl = doc.getElementsByTagName('identification')[0];
     if (identificationEl) {
@@ -711,6 +749,12 @@ const notationsToMarks = (notations, spannerTracker, pitches) => {
     // Articulations
     if (notations.articulations) {
         for (const artName of notations.articulations) {
+            // breath-mark is a NoDirection articulation in MusicXML but maps to
+            // LilyPond's \breathe — model it as the breath ornament.
+            if (artName === 'breath-mark') {
+                marks.push({ markType: 'ornament', type: OrnamentType.breath });
+                continue;
+            }
             const artType = convertArticulation(artName);
             if (artType) {
                 marks.push({ markType: 'articulation', type: artType });
@@ -728,12 +772,16 @@ const notationsToMarks = (notations, spannerTracker, pitches) => {
     }
     // Fermata
     if (notations.fermata) {
-        marks.push({ markType: 'ornament', type: 'fermata' });
+        marks.push({ markType: 'ornament', type: (notations.fermata === 'short' ? 'shortFermata' : 'fermata') });
     }
     // Arpeggiate
     if (notations.arpeggiate) {
         marks.push({ markType: 'ornament', type: 'arpeggio' });
     }
+    // Glissando / slide (start note only)
+    if (notations.glissando) {
+        marks.push({ markType: 'glissando' });
+    }
     return marks;
 };
 // Common tempo words that should be converted to \tempo
@@ -887,16 +935,30 @@ const directionToMarks = (direction, spannerTracker) => {
     if (direction.segno) {
         marks.push({ markType: 'navigation', type: NavigationMarkType.segno });
     }
+    // Rehearsal mark → markup (text-as-markup convention; LilyPond uses \mark).
+    if (direction.rehearsal) {
+        const placement = direction.placement === 'above' ? Placement.above
+            : direction.placement === 'below' ? Placement.below
+                : undefined;
+        marks.push({ markType: 'markup', content: direction.rehearsal, placement });
+    }
     // Words (text directions: "dolce", "espr.", "cresc.", "con forza", ...).
     // Tempo words ("Allegro", "a tempo", ...) are consumed separately as a tempo
-    // ContextChange by directionToContextChange, so skip those here to avoid
-    // double-emitting; everything else becomes a markup mark → MEI <dir>. Metronome
-    // directions are tempo too, never markup. Navigation text ("D.C. al Fine",
-    // "To Coda", "Fine", "D.S. al Coda") is NOT a tempo word, so it flows here as a
-    // markup glyph — the jump SEMANTICS are captured separately as measure-layout.
+    // ContextChange by directionToContextChange (which takes words[0]), so skip that
+    // one here to avoid double-emitting; the REST become a markup mark → MEI <dir>.
+    // A single <direction> often carries a tempo word AND an expressive/translation
+    // word together (e.g. <words>Moderato</words><words>中板</words>) — only the tempo
+    // word is consumed; the rest must still surface as markup. Metronome directions
+    // are tempo too, never markup. Navigation text ("D.C. al Fine", "To Coda",
+    // "Fine", "D.S. al Coda") is NOT a tempo word, so it flows here as a markup glyph
+    // — the jump SEMANTICS are captured separately as measure-layout.
     let emittedWords = false;
     if (direction.words && direction.words.length > 0 && !direction.metronome) {
-        const text = direction.words.map(w => w.text).join('').trim();
+        // If words[0] was consumed as the tempo text, drop it and keep the remainder;
+        // otherwise the whole run is one expressive phrase, joined as today.
+        const firstIsTempo = isTempoWord(direction.words[0].text.trim());
+        const rest = firstIsTempo ? direction.words.slice(1) : direction.words;
+        const text = rest.map(w => w.text).join('').trim();
         if (text && !isTempoWord(text)) {
             const placement = direction.placement === 'above' ? Placement.above
                 : direction.placement === 'below' ? Placement.below
@@ -1107,8 +1169,16 @@ const convertMeasure = (measureEl, voiceTracker, spannerTracker, ottavaTracker,
             // hairpin stop that lands just before a rest (common in piano scores:
             // `<pedal stop/>` followed by rests filling the voice) is silently dropped.
             const marks = note.isRest ? [] : (pendingMarks.get(voiceNum) || []);
-            if (!note.isRest)
+            if (!note.isRest) {
                 pendingMarks.delete(voiceNum);
+                // Drain directions that named this note's staff but had no known voice
+                // yet (queued under the -staff placeholder key by the <direction> handler).
+                const staffPending = pendingMarks.get(-staffNum);
+                if (staffPending && staffPending.length > 0) {
+                    marks.push(...staffPending);
+                    pendingMarks.delete(-staffNum);
+                }
+            }
             if (note.isRest) {
                 // Rest event
                 const duration = convertDuration(voiceTracker.getDivisions(), note.duration.divisions, note.duration.type, note.duration.dots, note.duration.timeModification);
@@ -1126,7 +1196,7 @@ const convertMeasure = (measureEl, voiceTracker, spannerTracker, ottavaTracker,
                 // so the encoder can emit <fermata startid="#rest">; without this the
                 // 3-of-4 fermatas that sit on rests in typical piano scores are lost.
                 if (note.notations?.fermata) {
-                    restEvent.marks = [{ markType: 'ornament', type: 'fermata' }];
+                    restEvent.marks = [{ markType: 'ornament', type: (note.notations.fermata === 'short' ? 'shortFermata' : 'fermata') }];
                 }
                 // Grace notes don't advance time
                 const advanceDuration = note.isGrace ? 0 : note.duration.divisions;
@@ -1225,9 +1295,17 @@ const convertMeasure = (measureEl, voiceTracker, spannerTracker, ottavaTracker,
             // Handle marks (dynamics, hairpins, etc.)
             const marks = directionToMarks(direction, spannerTracker);
             if (marks.length > 0) {
-                // Store marks to attach to next note in current voice
-                const existing = pendingMarks.get(currentVoice) || [];
-                pendingMarks.set(currentVoice, [...existing, ...marks]);
+                // Route to the voice the marks belong to. A <direction> in a grand-staff
+                // part names its <staff>; the matching note is the NEXT note on that staff
+                // — NOT currentVoice, which after a <backup> still points at the voice that
+                // just ended (so a staff-2 direction emitted after the backup would wrongly
+                // land on staff 1). Queue under a -staff placeholder key; the next note on
+                // that staff drains it, and the end-of-measure flush falls back to that
+                // staff's last note if no further note appears. Without a staff (single-
+                // staff parts), fall back to currentVoice as before.
+                const targetKey = direction.staff ? -direction.staff : currentVoice;
+                const existing = pendingMarks.get(targetKey) || [];
+                pendingMarks.set(targetKey, [...existing, ...marks]);
             }
         }
         else if (tagName === 'backup') {
@@ -1303,11 +1381,28 @@ const convertMeasure = (measureEl, voiceTracker, spannerTracker, ottavaTracker,
             }
             return undefined;
         };
+        // A staff-keyed leftover (negative key = -staffNum, queued for a "next note on
+        // this staff" that never came): resolve to the last note on any voice that lives
+        // on that staff.
+        const findLastNoteOnStaff = (staff) => {
+            let best;
+            for (const [, vs] of allVoices) {
+                if ((vs.staff || 1) !== staff)
+                    continue;
+                for (let i = vs.events.length - 1; i >= 0; i--) {
+                    if (vs.events[i].type === 'note') {
+                        best = vs.events[i];
+                        break;
+                    }
+                }
+            }
+            return best;
+        };
         for (const [voiceNum, marks] of pendingMarks) {
             if (marks.length === 0)
                 continue;
-            let target = findLastNote(voiceNum);
-            // Voice had no note (e.g. direction-only or rest-only): attach to the
+            let target = voiceNum < 0 ? findLastNoteOnStaff(-voiceNum) : findLastNote(voiceNum);
+            // Voice/staff had no note (e.g. direction-only or rest-only): attach to the
             // last note of any voice so the marking is not silently dropped.
             if (!target) {
                 for (const vn of allVoices.keys()) {

package/lib/lilylet/musicXmlEncoder.js

@@ -4,7 +4,7 @@
  * Converts LilyletDoc to MusicXML format.
  * Produces valid MusicXML 4.0 partwise documents.
  */
-import { StemDirection, Accidental, HairpinType, PedalType, } from "./types.js";
+import { StemDirection, Accidental, HairpinType, PedalType, NavigationMarkType, } from "./types.js";
 import { DIVISIONS, DIVISION_TO_TYPE, calculateDuration, } from "./musicXmlUtils.js";
 import { parseStaffLayout } from "./staffLayout.js";
 // === Constants and Reverse Mappings ===
@@ -78,6 +78,7 @@ const DYNAMIC_TO_XML = {
     fff: 'fff',
     sfz: 'sfz',
     rfz: 'rfz',
+    fp: 'fp',
 };
 // Barline style to MusicXML
 const BARLINE_TO_XML = {
@@ -202,6 +203,7 @@ const encodeAttributes = (level, options) => {
 const encodeNotations = (marks, level) => {
     const articulations = [];
     const ornaments = [];
+    const technical = [];
     const otherNotations = [];
     for (const mark of marks) {
         switch (mark.markType) {
@@ -212,17 +214,25 @@ const encodeNotations = (marks, level) => {
                 }
                 break;
             case 'ornament':
-                const ornXml = ORNAMENT_TO_XML[mark.type];
-                if (ornXml) {
-                    if (mark.type === 'fermata') {
-                        otherNotations.push('<fermata/>');
-                    }
-                    else if (mark.type === 'arpeggio') {
-                        otherNotations.push('<arpeggiate/>');
-                    }
-                    else {
+                // fermata / arpeggio live at the <notations> level; breath-mark is an
+                // <articulations> child; the rest are true <ornaments>. (shortFermata is
+                // a fermata with an "angled" shape — decoder maps it back.)
+                if (mark.type === 'fermata') {
+                    otherNotations.push('<fermata/>');
+                }
+                else if (mark.type === 'shortFermata') {
+                    otherNotations.push('<fermata>angled</fermata>');
+                }
+                else if (mark.type === 'arpeggio') {
+                    otherNotations.push('<arpeggiate/>');
+                }
+                else if (mark.type === 'breath') {
+                    articulations.push('<breath-mark/>');
+                }
+                else {
+                    const ornXml = ORNAMENT_TO_XML[mark.type];
+                    if (ornXml)
                         ornaments.push(`<${ornXml}/>`);
-                    }
                 }
                 break;
             case 'tie':
@@ -234,12 +244,18 @@ const encodeNotations = (marks, level) => {
             case 'tuplet':
                 otherNotations.push(`<tuplet type="${mark.start ? 'start' : 'stop'}"/>`);
                 break;
+            case 'glissando':
+                // Lilylet \glissando is start-only (the line auto-connects to the next
+                // note); emit just the start spanner so the decoder reads it back.
+                otherNotations.push('<glissando type="start" number="1"/>');
+                break;
             case 'fingering':
-                // Fingering goes in technical
+                technical.push(`<fingering>${mark.finger}</fingering>`);
                 break;
         }
     }
-    if (articulations.length === 0 && ornaments.length === 0 && otherNotations.length === 0) {
+    if (articulations.length === 0 && ornaments.length === 0 &&
+        technical.length === 0 && otherNotations.length === 0) {
         return '';
     }
     let xml = `${indent(level)}<notations>\n`;
@@ -260,6 +276,13 @@ const encodeNotations = (marks, level) => {
         }
         xml += `${indent(level + 1)}</ornaments>\n`;
     }
+    if (technical.length > 0) {
+        xml += `${indent(level + 1)}<technical>\n`;
+        for (const tech of technical) {
+            xml += `${indent(level + 2)}${tech}\n`;
+        }
+        xml += `${indent(level + 1)}</technical>\n`;
+    }
     xml += `${indent(level)}</notations>\n`;
     return xml;
 };
@@ -369,8 +392,14 @@ const encodeRestWithTuplet = (event, voice, staff, level, isFirst, isLast) => {
 /**
  * Encode direction element (dynamics, tempo, etc.)
  */
-const encodeDirection = (marks, level) => {
+const encodeDirection = (marks, level, staff = 0, emitStaff = false) => {
     let xml = '';
+    // In a grand-staff part, a <direction> must name its <staff> or the decoder
+    // can't route the mark back to the right staff (it would attach to the current
+    // voice/staff and drift — observed on chopin dynamics and cross-measure pedals).
+    const staffTag = (emitStaff && staff > 0)
+        ? `${indent(level + 1)}<staff>${staff}</staff>\n`
+        : '';
     for (const mark of marks) {
         if (mark.markType === 'dynamic') {
             const dynXml = DYNAMIC_TO_XML[mark.type];
@@ -381,6 +410,7 @@ const encodeDirection = (marks, level) => {
                 xml += `${indent(level + 3)}<${dynXml}/>\n`;
                 xml += `${indent(level + 2)}</dynamics>\n`;
                 xml += `${indent(level + 1)}</direction-type>\n`;
+                xml += staffTag;
                 xml += `${indent(level)}</direction>\n`;
             }
         }
@@ -400,6 +430,7 @@ const encodeDirection = (marks, level) => {
                 xml += `${indent(level + 1)}<direction-type>\n`;
                 xml += `${indent(level + 2)}<wedge type="${wedgeType}"/>\n`;
                 xml += `${indent(level + 1)}</direction-type>\n`;
+                xml += staffTag;
                 xml += `${indent(level)}</direction>\n`;
             }
         }
@@ -416,9 +447,31 @@ const encodeDirection = (marks, level) => {
                 xml += `${indent(level + 1)}<direction-type>\n`;
                 xml += `${indent(level + 2)}<pedal type="${pedalType}"/>\n`;
                 xml += `${indent(level + 1)}</direction-type>\n`;
+                xml += staffTag;
                 xml += `${indent(level)}</direction>\n`;
             }
         }
+        else if (mark.markType === 'markup') {
+            // Text direction → <words>. The decoder reads any non-tempo <words> back
+            // as a markup mark (text-as-markup convention).
+            const placement = mark.placement ? ` placement="${mark.placement}"` : '';
+            xml += `${indent(level)}<direction${placement}>\n`;
+            xml += `${indent(level + 1)}<direction-type>\n`;
+            xml += `${indent(level + 2)}<words>${escapeXml(mark.content)}</words>\n`;
+            xml += `${indent(level + 1)}</direction-type>\n`;
+            xml += staffTag;
+            xml += `${indent(level)}</direction>\n`;
+        }
+        else if (mark.markType === 'navigation') {
+            // \coda / \segno glyph → <direction-type><coda|segno>.
+            const glyph = mark.type === NavigationMarkType.coda ? 'coda' : 'segno';
+            xml += `${indent(level)}<direction>\n`;
+            xml += `${indent(level + 1)}<direction-type>\n`;
+            xml += `${indent(level + 2)}<${glyph}/>\n`;
+            xml += `${indent(level + 1)}</direction-type>\n`;
+            xml += staffTag;
+            xml += `${indent(level)}</direction>\n`;
+        }
     }
     return xml;
 };
@@ -536,20 +589,26 @@ const encodeMeasure = (measure, partIndex, measureNumber, isFirst, prevKey, prev
         for (const event of voice.events) {
             switch (event.type) {
                 case 'note': {
-                    // Check for direction marks (dynamics, hairpins, pedals)
-                    const directionMarks = event.marks?.filter(m => m.markType === 'dynamic' || m.markType === 'hairpin' || m.markType === 'pedal') || [];
+                    // Check for direction marks (dynamics, hairpins, pedals, text, nav)
+                    const directionMarks = event.marks?.filter(m => m.markType === 'dynamic' || m.markType === 'hairpin' ||
+                        m.markType === 'pedal' || m.markType === 'markup' ||
+                        m.markType === 'navigation') || [];
                     if (directionMarks.length > 0) {
-                        xml += encodeDirection(directionMarks, level + 1);
+                        xml += encodeDirection(directionMarks, level + 1, currentStaff, maxStaff > 1);
                     }
                     // Encode main note
                     xml += encodeNote(event, voiceNum, currentStaff, level + 1);
                     const dur = calculateDuration(event.duration);
                     voicePosition += dur;
-                    // Encode chord notes
+                    // Encode chord notes. Marks live on the parent NoteEvent (the whole
+                    // chord) and are emitted on the first note only — re-emitting them on
+                    // each member would multiply them on decode (the decoder aggregates
+                    // every member's marks back onto the one chord event).
                     for (let i = 1; i < event.pitches.length; i++) {
                         const chordEvent = {
                             ...event,
                             pitches: [event.pitches[i]],
+                            marks: undefined,
                         };
                         xml += encodeNote(chordEvent, voiceNum, currentStaff, level + 1, true);
                     }
@@ -582,6 +641,14 @@ const encodeMeasure = (measure, partIndex, measureNumber, isFirst, prevKey, prev
                         const isFirst = ti === 0;
                         const isLast = ti === tupletEvents.length - 1;
                         if (subEvent.type === 'note') {
+                            // Direction marks (dynamics, hairpins, pedals, text, nav) — same
+                            // as the plain-note case; without this they vanish inside tuplets.
+                            const directionMarks = subEvent.marks?.filter(m => m.markType === 'dynamic' || m.markType === 'hairpin' ||
+                                m.markType === 'pedal' || m.markType === 'markup' ||
+                                m.markType === 'navigation') || [];
+                            if (directionMarks.length > 0) {
+                                xml += encodeDirection(directionMarks, level + 1, currentStaff, maxStaff > 1);
+                            }
                             // Add tuplet notation marks
                             const tupletMarks = [];
                             if (isFirst)

package/lib/lilylet/musicXmlTypes.d.ts

@@ -56,7 +56,7 @@ export interface MusicXmlNotations {
     }[];
     articulations?: string[];
     ornaments?: string[];
-    fermata?: boolean;
+    fermata?: 'normal' | 'short';
     arpeggiate?: boolean;
     tremolo?: {
         type: 'single' | 'start' | 'stop';
@@ -66,6 +66,7 @@ export interface MusicXmlNotations {
         type: 'start' | 'stop';
         number: number;
     };
+    glissando?: boolean;
 }
 export interface MusicXmlNote {
     isChord: boolean;
@@ -117,6 +118,7 @@ export interface MusicXmlDirection {
     pedal?: MusicXmlPedal;
     metronome?: MusicXmlMetronome;
     words?: MusicXmlWords[];
+    rehearsal?: string;
     octaveShift?: MusicXmlOctaveShift;
     coda?: boolean;
     segno?: boolean;

package/lib/lilylet/musicXmlUtils.js

@@ -339,7 +339,7 @@ const DYNAMIC_MAP = {
     fz: DynamicType.sfz,
     sfp: DynamicType.sfz,
     sfpp: DynamicType.sfz,
-    fp: DynamicType.f, // forte-piano, approximate
+    fp: DynamicType.fp, // forte-piano
 };
 export const convertDynamic = (name) => {
     return DYNAMIC_MAP[name.toLowerCase()];

package/lib/lilylet/serializer.js

@@ -114,6 +114,7 @@ const ORNAMENT_MAP = {
     fermata: '\\fermata',
     shortFermata: '\\shortfermata',
     arpeggio: '\\arpeggio',
+    breath: '\\breathe',
 };
 // Dynamic to Lilylet notation
 const DYNAMIC_MAP = {
@@ -232,6 +233,19 @@ const serializeMarks = (marks) => {
             case 'fingering':
                 parts.push('-' + mark.finger);
                 break;
+            case 'markup': {
+                // Text direction attached to a note (e.g. ^\markup "cantabile").
+                // Placement: above → ^, below → _, unspecified → - (default).
+                const prefix = mark.placement === 'above' ? '^' : mark.placement === 'below' ? '_' : '-';
+                parts.push(prefix + '\\markup "' + escapeString(mark.content) + '"');
+                break;
+            }
+            case 'navigation':
+                parts.push(mark.type === 'coda' ? '\\coda' : '\\segno');
+                break;
+            case 'glissando':
+                parts.push('\\glissando');
+                break;
         }
     }
     return parts.join('');
@@ -507,7 +521,7 @@ const serializeEvent = (event, env, prevDuration, suppressGracePrefix = false) =
         case 'markup': {
             const mk = event;
             const prefix = mk.placement === 'above' ? '^' : mk.placement === 'below' ? '_' : '';
-            return { str: `${prefix}\\markup "${mk.content}"`, newEnv: env };
+            return { str: `${prefix}\\markup "${escapeString(mk.content)}"`, newEnv: env };
         }
         case 'dynamic': {
             const dynStr = DYNAMIC_MAP[event.dynamicType];
@@ -841,7 +855,12 @@ const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false,
 };
 // Escape string for serialization (quotes and backslashes)
 const escapeString = (str) => {
-    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
 };
 // Serialize metadata
 const serializeMetadata = (metadata) => {

package/lib/lilylet/types.d.ts

@@ -39,7 +39,8 @@ export declare enum OrnamentType {
     prall = "prall",
     fermata = "fermata",
     shortFermata = "shortFermata",
-    arpeggio = "arpeggio"
+    arpeggio = "arpeggio",
+    breath = "breath"
 }
 export declare enum DynamicType {
     ppp = "ppp",
@@ -150,7 +151,10 @@ export interface MarkupMark {
     content: string;
     placement?: Placement;
 }
-export type Mark = Articulation | Ornament | Dynamic | Hairpin | Tie | Slur | Beam | Pedal | Fingering | NavigationMark | MarkupMark;
+export interface Glissando {
+    markType: 'glissando';
+}
+export type Mark = Articulation | Ornament | Dynamic | Hairpin | Tie | Slur | Beam | Pedal | Fingering | NavigationMark | MarkupMark | Glissando;
 export interface KeySignature {
     pitch: Phonet;
     accidental?: Accidental;

package/lib/lilylet/types.js

@@ -47,6 +47,7 @@ export var OrnamentType;
     OrnamentType["fermata"] = "fermata";
     OrnamentType["shortFermata"] = "shortFermata";
     OrnamentType["arpeggio"] = "arpeggio";
+    OrnamentType["breath"] = "breath";
 })(OrnamentType || (OrnamentType = {}));
 export var DynamicType;
 (function (DynamicType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.75",
+  "version": "0.1.78",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",
@@ -41,6 +41,7 @@
     "test:abc": "tsx ./tests/abc-decoder.ts",
     "test:roundtrip": "tsx ./tests/lilypond-roundtrip.ts",
     "test:lyl-roundtrip": "tsx ./tests/lyl-roundtrip.ts",
+    "test:xml-roundtrip": "tsx ./tests/musicxml-roundtrip.ts",
     "test:abc-svg": "tsx ./tests/abc-abcjs-svg.ts",
     "train:bpe": "tsx ./tools/trainBpeTokenizer.ts",
     "build:manual-tokenizer": "tsx ./tools/buildManualTokenizer.ts",
@@ -48,6 +49,7 @@
     "test:bpe": "tsx ./tests/unit/bpeTokenizer.test.ts",
     "test:measures": "tsx ./tests/unit/measureLayout.test.ts",
     "test:measures-xml": "tsx ./tests/unit/measureLayoutFromXml.test.ts",
+    "test:abc-repeats": "tsx ./tests/unit/abcRepeatLayout.test.ts",
     "build:tests": "tsc -p tsconfig.tests.json; cp source/lilylet/grammar.jison.js lib-tests/source/lilylet/ && cp source/abc/grammar.jison.js lib-tests/source/abc/ && node tools/fixEsmExtensions.cjs lib-tests && ln -sfn ../../tests/assets lib-tests/tests/assets",
     "test:roundtrip:compiled": "node lib-tests/tests/lilypond-roundtrip.js",
     "ts": "tsx"

package/source/abc/abc.jison

@@ -542,15 +542,18 @@ bar
 	| ':' '|' ']'						-> ':|]'
 	| '|' N								-> '|' + $2
 	| '|' N volta_rest					-> '|' + $2 + $3
-	| ':' '|' N							-> ':|' + $2
-	| ':' '|' N volta_rest				-> ':|' + $2 + $3
+	| ':' '|' N							-> ':|' + $3
+	| ':' '|' N volta_rest				-> ':|' + $3 + $4
 	| '&'								-> '&'
 	;
 
-// Additional volta endings after the first number, comma-separated: "1,2", "1,2,3".
+// Additional volta endings after the first number: comma-separated "1,2,3", or a
+// hyphen range "1-3". Mirrors abc2xml, which normalizes "[1-2" to number="1,2".
 volta_rest
 	: ',' N								-> ',' + $2
+	| '-' N								-> ',' + $2
 	| volta_rest ',' N					-> $1 + ',' + $3
+	| volta_rest '-' N					-> $1 + ',' + $3
 	;
 
 music
@@ -566,7 +569,8 @@ music
 	| music NAME						-> $1
 	| music '^' NAME					-> $1
 	| music '^' articulation_letter		-> $1
-	| music '[' N						-> $1
+	| music '[' N						-> $1 ? [...$1, {volta: String($3)}] : [{volta: String($3)}]
+	| music '[' N volta_rest			-> $1 ? [...$1, {volta: String($3) + $4}] : [{volta: String($3) + $4}]
 	;
 
 // Articulation-class letters (P macro: HJLMOPRSTuv). After a stray '^' inside a