@k-l-lambda/lilylet 0.1.56 → 0.1.58

package/lib/lilylet/lilypondDecoder.js

@@ -585,12 +585,9 @@ const parseLilyDocument = (lilyDocument) => {
                         const restEvent = {
                             type: 'rest',
                             duration: convertDuration(term.durationValue),
+                            fullMeasure: (term.name === 'R') || undefined,
                             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 +979,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 +987,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/serializer.js

@@ -500,10 +500,14 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
     for (const event of voice.events) {
         if (event.type === 'context') {
             const ctx = event;
-            // Skip context events that belong to a different staff (cross-staff clef/ottava)
-            if (ctx.staff && ctx.staff !== voice.staff) {
+            // Cross-staff context: update activeStaff and emit \staff directive
+            if (ctx.staff && ctx.staff !== activeStaff) {
+                activeStaff = ctx.staff;
+                parts.push('\\staff "' + activeStaff + '"');
                 continue;
             }
+            if (ctx.staff)
+                continue; // same staff, no-op
             // Skip clef-only context events if clef already established for this staff
             if (clefOutputted && ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo) {
                 continue;
@@ -511,8 +515,8 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
         }
         if (event.type === 'note') {
             const noteEvt = event;
-            // Cross-staff: emit \staff when note's effective staff differs from active
-            const effectiveStaff = noteEvt.staff || voice.staff;
+            // Cross-staff via explicit note.staff (lilylet native cross-staff)
+            const effectiveStaff = noteEvt.staff || activeStaff;
             if (effectiveStaff !== activeStaff) {
                 activeStaff = effectiveStaff;
                 parts.push('\\staff "' + activeStaff + '"');
@@ -679,12 +683,16 @@ export const serializeLilyletDoc = (doc) => {
         // Collect clefs from this measure's voices
         for (const part of measure.parts) {
             for (const voice of part.voices) {
+                let clefActiveStaff = voice.staff;
                 for (const event of voice.events) {
-                    if (event.type === 'context' && event.clef) {
+                    if (event.type === 'context') {
                         const ctx = event;
-                        // Use the event's staff if specified (cross-staff), otherwise the voice's staff
-                        const clefStaff = ctx.staff || voice.staff;
-                        staffClefs[clefStaff] = ctx.clef;
+                        if (ctx.staff) {
+                            clefActiveStaff = ctx.staff;
+                        }
+                        if (ctx.clef) {
+                            staffClefs[clefActiveStaff] = ctx.clef;
+                        }
                     }
                 }
             }

package/package.json

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

package/source/lilylet/lilypondDecoder.ts

@@ -708,18 +708,10 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 						const restEvent: RestEvent = {
 							type: 'rest',
 							duration: convertDuration(term.durationValue),
+							fullMeasure: (term.name === 'R') || undefined,
 							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);
 					}
 				}
@@ -1145,8 +1137,8 @@ const parsedMeasuresToDoc = (parsedMeasures: ParsedMeasure[], metadata?: Metadat
 		// 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
-		const partMap = new Map<number, Map<number, Event[]>>();
+		// Group voices by partIndex, then collect voice arrays per staff
+		const partMap = new Map<number, Map<number, Event[][]>>();
 		for (const v of filteredVoices) {
 			const pi = v.partIndex || 1;
 			if (!partMap.has(pi)) {
@@ -1154,24 +1146,26 @@ const parsedMeasuresToDoc = (parsedMeasures: ParsedMeasure[], metadata?: Metadat
 			}
 			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 => ({
-					staff,
-					events: dedupeContextEvents(staffMap.get(staff)!),
-				})),
+				voices: staffNums.flatMap(staff =>
+					staffMap.get(staff)!.map(events => ({
+						staff,
+						events: dedupeContextEvents(events),
+					}))
+				),
 			};
 		});
 

package/source/lilylet/lilypondEncoder.ts

@@ -394,11 +394,18 @@ const encodeNoteEvent = (event: NoteEvent, env: PitchEnv, lastDuration: Duration
 	if (event.pitches.length > 1) {
 		result += '<';
 		const pitchStrs: string[] = [];
-		for (const pitch of event.pitches) {
-			const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+		let firstPitchEnv: PitchEnv | undefined;
+		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 += '>';
 	} else if (event.pitches.length === 1) {
@@ -455,13 +462,15 @@ const encodeRestEvent = (event: RestEvent, env: PitchEnv, lastDuration: 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 };
 };
 
 
@@ -512,8 +521,9 @@ const encodeTupletEvent = (event: TupletEvent, env: PitchEnv, lastDuration: Dura
 			newEnv = ne;
 			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;
 		}
 	}
@@ -535,11 +545,14 @@ const encodeTremoloEvent = (event: TremoloEvent, env: PitchEnv): { str: string;
 	if (event.pitchA.length > 1) {
 		pitchA += '<';
 		const pitchStrs: string[] = [];
-		for (const pitch of event.pitchA) {
-			const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+		let firstPitchEnv: PitchEnv | undefined;
+		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 += '>';
 	} else if (event.pitchA.length === 1) {
@@ -553,11 +566,14 @@ const encodeTremoloEvent = (event: TremoloEvent, env: PitchEnv): { str: string;
 	if (event.pitchB.length > 1) {
 		pitchB += '<';
 		const pitchStrs: string[] = [];
-		for (const pitch of event.pitchB) {
-			const { str, newEnv: ne } = encodePitch(pitch, newEnv);
+		let firstPitchEnv: PitchEnv | undefined;
+		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 += '>';
 	} else if (event.pitchB.length === 1) {
@@ -624,8 +640,9 @@ const encodeVoice = (
 				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;
 			}
@@ -662,7 +679,8 @@ const encodeVoice = (
 				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/source/lilylet/serializer.ts

@@ -648,10 +648,13 @@ const serializeVoice = (
 	for (const event of voice.events) {
 		if (event.type === 'context') {
 			const ctx = event as ContextChange;
-			// Skip context events that belong to a different staff (cross-staff clef/ottava)
-			if (ctx.staff && ctx.staff !== voice.staff) {
+			// Cross-staff context: update activeStaff and emit \staff directive
+			if (ctx.staff && ctx.staff !== activeStaff) {
+				activeStaff = ctx.staff;
+				parts.push('\\staff "' + activeStaff + '"');
 				continue;
 			}
+			if (ctx.staff) continue;  // same staff, no-op
 			// Skip clef-only context events if clef already established for this staff
 			if (clefOutputted && ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo) {
 				continue;
@@ -661,8 +664,8 @@ const serializeVoice = (
 		if (event.type === 'note') {
 			const noteEvt = event as NoteEvent;
 
-			// Cross-staff: emit \staff when note's effective staff differs from active
-			const effectiveStaff = noteEvt.staff || voice.staff;
+			// Cross-staff via explicit note.staff (lilylet native cross-staff)
+			const effectiveStaff = noteEvt.staff || activeStaff;
 			if (effectiveStaff !== activeStaff) {
 				activeStaff = effectiveStaff;
 				parts.push('\\staff "' + activeStaff + '"');
@@ -872,12 +875,16 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 		// Collect clefs from this measure's voices
 		for (const part of measure.parts) {
 			for (const voice of part.voices) {
+				let clefActiveStaff = voice.staff;
 				for (const event of voice.events) {
-					if (event.type === 'context' && (event as ContextChange).clef) {
+					if (event.type === 'context') {
 						const ctx = event as ContextChange;
-						// Use the event's staff if specified (cross-staff), otherwise the voice's staff
-						const clefStaff = ctx.staff || voice.staff;
-						staffClefs[clefStaff] = ctx.clef!;
+						if (ctx.staff) {
+							clefActiveStaff = ctx.staff;
+						}
+						if (ctx.clef) {
+							staffClefs[clefActiveStaff] = ctx.clef;
+						}
 					}
 				}
 			}