@k-l-lambda/lilylet 0.1.55 → 0.1.57

package/lib/lilylet/lilypondDecoder.js

@@ -587,10 +587,6 @@ const parseLilyDocument = (lilyDocument) => {
                             duration: convertDuration(term.durationValue),
                             invisible: term.isSpacer || undefined,
                         };
-                        // Positioned rest
-                        if (!term.isSpacer && context.pitch) {
-                            restEvent.pitch = convertPitch(context.pitch.phonetStep, 0, context.pitch.octave);
-                        }
                         voice.events.push(restEvent);
                     }
                 }
@@ -982,7 +978,7 @@ const parsedMeasuresToDoc = (parsedMeasures, metadata) => {
     const measures = parsedMeasures.map(pm => {
         // Filter out voices that only contain spacer rests and context changes
         const filteredVoices = pm.voices.filter(v => hasRealContent(v.events));
-        // Group voices by partIndex, then merge voices on the same staff
+        // Group voices by partIndex, then collect voice arrays per staff
         const partMap = new Map();
         for (const v of filteredVoices) {
             const pi = v.partIndex || 1;
@@ -990,23 +986,23 @@ const parsedMeasuresToDoc = (parsedMeasures, metadata) => {
                 partMap.set(pi, new Map());
             }
             const staffMap = partMap.get(pi);
-            // Merge events from voices on the same staff
+            // Preserve each voice as a separate array
             if (!staffMap.has(v.staff)) {
                 staffMap.set(v.staff, []);
             }
-            staffMap.get(v.staff).push(...v.events);
+            staffMap.get(v.staff).push(v.events);
         }
         // Convert to parts array (sorted by part index, then by staff)
-        // Apply deduplication to merged events
+        // Apply deduplication to each voice's events
         const partIndices = Array.from(partMap.keys()).sort((a, b) => a - b);
         const parts = partIndices.map(pi => {
             const staffMap = partMap.get(pi);
             const staffNums = Array.from(staffMap.keys()).sort((a, b) => a - b);
             return {
-                voices: staffNums.map(staff => ({
+                voices: staffNums.flatMap(staff => staffMap.get(staff).map(events => ({
                     staff,
-                    events: dedupeContextEvents(staffMap.get(staff)),
-                })),
+                    events: dedupeContextEvents(events),
+                }))),
             };
         });
         // Fallback to single empty part if no voices

package/lib/lilylet/lilypondEncoder.js

@@ -294,11 +294,19 @@ const encodeNoteEvent = (event, env, lastDuration) => {
     if (event.pitches.length > 1) {
         result += '<';
         const pitchStrs = [];
-        for (const pitch of event.pitches) {
-            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+        let firstPitchEnv;
+        for (let i = 0; i < event.pitches.length; i++) {
+            // In LilyPond relative mode, each pitch in a chord is relative
+            // to the previous pitch in the chord (cascading).
+            // After the chord, env becomes the first pitch.
+            const { str, newEnv: ne } = encodePitch(event.pitches[i], newEnv);
             pitchStrs.push(str);
             newEnv = ne;
+            if (i === 0)
+                firstPitchEnv = ne;
         }
+        // After chord, reference resets to first pitch
+        newEnv = firstPitchEnv;
         result += pitchStrs.join(' ');
         result += '>';
     }
@@ -347,12 +355,14 @@ const encodeRestEvent = (event, env, lastDuration) => {
         result += encodeDuration(event.duration);
     }
     // Positioned rest
+    let newEnv = env;
     if (event.pitch && !event.fullMeasure && !event.invisible) {
-        const { str } = encodePitch(event.pitch, env);
+        const { str, newEnv: ne } = encodePitch(event.pitch, env);
         result = str + result.slice(1); // Replace 'r' with pitch
         result += '\\rest';
+        newEnv = ne;
     }
-    return { str: result, newEnv: env, newDuration: event.duration };
+    return { str: result, newEnv, newDuration: event.duration };
 };
 /**
  * Encode a context change event
@@ -397,8 +407,9 @@ const encodeTupletEvent = (event, env, lastDuration) => {
             newDuration = nd;
         }
         else if (subEvent.type === 'rest') {
-            const { str, newDuration: nd } = encodeRestEvent(subEvent, newEnv, newDuration);
+            const { str, newEnv: ne, newDuration: nd } = encodeRestEvent(subEvent, newEnv, newDuration);
             result += str + ' ';
+            newEnv = ne;
             newDuration = nd;
         }
     }
@@ -415,11 +426,15 @@ const encodeTremoloEvent = (event, env) => {
     if (event.pitchA.length > 1) {
         pitchA += '<';
         const pitchStrs = [];
-        for (const pitch of event.pitchA) {
-            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+        let firstPitchEnv;
+        for (let i = 0; i < event.pitchA.length; i++) {
+            const { str, newEnv: ne } = encodePitch(event.pitchA[i], newEnv);
             pitchStrs.push(str);
             newEnv = ne;
+            if (i === 0)
+                firstPitchEnv = ne;
         }
+        newEnv = firstPitchEnv;
         pitchA += pitchStrs.join(' ');
         pitchA += '>';
     }
@@ -433,11 +448,15 @@ const encodeTremoloEvent = (event, env) => {
     if (event.pitchB.length > 1) {
         pitchB += '<';
         const pitchStrs = [];
-        for (const pitch of event.pitchB) {
-            const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+        let firstPitchEnv;
+        for (let i = 0; i < event.pitchB.length; i++) {
+            const { str, newEnv: ne } = encodePitch(event.pitchB[i], newEnv);
             pitchStrs.push(str);
             newEnv = ne;
+            if (i === 0)
+                firstPitchEnv = ne;
         }
+        newEnv = firstPitchEnv;
         pitchB += pitchStrs.join(' ');
         pitchB += '>';
     }
@@ -490,8 +509,9 @@ const encodeVoice = (voice, measureContext, voiceIndex) => {
                 break;
             }
             case 'rest': {
-                const { str, newDuration } = encodeRestEvent(event, env, lastDuration);
+                const { str, newEnv, newDuration } = encodeRestEvent(event, env, lastDuration);
                 result += str + ' ';
+                env = newEnv;
                 lastDuration = newDuration;
                 break;
             }
@@ -528,7 +548,8 @@ const encodeVoice = (voice, measureContext, voiceIndex) => {
                 break;
             }
             case 'pitchReset': {
-                env = { step: 0, octave: 0 };
+                // Ignore: each measure already gets its own \relative c' block,
+                // and within a measure the LilyPond reference pitch is not reset.
                 break;
             }
         }

package/lib/lilylet/meiEncoder.js

@@ -140,7 +140,11 @@ const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0, measureAccidentals)
     const prevMeasureAccid = measureAccidentals?.get(pitchKey);
     if (pitch.accidental) {
         const noteAccid = ACCIDENTALS[pitch.accidental];
-        if (prevMeasureAccid !== undefined && noteAccid !== prevMeasureAccid) {
+        if (pitch.courtesy) {
+            // Courtesy accidental (!) - always display
+            accid = noteAccid;
+        }
+        else if (prevMeasureAccid !== undefined && noteAccid !== prevMeasureAccid) {
             // Previous note in this measure had a different accidental - must re-assert
             accid = noteAccid;
         }
@@ -156,7 +160,11 @@ const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0, measureAccidentals)
     }
     else if (keyAccid) {
         // Note has no accidental but key implies one - output natural
-        if (prevMeasureAccid === 'n') {
+        if (pitch.courtesy) {
+            // Courtesy accidental (!) - always display
+            accid = 'n';
+        }
+        else if (prevMeasureAccid === 'n') {
             // Already cancelled earlier in this measure - no need to show again
         }
         else {
@@ -166,6 +174,13 @@ const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0, measureAccidentals)
         if (measureAccidentals)
             measureAccidentals.set(pitchKey, 'n');
     }
+    else if (pitch.courtesy && prevMeasureAccid && prevMeasureAccid !== 'n') {
+        // Courtesy accidental after an in-measure accidental - force natural display
+        accid = 'n';
+        accidGes = 'n';
+        if (measureAccidentals)
+            measureAccidentals.set(pitchKey, 'n');
+    }
     else if (measureAccidentals) {
         // No explicit accidental, no key accidental - check if earlier note in measure had one
         if (prevMeasureAccid && prevMeasureAccid !== 'n') {
@@ -483,11 +498,14 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
     };
 };
 // Convert RestEvent to MEI
-const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
+const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals, crossStaff) => {
     const dur = DURATIONS[event.duration.division] || "4";
     let attrs = `xml:id="${generateId('rest')}" dur="${dur}"`;
     if (event.duration.dots > 0)
         attrs += ` dots="${event.duration.dots}"`;
+    // Cross-staff attribute
+    if (crossStaff)
+        attrs += ` staff="${crossStaff}"`;
     // Pitched rest (positioned at specific pitch)
     if (event.pitch) {
         const pitch = encodePitch(event.pitch, keyFifths, ottavaShift);
@@ -899,9 +917,12 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 }
                 break;
             }
-            case 'rest':
-                xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
+            case 'rest': {
+                // For cross-staff notation: pass staff number if different from voice's home staff
+                const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
+                xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
                 break;
+            }
             case 'tuplet': {
                 // Tuplet can be nested inside beam in MEI: <beam><tuplet>...</tuplet></beam>
                 // Pass beamElementOpen to tuplet so it knows not to create its own beam

package/lib/lilylet/types.d.ts

@@ -91,6 +91,7 @@ export interface Pitch {
     phonet: Phonet;
     accidental?: Accidental;
     octave: number;
+    courtesy?: boolean;
 }
 export interface Duration {
     division: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.55",
+  "version": "0.1.57",
   "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",