@k-l-lambda/lilylet 0.1.51 → 0.1.53

package/source/lilylet/meiEncoder.ts

@@ -125,6 +125,7 @@ const DYNAMIC_MAP: Record<string, string> = {
 	fff: "fff",
 	sfz: "sfz",
 	rfz: "rfz",
+	fp: "fp",
 };
 
 
@@ -171,10 +172,12 @@ const getKeyAccidentals = (fifths: number): Record<string, string> => {
 	return result;
 };
 
-// Convert Pitch to MEI attributes, checking against key signature
+// Convert Pitch to MEI attributes, checking against key signature and in-measure accidentals
 // ottavaShift: current ottava level (1 = 8va up, -1 = 8vb down, 2 = 15ma up, etc.)
 // The written pitch should be adjusted by subtracting the ottava shift
-const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number = 0): { pname: string; oct: number; accid?: string; accidGes?: string } => {
+// measureAccidentals: tracks accidentals used earlier in the same measure (keyed by "pname-oct")
+//   - mutated to record new accidentals; used to add cancellation naturals
+const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): { pname: string; oct: number; accid?: string; accidGes?: string } => {
 	// Lilylet octave: 0 = middle C octave (C4), positive = higher, negative = lower
 	// When ottava is active, the source pitch is the sounding pitch, but we need to output the written pitch
 	// For 8va up (ottavaShift=1), written pitch is one octave lower than sounding
@@ -188,18 +191,40 @@ const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number =
 	let accid: string | undefined;
 	let accidGes: string | undefined;
 
+	const pitchKey = `${pitch.phonet}-${oct}`;
+
+	// Check what was previously established for this pitch in this measure
+	const prevMeasureAccid = measureAccidentals?.get(pitchKey);
+
 	if (pitch.accidental) {
 		const noteAccid = ACCIDENTALS[pitch.accidental];
-		if (noteAccid !== keyAccid) {
+		if (prevMeasureAccid !== undefined && noteAccid !== prevMeasureAccid) {
+			// Previous note in this measure had a different accidental - must re-assert
+			accid = noteAccid;
+		} else if (noteAccid !== keyAccid) {
 			// Accidental differs from key signature - display it
 			accid = noteAccid;
 		}
 		// Always set gestural accidental for MIDI generation
 		accidGes = noteAccid;
+		// Record this accidental for in-measure tracking
+		if (measureAccidentals) measureAccidentals.set(pitchKey, noteAccid);
 	} else if (keyAccid) {
 		// Note has no accidental but key implies one - output natural
-		accid = 'n';
+		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 (measureAccidentals) {
+		// No explicit accidental, no key accidental - check if earlier note in measure had one
+		if (prevMeasureAccid && prevMeasureAccid !== 'n') {
+			// Previous note had an accidental - add cancellation natural
+			accid = 'n';
+			measureAccidentals.set(pitchKey, 'n');
+		}
 	}
 
 	return { pname: pitch.phonet, oct, accid, accidGes };
@@ -456,7 +481,8 @@ const noteEventToMEI = (
 	tieEnd?: boolean,
 	contextStemDir?: StemDirection,
 	keyFifths: number = 0,
-	ottavaShift: number = 0
+	ottavaShift: number = 0,
+	measureAccidentals?: Map<string, string>
 ): NoteEventResult => {
 	const dur = DURATIONS[event.duration.division] || "4";
 	const dots = event.duration.dots || 0;
@@ -491,7 +517,7 @@ const noteEventToMEI = (
 
 	// Single note
 	if (event.pitches.length === 1) {
-		const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift, measureAccidentals);
 		const noteId = generateId('note');
 		return {
 			xml: buildNoteElement(pitch, dur, dots, indent, false, noteOptions, noteId),
@@ -532,7 +558,7 @@ const noteEventToMEI = (
 	let result = `${indent}<chord ${chordAttrs}>\n`;
 
 	for (const p of event.pitches) {
-		const pitch = encodePitch(p, keyFifths, ottavaShift);
+		const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 		result += buildNoteElement(pitch, dur, dots, indent + '    ', true);
 	}
 
@@ -577,7 +603,7 @@ const noteEventToMEI = (
 
 
 // Convert RestEvent to MEI
-const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0): string => {
+const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): 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}"`;
@@ -605,6 +631,7 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 // TupletEventResult - return type for tupletEventToMEI
 interface TupletEventResult {
 	xml: string;
+	firstNoteId: string | null;  // ID of first note in tuplet (for attaching pending markups)
 	slurStarts: string[];  // Note IDs that start slurs
 	slurEnds: string[];    // Note IDs that end slurs
 	dynamics: DynamRef[];
@@ -615,8 +642,23 @@ interface TupletEventResult {
 	arpeggios: ArpegRef[];
 }
 
+// Check if a tuplet has balanced internal beam groups (both [ and ] inside the same tuplet)
+// Returns false for cross-tuplet beams where [ is in one tuplet and ] in another
+const tupletHasInternalBeams = (event: TupletEvent): boolean => {
+	let starts = 0;
+	let ends = 0;
+	for (const e of event.events) {
+		if (e.type === 'note') {
+			const markOptions = extractMarkOptions((e as NoteEvent).marks);
+			if (markOptions.beamStart) starts++;
+			if (markOptions.beamEnd) ends++;
+		}
+	}
+	return starts > 0 && starts === ends;
+};
+
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false): TupletEventResult => {
+const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>): TupletEventResult => {
 	// LilyPond \times 2/3 means "multiply duration by 2/3"
 	// So 3 notes × 2/3 = 2 beats worth (3 in time of 2)
 	// MEI: num = number of notes written, numbase = normal equivalent
@@ -631,6 +673,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	const effectiveStaff = currentStaff ?? layerStaff;
 
 	// Collect control event info from notes inside tuplet
+	let firstNoteId: string | null = null;
 	const slurStarts: string[] = [];
 	const slurEnds: string[] = [];
 	const dynamics: DynamRef[] = [];
@@ -640,20 +683,32 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	const turns: TurnRef[] = [];
 	const arpeggios: ArpegRef[] = [];
 
-	// If we're inside a parent beam, don't create internal beams - notes go directly into tuplet
-	// MEI allows: <beam><tuplet><note/>...</tuplet><tuplet><note/>...</tuplet></beam>
-	// Beam state is managed by encodeLayer, not here.
+	// Handle internal beam groups: if notes have manual beam marks, respect them
+	const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
+	let beamOpen = false;
 
 	for (const e of event.events) {
 		if (e.type === 'note') {
-			// For cross-staff notation: set note's staff if different from layerStaff
 			const noteEvent = e as NoteEvent;
+			const markOptions = extractMarkOptions(noteEvent.marks);
+
+			// Open beam if this note starts a beam group
+			if (hasInternalBeams && markOptions.beamStart && !beamOpen) {
+				xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
+				beamOpen = true;
+			}
+
+			const noteIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+
+			// For cross-staff notation: set note's staff if different from layerStaff
 			const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
 				? { ...noteEvent, staff: effectiveStaff }
 				: noteEvent;
-			const result = noteEventToMEI(effectiveNoteEvent, baseIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
+			const result = noteEventToMEI(effectiveNoteEvent, noteIndent, layerStaff, false, undefined, keyFifths, ottavaShift, measureAccidentals);
 			xml += result.xml;
 
+			if (!firstNoteId) firstNoteId = result.elementId;
+
 			// Collect slur info
 			if (result.slurStart) slurStarts.push(result.elementId);
 			if (result.slurEnd) slurEnds.push(result.elementId);
@@ -665,18 +720,30 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			if (result.mordent) mordents.push({ startid: result.elementId, form: result.mordent === 'upper' ? 'upper' : undefined });
 			if (result.turn) turns.push({ startid: result.elementId });
 			if (result.arpeggio) arpeggios.push({ plist: result.elementId });
+
+			// Close beam if this note ends a beam group
+			if (hasInternalBeams && markOptions.beamEnd && beamOpen) {
+				xml += `${baseIndent}</beam>\n`;
+				beamOpen = false;
+			}
 		} else if (e.type === 'rest') {
-			xml += restEventToMEI(e as RestEvent, baseIndent, keyFifths, ottavaShift);
+			const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals);
 		}
 	}
 
+	// Close any unclosed beam
+	if (beamOpen) {
+		xml += `${baseIndent}</beam>\n`;
+	}
+
 	xml += `${indent}</tuplet>\n`;
-	return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
 };
 
 
 // Convert TremoloEvent to MEI (fingered tremolo - alternating between two notes)
-const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0): string => {
+const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): string => {
 	const ftremId = generateId('fTrem');
 
 	// For \repeat tremolo 4 { c16 d16 }:
@@ -700,7 +767,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 
 	// First note (or chord)
 	if (event.pitchA.length === 1) {
-		const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -708,7 +775,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 	} else if (event.pitchA.length > 1) {
 		result += `${indent}    <chord xml:id="${generateId('chord')}" dur="${noteDur}">\n`;
 		for (const p of event.pitchA) {
-			const pitch = encodePitch(p, keyFifths, ottavaShift);
+			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -719,7 +786,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 
 	// Second note (or chord)
 	if (event.pitchB.length === 1) {
-		const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -727,7 +794,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 	} else if (event.pitchB.length > 1) {
 		result += `${indent}    <chord xml:id="${generateId('chord')}" dur="${noteDur}">\n`;
 		for (const p of event.pitchB) {
-			const pitch = encodePitch(p, keyFifths, ottavaShift);
+			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -869,6 +936,11 @@ const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TremoloE
 	}
 	if (event.type === 'tuplet') {
 		const tuplet = event as TupletEvent;
+		// If the tuplet has internal beam groups, don't report beam marks to the parent
+		// so the parent won't wrap the tuplet in an external <beam>
+		if (tupletHasInternalBeams(tuplet)) {
+			return { beamStart: false, beamEnd: false };
+		}
 		let beamStart = false;
 		let beamEnd = false;
 		for (const e of tuplet.events) {
@@ -928,6 +1000,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	const harmonies: HarmonyRef[] = [];
 	const barlines: BarlineRef[] = [];
 	const markups: MarkupRef[] = [];
+	const pendingMarkups: { content: string; placement?: 'above' | 'below' }[] = [];
 
 	// Track current stem direction from context changes
 	let currentStemDirection: StemDirection | undefined = undefined;
@@ -935,9 +1008,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	// Track current staff for cross-staff notation
 	let currentStaff: number = voice.staff || 1;
 
+	// Track in-measure accidentals for cancellation naturals
+	const measureAccidentals = new Map<string, string>();
+
 	// Track pending tie pitches (for tie="t" on next note) - initialized from previous measure
 	let pendingTiePitches: Pitch[] = [...initialTiePitches];
 
+	// Helper to flush pending markups onto a note ID
+	const flushPendingMarkups = (noteId: string) => {
+		for (const mkup of pendingMarkups) {
+			markups.push({ startid: noteId, content: mkup.content, placement: mkup.placement });
+		}
+		pendingMarkups.length = 0;
+	};
+
 	// Helper to check if pitches match for tie continuation
 	const pitchesMatch = (p1: Pitch[], p2: Pitch[]): boolean => {
 		if (p1.length !== p2.length) return false;
@@ -975,10 +1059,13 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					? { ...noteEvent, staff: currentStaff }
 					: noteEvent;
 
-				const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift);
+				const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
 				xml += result.xml;
 				lastNoteId = result.elementId;
 
+				// Flush any pending markups onto this note
+				flushPendingMarkups(result.elementId);
+
 				// If there's a pending ottava, start the span on this note
 				if (pendingOttava !== null && pendingOttava !== 0) {
 					const dis: 8 | 15 = Math.abs(pendingOttava) === 2 ? 15 : 8;
@@ -1081,14 +1168,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				break;
 			}
 			case 'rest':
-				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift);
+				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
 				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
-				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen);
+				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
 				xml += tupletResult.xml;
 
+				// Flush any pending markups onto the first note of the tuplet
+				if (tupletResult.firstNoteId) {
+					flushPendingMarkups(tupletResult.firstNoteId);
+					lastNoteId = tupletResult.firstNoteId;
+				}
+
 				// Process slur ends first (to close any pending slurs from before this tuplet)
 				for (const endId of tupletResult.slurEnds) {
 					if (currentSlur) {
@@ -1116,7 +1209,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				break;
 			}
 			case 'tremolo':
-				xml += tremoloEventToMEI(event as TremoloEvent, currentIndent, keyFifths, currentOttavaShift);
+				xml += tremoloEventToMEI(event as TremoloEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
 				break;
 			case 'context': {
 				const ctx = event as ContextChange;
@@ -1181,16 +1274,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					harmonies.push({ startid: lastNoteId, text: (event as HarmonyEvent).text });
 				}
 				break;
-			case 'markup':
-				// Markup needs a note ID to attach to - use the last note if available
+			case 'markup': {
+				// Markup needs a note ID to attach to
+				const mkupEvent = event as MarkupEvent;
 				if (lastNoteId) {
-					const mkupEvent = event as MarkupEvent;
 					markups.push({
 						startid: lastNoteId,
 						content: mkupEvent.content,
 						placement: mkupEvent.placement,
 					});
+				} else {
+					// No note yet - save as pending, will attach to next note
+					pendingMarkups.push({ content: mkupEvent.content, placement: mkupEvent.placement });
 				}
+			}
 				break;
 		}
 

package/source/lilylet/serializer.ts

@@ -144,6 +144,7 @@ const DYNAMIC_MAP: Record<string, string> = {
 	fff: '\\fff',
 	sfz: '\\sfz',
 	rfz: '\\rfz',
+	fp: '\\fp',
 };
 
 

package/source/lilylet/types.ts

@@ -60,6 +60,7 @@ export enum DynamicType {
 	fff = 'fff',
 	sfz = 'sfz',
 	rfz = 'rfz',
+	fp = 'fp',
 }
 
 export enum HairpinType {