@k-l-lambda/lilylet 0.1.76 → 0.1.78

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('');

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.76",
+  "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