@k-l-lambda/lilylet 0.1.50 → 0.1.52

package/source/lilylet/meiEncoder.ts

@@ -125,6 +125,7 @@ const DYNAMIC_MAP: Record<string, string> = {
 	fff: "fff",
 	sfz: "sfz",
 	rfz: "rfz",
+	fp: "fp",
 };
 
 
@@ -524,6 +525,10 @@ const noteEventToMEI = (
 	if (layerStaff && noteOptions.staff && noteOptions.staff !== layerStaff) {
 		chordAttrs += ` staff="${noteOptions.staff}"`;
 	}
+	if (noteOptions.tremolo) {
+		const stemMod = tremoloToStemMod(noteOptions.tremolo);
+		if (stemMod) chordAttrs += ` stem.mod="${stemMod}"`;
+	}
 
 	let result = `${indent}<chord ${chordAttrs}>\n`;
 
@@ -611,6 +616,21 @@ 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 => {
 	// LilyPond \times 2/3 means "multiply duration by 2/3"
@@ -636,18 +656,28 @@ 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);
 			xml += result.xml;
 
 			// Collect slur info
@@ -661,11 +691,23 @@ 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);
 		}
 	}
 
+	// Close any unclosed beam
+	if (beamOpen) {
+		xml += `${baseIndent}</beam>\n`;
+	}
+
 	xml += `${indent}</tuplet>\n`;
 	return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
 };
@@ -865,6 +907,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) {

package/source/lilylet/serializer.ts

@@ -31,6 +31,7 @@ import {
 	PedalType,
 	Tempo,
 	Placement,
+	Metadata,
 } from "./types";
 
 
@@ -143,6 +144,7 @@ const DYNAMIC_MAP: Record<string, string> = {
 	fff: '\\fff',
 	sfz: '\\sfz',
 	rfz: '\\rfz',
+	fp: '\\fp',
 };
 
 
@@ -259,6 +261,9 @@ const serializeMarks = (marks: Mark[]): string => {
 				if (pedalStr) parts.push(pedalStr);
 				break;
 			}
+			case 'fingering':
+				parts.push('-' + mark.finger);
+				break;
 		}
 	}
 
@@ -584,14 +589,16 @@ const findVoiceClef = (voice: Voice): Clef | undefined => {
 // Takes currentStaff (what parser thinks staff is) and returns { str, newStaff }
 // If isGrandStaff is true, always output \staff command for clarity
 // measureContext provides key/time for first voice
-// staffClef is the clef for this voice's staff (tracked across measures)
+// allStaffClefs is the clef map for all staves (tracked across measures)
+// emittedClefs tracks which clefs have already been output (avoids duplicates)
 const serializeVoice = (
 	voice: Voice,
 	currentStaff: number,
 	isGrandStaff: boolean = false,
 	measureContext?: MeasureContext,
 	isFirstVoice: boolean = false,
-	staffClef?: Clef
+	allStaffClefs?: Record<number, Clef>,
+	emittedClefs?: Record<number, Clef>
 ): { str: string; newStaff: number } => {
 	const parts: string[] = [];
 	let prevDuration: Duration | undefined;
@@ -625,25 +632,63 @@ const serializeVoice = (
 		}
 	}
 
-	// Output clef for every voice (use staff clef tracked across measures, or find from voice events)
-	const voiceClef = staffClef || findVoiceClef(voice);
-	if (voiceClef) {
+	// Output clef only if not yet emitted or changed for this staff
+	const voiceClef = allStaffClefs?.[voice.staff] || findVoiceClef(voice);
+	const clefAlreadyEmitted = voiceClef && emittedClefs?.[voice.staff] === voiceClef;
+	if (voiceClef && !clefAlreadyEmitted) {
 		parts.push('\\clef "' + CLEF_MAP[voiceClef] + '"');
+		if (emittedClefs) emittedClefs[voice.staff] = voiceClef;
 	}
+	// Skip redundant clef context events if this staff's clef is already established
+	const clefOutputted = !!voiceClef && !!emittedClefs?.[voice.staff];
 
-	// Track if we've already output the clef to avoid duplication
-	let clefOutputted = !!voiceClef;
+	let activeStaff = voice.staff;
+	let activeStemDir: StemDirection | undefined;
 
 	for (const event of voice.events) {
-		// Skip clef context events if we've already output the clef at the beginning
-		if (clefOutputted && event.type === 'context') {
+		if (event.type === 'context') {
 			const ctx = event as ContextChange;
-			if (ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo && !ctx.staff) {
-				// This is a clef-only context event, skip it
+			// Skip context events that belong to a different staff (cross-staff clef/ottava)
+			if (ctx.staff && ctx.staff !== voice.staff) {
+				continue;
+			}
+			// 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;
 			}
 		}
 
+		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;
+			if (effectiveStaff !== activeStaff) {
+				activeStaff = effectiveStaff;
+				parts.push('\\staff "' + activeStaff + '"');
+				// Emit the target staff's clef if it differs from what was last emitted for this staff
+				const targetClef = allStaffClefs?.[activeStaff];
+				if (targetClef && emittedClefs?.[activeStaff] !== targetClef) {
+					parts.push('\\clef "' + CLEF_MAP[targetClef] + '"');
+					if (emittedClefs) emittedClefs[activeStaff] = targetClef;
+				}
+			}
+
+			// Stem direction: emit \stemUp/\stemDown/\stemNeutral on change
+			const stemDir = noteEvt.stemDirection;
+			if (stemDir !== activeStemDir) {
+				if (stemDir === StemDirection.up) {
+					parts.push('\\stemUp');
+				} else if (stemDir === StemDirection.down) {
+					parts.push('\\stemDown');
+				} else if (activeStemDir) {
+					// Was set, now undefined → reset to neutral
+					parts.push('\\stemNeutral');
+				}
+				activeStemDir = stemDir;
+			}
+		}
+
 		const { str: eventStr, newEnv } = serializeEvent(event, pitchEnv, prevDuration);
 		pitchEnv = newEnv;
 
@@ -656,6 +701,9 @@ const serializeVoice = (
 			prevDuration = (event as NoteEvent).duration;
 		} else if (event.type === 'rest') {
 			prevDuration = (event as RestEvent).duration;
+		} else if (event.type === 'context' && (event as ContextChange).clef && emittedClefs) {
+			const ctx = event as ContextChange;
+			emittedClefs[ctx.staff || activeStaff] = ctx.clef!;
 		}
 	}
 
@@ -671,7 +719,8 @@ const serializePart = (
 	isGrandStaff: boolean = false,
 	measureContext?: MeasureContext,
 	isFirstPart: boolean = false,
-	clefsByStaff?: Record<number, Clef>
+	clefsByStaff?: Record<number, Clef>,
+	emittedClefs?: Record<number, Clef>
 ): { str: string; newStaff: number } => {
 	if (part.voices.length === 0) {
 		return { str: '', newStaff: currentStaff };
@@ -683,10 +732,8 @@ const serializePart = (
 	for (let i = 0; i < part.voices.length; i++) {
 		const voice = part.voices[i];
 		// Pass measureContext to all voices, isFirstVoice for key/time
-		// Pass staff clef from clefsByStaff map
 		const isFirstVoice = isFirstPart && i === 0;
-		const staffClef = clefsByStaff?.[voice.staff];
-		const { str, newStaff } = serializeVoice(voice, staff, isGrandStaff, measureContext, isFirstVoice, staffClef);
+		const { str, newStaff } = serializeVoice(voice, staff, isGrandStaff, measureContext, isFirstVoice, clefsByStaff, emittedClefs);
 		voiceStrs.push(str);
 		staff = newStaff;
 	}
@@ -705,7 +752,8 @@ const serializeMeasure = (
 	isGrandStaff: boolean = false,
 	currentKey?: KeySignature,
 	currentTime?: { numerator: number; denominator: number; symbol?: 'common' | 'cut' },
-	staffClefs?: Record<number, Clef>
+	staffClefs?: Record<number, Clef>,
+	emittedClefs?: Record<number, Clef>
 ): { str: string; newStaff: number } => {
 	const parts: string[] = [];
 
@@ -723,7 +771,7 @@ const serializeMeasure = (
 	// Parts
 	let staff = currentStaff;
 	if (measure.parts.length === 1) {
-		const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsByStaff);
+		const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsByStaff, emittedClefs);
 		if (partStr) {
 			parts.push(partStr);
 		}
@@ -734,7 +782,7 @@ const serializeMeasure = (
 		for (let i = 0; i < measure.parts.length; i++) {
 			const part = measure.parts[i];
 			// Pass measureContext to all parts, isFirstPart to first part only
-			const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsByStaff);
+			const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsByStaff, emittedClefs);
 			if (str) {
 				partStrs.push(str);
 			}
@@ -753,7 +801,7 @@ const escapeString = (str: string): string => {
 };
 
 // Serialize metadata
-const serializeMetadata = (metadata: any): string => {
+const serializeMetadata = (metadata: Metadata): string => {
 	const lines: string[] = [];
 
 	if (metadata.title) {
@@ -809,6 +857,7 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 	let currentKey: KeySignature | undefined;
 	let currentTime: { numerator: number; denominator: number; symbol?: 'common' | 'cut' } | undefined;
 	const staffClefs: Record<number, Clef> = {}; // Track clef per staff
+	const emittedClefs: Record<number, Clef> = {}; // Track which clefs have been output
 
 	for (let i = 0; i < doc.measures.length; i++) {
 		const measure = doc.measures[i];
@@ -825,13 +874,16 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 			for (const voice of part.voices) {
 				for (const event of voice.events) {
 					if (event.type === 'context' && (event as ContextChange).clef) {
-						staffClefs[voice.staff] = (event as ContextChange).clef!;
+						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!;
 					}
 				}
 			}
 		}
 
-		const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, staffClefs);
+		const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, staffClefs, emittedClefs);
 		// Always include measure, even if empty (use space rest for empty measures)
 		measureStrs.push(measureStr || 's1');
 		currentStaff = newStaff;

package/source/lilylet/types.ts

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