@k-l-lambda/lilylet 0.1.55 → 0.1.57

package/source/lilylet/lilylet.jison

@@ -396,7 +396,9 @@ pitches
 	;
 
 pitch
-	: PITCH octave								-> parsePitch($1, $2)
+	: PITCH octave '!'							-> { ...parsePitch($1, $2), courtesy: true }
+	| PITCH '!'								-> { ...parsePitch($1, 0), courtesy: true }
+	| PITCH octave								-> parsePitch($1, $2)
 	| PITCH										-> parsePitch($1, 0)
 	;
 
@@ -564,7 +566,6 @@ articulation_mark
 	| '>'										-> articulation('accent')
 	| '.'										-> articulation('staccato')
 	| '-'										-> articulation('tenuto')
-	| '!'										-> articulation('staccatissimo')
 	| '^'										-> articulation('marcato')
 	| '_'										-> articulation('portato')
 	;

package/source/lilylet/lilypondDecoder.ts

@@ -711,15 +711,6 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 							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 +1136,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 +1145,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/meiEncoder.ts

@@ -198,7 +198,10 @@ const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number =
 
 	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;
 		} else if (noteAccid !== keyAccid) {
@@ -211,13 +214,21 @@ const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number =
 		if (measureAccidentals) measureAccidentals.set(pitchKey, noteAccid);
 	} 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 {
 			accid = 'n';
 		}
 		accidGes = 'n';
 		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') {
@@ -603,11 +614,14 @@ const noteEventToMEI = (
 
 
 // Convert RestEvent to MEI
-const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): string => {
+const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>, crossStaff?: number): string => {
 	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);
@@ -1189,9 +1203,12 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				}
 				break;
 			}
-			case 'rest':
-				xml += restEventToMEI(event as RestEvent, 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 as RestEvent, 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/source/lilylet/types.ts

@@ -110,6 +110,7 @@ export interface Pitch {
 	phonet: Phonet;
 	accidental?: Accidental;
 	octave: number; // 0 = middle C octave, positive = higher, negative = lower
+	courtesy?: boolean; // force display of accidental (! in LilyPond)
 }
 
 export interface Duration {