@k-l-lambda/lilylet 0.1.73 → 0.1.74

package/source/lilylet/meiEncoder.ts

@@ -410,8 +410,10 @@ const extractMarkOptions = (marks?: Mark[]): {
 	beamStart: boolean;
 	beamEnd: boolean;
 	dynamic?: string;
+	dynamics: string[];  // all dynamics on this event (a note may carry several, e.g. fp written as two marks)
 	hairpin?: string;
 	pedal?: string;
+	pedals?: ('up' | 'down')[];
 	tremolo?: number;
 	fingerings: { finger: number; placement?: 'above' | 'below' }[];
 	navigation?: 'coda' | 'segno';
@@ -430,8 +432,10 @@ const extractMarkOptions = (marks?: Mark[]): {
 		beamStart: false,
 		beamEnd: false,
 		dynamic: undefined as string | undefined,
+		dynamics: [] as string[],
 		hairpin: undefined as string | undefined,
 		pedal: undefined as string | undefined,
+		pedals: [] as ('up' | 'down')[],
 		tremolo: undefined as number | undefined,
 		fingerings: [] as { finger: number; placement?: 'above' | 'below' }[],
 		navigation: undefined as 'coda' | 'segno' | undefined,
@@ -472,7 +476,8 @@ const extractMarkOptions = (marks?: Mark[]): {
 			case 'dynamic': {
 				const dynStr = DYNAMIC_MAP[mark.type];
 				if (dynStr) {
-					result.dynamic = dynStr;
+					result.dynamic = dynStr;  // kept for back-compat (first dynamic)
+					result.dynamics.push(dynStr);
 				}
 				break;
 			}
@@ -481,15 +486,20 @@ const extractMarkOptions = (marks?: Mark[]): {
 					result.hairpin = 'crescStart';
 				} else if (mark.type === HairpinType.diminuendoStart) {
 					result.hairpin = 'dimStart';
-				} else if (mark.type === HairpinType.crescendoEnd || mark.type === HairpinType.diminuendoEnd) {
-					result.hairpin = 'end';
+				} else if (mark.type === HairpinType.crescendoEnd) {
+					result.hairpin = 'crescEnd';
+				} else if (mark.type === HairpinType.diminuendoEnd) {
+					result.hairpin = 'dimEnd';
 				}
 				break;
 			case 'pedal':
+				// A note can carry more than one pedal mark (a pedal "bounce": an up
+				// to release the previous pedal and an immediate down to re-pedal on
+				// the same note), so collect ALL of them rather than keep one scalar.
 				if (mark.type === PedalType.sustainOn) {
-					result.pedal = 'down';
+					result.pedals.push('down');
 				} else if (mark.type === PedalType.sustainOff) {
-					result.pedal = 'up';
+					result.pedals.push('up');
 				}
 				break;
 			case 'tie':
@@ -544,6 +554,7 @@ interface NoteEventResult {
 	elementId: string;
 	hairpin?: string;
 	pedal?: string;
+	pedals?: ('up' | 'down')[];
 	hasTieStart: boolean;
 	pitches: Pitch[];
 	arpeggio: boolean;
@@ -551,7 +562,8 @@ interface NoteEventResult {
 	trill: boolean;
 	mordent: 'lower' | 'upper' | false;  // lower = mordent, upper = prall
 	turn: boolean;
-	dynamic?: string;  // dynamic marking (p, pp, f, ff, etc.)
+	dynamic?: string;  // dynamic marking (p, pp, f, ff, etc.) — first one (back-compat)
+	dynamics: string[];  // all dynamics on this event
 	slurStart: boolean;  // For tracking slur spans
 	slurEnd: boolean;    // For tracking slur spans
 	fingerings: { finger: number; placement?: 'above' | 'below' }[];
@@ -610,6 +622,7 @@ const noteEventToMEI = (
 			elementId: noteId,
 			hairpin: markOptions.hairpin,
 			pedal: markOptions.pedal,
+			pedals: markOptions.pedals,
 			hasTieStart: markOptions.tieStart,
 			pitches: event.pitches,
 			arpeggio: markOptions.arpeggio,
@@ -618,6 +631,7 @@ const noteEventToMEI = (
 			mordent: markOptions.mordent,
 			turn: markOptions.turn,
 			dynamic: markOptions.dynamic,
+			dynamics: markOptions.dynamics,
 			slurStart: markOptions.slurStart,
 			slurEnd: markOptions.slurEnd,
 			fingerings: markOptions.fingerings,
@@ -671,6 +685,7 @@ const noteEventToMEI = (
 		elementId: chordId,
 		hairpin: markOptions.hairpin,
 		pedal: markOptions.pedal,
+		pedals: markOptions.pedals,
 		hasTieStart: markOptions.tieStart,
 		pitches: event.pitches,
 		arpeggio: markOptions.arpeggio,
@@ -679,6 +694,7 @@ const noteEventToMEI = (
 		mordent: markOptions.mordent,
 		turn: markOptions.turn,
 		dynamic: markOptions.dynamic,
+		dynamics: markOptions.dynamics,
 		slurStart: markOptions.slurStart,
 		slurEnd: markOptions.slurEnd,
 		fingerings: markOptions.fingerings,
@@ -689,7 +705,7 @@ const noteEventToMEI = (
 
 
 // Convert RestEvent to MEI
-const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>, crossStaff?: number): { xml: string; elementId: string } => {
+const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>, crossStaff?: number): { xml: string; elementId: string; fermata?: 'normal' | 'short' } => {
 	const dur = DURATIONS[event.duration.division] || "4";
 	const restId = generateId('rest');
 	let attrs = `xml:id="${restId}" dur="${dur}"`;
@@ -698,6 +714,15 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 	// Cross-staff attribute
 	if (crossStaff) attrs += ` staff="${crossStaff}"`;
 
+	// A rest may carry a fermata (held silence). Surface it so the layer loop can
+	// emit a <fermata> control event referencing this rest's id.
+	let fermata: 'normal' | 'short' | undefined;
+	if (event.marks) {
+		for (const mk of event.marks) {
+			if (mk.markType === 'ornament' && (mk as { type?: string }).type === 'fermata') fermata = 'normal';
+		}
+	}
+
 	// Pitched rest (positioned at specific pitch)
 	if (event.pitch) {
 		const pitch = encodePitch(event.pitch, keyFifths, ottavaShift);
@@ -706,16 +731,16 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 
 	// Space rest (invisible)
 	if (event.invisible) {
-		return { xml: `${indent}<space ${attrs} />\n`, elementId: restId };
+		return { xml: `${indent}<space ${attrs} />\n`, elementId: restId, fermata };
 	}
 
 	// Full measure rest
 	if (event.fullMeasure) {
 		const mRestId = generateId('mrest');
-		return { xml: `${indent}<mRest xml:id="${mRestId}" />\n`, elementId: mRestId };
+		return { xml: `${indent}<mRest xml:id="${mRestId}" />\n`, elementId: mRestId, fermata };
 	}
 
-	return { xml: `${indent}<rest ${attrs} />\n`, elementId: restId };
+	return { xml: `${indent}<rest ${attrs} />\n`, elementId: restId, fermata };
 };
 
 
@@ -731,6 +756,9 @@ interface TupletEventResult {
 	mordents: MordentRef[];
 	turns: TurnRef[];
 	arpeggios: ArpegRef[];
+	pedals: PedalMark[];  // pedal marks on notes inside the tuplet (independent events)
+	fingerings: FingerRef[];  // fingering marks on notes inside the tuplet
+	markups: MarkupRef[];  // text directions (markup) on notes inside the tuplet
 	endingClef?: string;  // Updated clef name if changed inside the tuplet
 }
 
@@ -774,6 +802,9 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	const mordents: MordentRef[] = [];
 	const turns: TurnRef[] = [];
 	const arpeggios: ArpegRef[] = [];
+	const pedals: PedalMark[] = [];
+	const fingerings: FingerRef[] = [];
+	const markups: MarkupRef[] = [];
 
 	// Handle internal beam groups: if notes have manual beam marks, respect them
 	const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
@@ -808,12 +839,20 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			if (result.slurEnd) slurEnds.push(result.elementId);
 
 			// Collect other control events
-			if (result.dynamic) dynamics.push({ startid: result.elementId, label: result.dynamic });
+			if (result.dynamics) for (const label of result.dynamics) dynamics.push({ startid: result.elementId, label });
 			if (result.fermata) fermatas.push({ startid: result.elementId, shape: result.fermata === 'short' ? 'angular' : undefined });
 			if (result.trill) trills.push({ startid: result.elementId });
 			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 });
+			if (result.pedals) for (const dir of result.pedals) pedals.push({ startId: result.elementId, dir });
+			// Fingerings and text directions (markup) on inner notes are control
+			// events that attach by id — collect them so the layer loop can emit
+			// <fing>/<dir> for them (previously silently dropped inside tuplets).
+			for (const fing of result.fingerings)
+				fingerings.push({ startid: result.elementId, finger: fing.finger, placement: fing.placement });
+			for (const mkup of result.markups)
+				markups.push({ startid: result.elementId, content: mkup.content, placement: mkup.placement });
 
 			// Close beam if this note ends a beam group
 			if (hasInternalBeams && markOptions.beamEnd && beamOpen) {
@@ -822,7 +861,9 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			}
 		} else if (e.type === 'rest') {
 			const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals).xml;
+			const restResult = restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals);
+			xml += restResult.xml;
+			if (restResult.fermata) fermatas.push({ startid: restResult.elementId, shape: restResult.fermata === 'short' ? 'angular' : undefined });
 		} else if (e.type === 'context') {
 			const ctx = e as ContextChange;
 			if (ctx.clef && ctx.clef !== activeClef) {
@@ -844,7 +885,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	}
 
 	xml += `${indent}</tuplet>\n`;
-	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, endingClef };
+	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, pedals, fingerings, markups, endingClef };
 };
 
 
@@ -997,7 +1038,7 @@ interface SlurSpan {
 
 // Tie state for cross-measure ties - maps staff:layer to pending pitches
 type TieState = Record<string, Pitch[]>;
-type SlurState = Record<string, string | null>;  // voice key -> pending slur startId
+type SlurState = Record<string, string[]>;  // voice key -> open slur startIds (stack, oldest first)
 type HairpinState = Record<string, { form: 'cres' | 'dim'; startId: string } | null>;  // voice key -> pending hairpin
 
 // Pending octave span for cross-measure continuation
@@ -1032,7 +1073,7 @@ interface LayerResult {
 	barlines: BarlineRef[];
 	markups: MarkupRef[];
 	pendingTiePitches: Pitch[];  // For cross-measure tie tracking
-	pendingSlur: string | null;  // For cross-measure slur tracking (startId)
+	pendingSlur: string[];  // For cross-measure slur tracking (all open slur startIds)
 	pendingHairpin: { form: 'cres' | 'dim'; startId: string } | null;  // For cross-measure hairpin tracking
 	pendingOctave: PendingOctave | null;  // For cross-measure ottava span tracking
 	ottavaExplicitlyClosed: boolean;  // True if ottava was closed by explicit \ottava #0 in this layer
@@ -1071,7 +1112,7 @@ const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEve
 };
 
 // Encode a layer (voice)
-const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePitches: Pitch[] = [], keyFifths: number = 0, initialClef?: Clef, initialSlur: string | null = null, initialHairpin: { form: 'cres' | 'dim'; startId: string } | null = null, initialOctave: PendingOctave | null = null): LayerResult => {
+const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePitches: Pitch[] = [], keyFifths: number = 0, initialClef?: Clef, initialSlurs: string[] = [], initialHairpin: { form: 'cres' | 'dim'; startId: string } | null = null, initialOctave: PendingOctave | null = null): LayerResult => {
 	const layerId = generateId("layer");
 	let xml = `${indent}<layer xml:id="${layerId}" n="${layerN}">\n`;
 
@@ -1081,9 +1122,13 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	// Track current clef to only emit changes
 	let currentClef: Clef | undefined = initialClef;
 
-	// Track hairpin spans
+	// Track hairpin spans. Use a stack of open hairpins (not a single slot): the
+	// flattened layer stream can interleave overlapping/cross-staff hairpins
+	// (e.g. a crescendo starting before the previous one ended), and a single slot
+	// would silently overwrite the earlier one. Seed with any hairpin still open
+	// from the previous measure (cross-measure carry).
 	const hairpins: HairpinSpan[] = [];
-	let currentHairpin: { form: 'cres' | 'dim'; startId: string } | null = initialHairpin;
+	const openHairpins: { form: 'cres' | 'dim'; startId: string }[] = initialHairpin ? [initialHairpin] : [];
 
 	// Track pedal marks (each is independent, not paired spans)
 	const pedals: PedalMark[] = [];
@@ -1098,9 +1143,15 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	let lastNoteId: string | null = null;  // Track last note id for ending ottava spans
 	let ottavaExplicitlyClosed: boolean = false;  // Track if ottava was explicitly closed by \ottava #0
 
-	// Track slur spans - slurs must be encoded as control events in MEI
+	// Track slur spans - slurs must be encoded as control events in MEI.
+	// A single slot can't hold the overlapping/concurrent slurs that piano writing
+	// produces (measured up to 3 open at once per voice); a new start while one was
+	// open overwrote it and the span was lost. Use a STACK and pair each end to the
+	// most-recent open slur (LIFO), matching the hairpin fix. `currentSlur` is kept
+	// as a view of the stack top for the existing cross-measure carry plumbing.
 	const slurs: SlurSpan[] = [];
-	let currentSlur: { startId: string } | null = initialSlur ? { startId: initialSlur } : null;
+	const openSlurs: { startId: string }[] = initialSlurs.map(startId => ({ startId }));
+	let currentSlur: { startId: string } | null = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
 
 	// Track arpeggio refs
 	const arpeggios: ArpegRef[] = [];
@@ -1256,38 +1307,48 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 
 				// Track hairpin spans
 				if (result.hairpin === 'crescStart') {
-					currentHairpin = { form: 'cres', startId: result.elementId };
+					openHairpins.push({ form: 'cres', startId: result.elementId });
 				} else if (result.hairpin === 'dimStart') {
-					currentHairpin = { form: 'dim', startId: result.elementId };
-				} else if (result.hairpin === 'end' && currentHairpin) {
+					openHairpins.push({ form: 'dim', startId: result.elementId });
+				} else if ((result.hairpin === 'crescEnd' || result.hairpin === 'dimEnd') && openHairpins.length > 0) {
+					const endForm: 'cres' | 'dim' = result.hairpin === 'crescEnd' ? 'cres' : 'dim';
+					// Close the most-recent open hairpin of the matching form; if none
+					// matches (interleaved/malformed input), fall back to the newest open.
+					let idx = -1;
+					for (let i = openHairpins.length - 1; i >= 0; i--) {
+						if (openHairpins[i].form === endForm) { idx = i; break; }
+					}
+					if (idx < 0) idx = openHairpins.length - 1;
+					const open = openHairpins.splice(idx, 1)[0];
 					hairpins.push({
-						form: currentHairpin.form,
-						startId: currentHairpin.startId,
+						form: open.form,
+						startId: open.startId,
 						endId: result.elementId,
 					});
-					currentHairpin = null;
 				}
 
-				// Track pedal marks (each is independent)
-				if (result.pedal === 'down' || result.pedal === 'up') {
-					pedals.push({
-						startId: result.elementId,
-						dir: result.pedal,
-					});
+				// Track pedal marks (each is independent; a note may carry several,
+				// e.g. an up+down pedal bounce at the same beat).
+				if (result.pedals) {
+					for (const dir of result.pedals) {
+						pedals.push({ startId: result.elementId, dir });
+					}
 				}
 
 				// Track slur spans - end must be processed before start
-				// in case a note ends one slur and starts another
-				if (result.slurEnd && currentSlur) {
+				// in case a note ends one slur and starts another.
+				// Pair an end to the most-recent open slur (LIFO).
+				if (result.slurEnd && openSlurs.length > 0) {
+					const open = openSlurs.pop()!;
 					slurs.push({
-						startId: currentSlur.startId,
+						startId: open.startId,
 						endId: result.elementId,
 					});
-					currentSlur = null;
 				}
 				if (result.slurStart) {
-					currentSlur = { startId: result.elementId };
+					openSlurs.push({ startId: result.elementId });
 				}
+				currentSlur = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
 
 				// Track arpeggio refs
 				if (result.arpeggio) {
@@ -1313,8 +1374,8 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				if (result.turn) {
 					turns.push({ startid: result.elementId });
 				}
-				if (result.dynamic) {
-					dynamics.push({ startid: result.elementId, label: result.dynamic });
+				if (result.dynamics) {
+					for (const label of result.dynamics) dynamics.push({ startid: result.elementId, label });
 				}
 				// Track fingerings
 				for (const fing of result.fingerings) {
@@ -1335,6 +1396,8 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
 				const restResult = restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
 				xml += restResult.xml;
+				// Fermata over a rest (held silence) — emit as a control event on the rest.
+				if (restResult.fermata) fermatas.push({ startid: restResult.elementId, shape: restResult.fermata === 'short' ? 'angular' : undefined });
 				// A leading dynamic/markup attaches to the next event, which may be this rest
 				flushPendingMarkups(restResult.elementId);
 				flushPendingDynamics(restResult.elementId);
@@ -1360,21 +1423,22 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					lastNoteId = tupletResult.firstNoteId;
 				}
 
-				// Process slur ends first (to close any pending slurs from before this tuplet)
+				// Process slur ends first (to close open slurs, LIFO), then starts.
 				for (const endId of tupletResult.slurEnds) {
-					if (currentSlur) {
+					if (openSlurs.length > 0) {
+						const open = openSlurs.pop()!;
 						slurs.push({
-							startId: currentSlur.startId,
+							startId: open.startId,
 							endId: endId,
 						});
-						currentSlur = null;
 					}
 				}
 
 				// Then process slur starts (to open new slurs)
 				for (const startId of tupletResult.slurStarts) {
-					currentSlur = { startId };
+					openSlurs.push({ startId });
 				}
+				currentSlur = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
 
 				// Collect other control events from tuplet
 				dynamics.push(...tupletResult.dynamics);
@@ -1383,6 +1447,9 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				mordents.push(...tupletResult.mordents);
 				turns.push(...tupletResult.turns);
 				arpeggios.push(...tupletResult.arpeggios);
+				pedals.push(...tupletResult.pedals);
+				fingerings.push(...tupletResult.fingerings);
+				markups.push(...tupletResult.markups);
 
 				break;
 			}
@@ -1524,8 +1591,24 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 		? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift, continued: true, emitted: currentOctave.emitted, endToken: currentOctave.endToken, endFallbackId: currentOctave.endFallbackId }
 		: null;
 
+	// Resolve hairpins still open at layer end. The cross-measure carry supports a
+	// single pending hairpin, so keep the OLDEST open span (bottom of stack — most
+	// likely to legitimately continue into the next measure) as pendingHairpin, and
+	// flush the rest here, ending them at the last note so they aren't dropped
+	// (MusicXML files routinely leave wedges unclosed). Without a last note id there
+	// is nothing to attach to, so those are unavoidably dropped.
+	let pendingHairpin: { form: 'cres' | 'dim'; startId: string } | null = null;
+	if (openHairpins.length > 0) {
+		pendingHairpin = openHairpins[0];
+		for (let i = 1; i < openHairpins.length; i++) {
+			if (lastNoteId) {
+				hairpins.push({ form: openHairpins[i].form, startId: openHairpins[i].startId, endId: lastNoteId });
+			}
+		}
+	}
+
 	xml += `${indent}</layer>\n`;
-	return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
+	return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: openSlurs.map(s => s.startId), pendingHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
 };
 
 // Staff result type
@@ -1591,7 +1674,7 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 			const layerN = vi + 1;
 			const tieKey = `${staffN}-${layerN}`;
 			const initialTies = tieState[tieKey] || [];
-			const initialSlur = slurState[tieKey] || null;
+			const initialSlur = slurState[tieKey] || [];
 			const initialHairpin = hairpinState[tieKey] || null;
 			const initialOctave = ottavaState[tieKey] || null;
 			const result = encodeLayer(voice, layerN, indent + '    ', initialTies, keyFifths, endingClef, initialSlur, initialHairpin, initialOctave);
@@ -1617,9 +1700,9 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 				pendingTies[tieKey] = result.pendingTiePitches;
 			}
 			// Track pending slurs for this layer
-			if (result.pendingSlur) {
-				pendingSlurs[tieKey] = result.pendingSlur;
-			}
+			// Always record (even empty) so a measure that closed all its slurs
+			// clears the carried stack rather than leaving a stale open slur.
+			pendingSlurs[tieKey] = result.pendingSlur;
 			// Track pending hairpins for this layer
 			if (result.pendingHairpin) {
 				pendingHairpins[tieKey] = result.pendingHairpin;