@k-l-lambda/lilylet 0.1.73 → 0.1.75

package/source/lilylet/meiEncoder.ts

@@ -29,6 +29,7 @@ import {
 } from "./types";
 import { parseStaffLayout, StaffGroup, StaffGroupType } from "./staffLayout";
 import { gmProgramOf } from "./gmInstruments";
+import { parseMeasureLayout, expandMeasureLayout, collectVoltaSpans } from "./measureLayout";
 
 
 // MEI key signatures: positive = sharps, negative = flats
@@ -410,8 +411,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 +433,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 +477,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 +487,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 +555,7 @@ interface NoteEventResult {
 	elementId: string;
 	hairpin?: string;
 	pedal?: string;
+	pedals?: ('up' | 'down')[];
 	hasTieStart: boolean;
 	pitches: Pitch[];
 	arpeggio: boolean;
@@ -551,7 +563,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 +623,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 +632,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 +686,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 +695,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 +706,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 +715,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 +732,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 };
 };
 
 
@@ -723,6 +749,7 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 interface TupletEventResult {
 	xml: string;
 	firstNoteId: string | null;  // ID of first note in tuplet (for attaching pending markups)
+	lastNoteId: string | null;   // ID of last note/rest in tuplet (for closing/extending ottava spans)
 	slurStarts: string[];  // Note IDs that start slurs
 	slurEnds: string[];    // Note IDs that end slurs
 	dynamics: DynamRef[];
@@ -731,6 +758,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
 }
 
@@ -766,6 +796,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 
 	// Collect control event info from notes inside tuplet
 	let firstNoteId: string | null = null;
+	let lastNoteId: string | null = null;  // last note/rest id — anchors an ottava span end
 	const slurStarts: string[] = [];
 	const slurEnds: string[] = [];
 	const dynamics: DynamRef[] = [];
@@ -774,6 +805,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);
@@ -802,18 +836,27 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			xml += result.xml;
 
 			if (!firstNoteId) firstNoteId = result.elementId;
+			lastNoteId = result.elementId;
 
 			// Collect slur info
 			if (result.slurStart) slurStarts.push(result.elementId);
 			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 +865,10 @@ 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;
+			lastNoteId = restResult.elementId;
+			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 +890,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, lastNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, pedals, fingerings, markups, endingClef };
 };
 
 
@@ -997,7 +1043,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 +1078,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 +1117,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 +1127,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 +1148,48 @@ 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
+	// ── Ottava span anchoring (shared by note / rest / tuplet cases) ──
+	// Originally the open/extend/close logic lived ONLY in `case 'note'`, so an
+	// ottava span running over a tuplet run (ubiquitous in etudes) or over rests
+	// was never opened — the whole span vanished (No.26 10→0, No.20 7→0). These
+	// helpers let any event type anchor a span. Mirror the note-case ordering:
+	// the caller updates lastNoteId to the event's first emitted id, THEN calls
+	// these.
+	// Apply a pending ottava's pitch shift before the event's notes are encoded.
+	const applyPendingOttavaShift = (): void => {
+		if (pendingOttava !== null && pendingOttava !== 0) currentOttavaShift = pendingOttava;
+	};
+	// Extend a carried (endToken) span's end to this event's last emitted id.
+	const extendOttavaEnd = (lastId: string): void => {
+		if (currentOctave?.endToken) octaveEndReplacements[currentOctave.endToken] = lastId;
+	};
+	// Open the pending ottava span on `anchorId` (the event's FIRST emitted id),
+	// closing any open span of a different value first; or resolve a continued span.
+	const applyOttavaAnchor = (anchorId: string): void => {
+		if (pendingOttava !== null && pendingOttava !== 0) {
+			const dis: 8 | 15 = Math.abs(pendingOttava) === 2 ? 15 : 8;
+			const disPlace: 'above' | 'below' = pendingOttava > 0 ? 'above' : 'below';
+			if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
+				octaves.push({ dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, endId: anchorId });
+				currentOctave = null;
+			}
+			if (!currentOctave) currentOctave = { dis, disPlace, startId: anchorId };
+			pendingOttava = null;
+		} else if (currentOctave?.continued) {
+			if (!currentOctave.endToken) currentOctave.startId = anchorId;
+			currentOctave.continued = false;
+		}
+	};
+
+	// 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[] = [];
@@ -1197,9 +1286,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				const tieEnd = pendingTiePitches.length > 0 && pitchesMatch(pendingTiePitches, noteEvent.pitches);
 
 				// If there's a pending ottava, apply it BEFORE encoding the note
-				if (pendingOttava !== null && pendingOttava !== 0) {
-					currentOttavaShift = pendingOttava;  // Apply the shift for this note
-				}
+				applyPendingOttavaShift();
 
 				// For cross-staff notation: set note's staff to currentStaff if different from voice.staff
 				const effectiveNoteEvent = currentStaff !== voice.staff
@@ -1209,9 +1296,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
 				xml += result.xml;
 				lastNoteId = result.elementId;
-				if (currentOctave?.endToken) {
-					octaveEndReplacements[currentOctave.endToken] = result.elementId;
-				}
+				extendOttavaEnd(result.elementId);
 
 				// Flush any pending markups onto this note
 				flushPendingMarkups(result.elementId);
@@ -1220,32 +1305,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				flushPendingDynamics(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;
-					const disPlace: 'above' | 'below' = pendingOttava > 0 ? 'above' : 'below';
-					// Close existing span first if it has a different value
-					if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
-						if (lastNoteId) {
-							octaves.push({
-								dis: currentOctave.dis,
-								disPlace: currentOctave.disPlace,
-								startId: currentOctave.startId,
-								endId: lastNoteId,
-							});
-						}
-						currentOctave = null;
-					}
-					// Start new span if we don't already have one with the same value
-					if (!currentOctave) {
-						currentOctave = { dis, disPlace, startId: result.elementId };
-					}
-					pendingOttava = null;
-				} else if (currentOctave?.continued) {
-					if (!currentOctave.endToken) {
-						currentOctave.startId = result.elementId;
-					}
-					currentOctave.continued = false;
-				}
+				applyOttavaAnchor(result.elementId);
 
 				// Update pending tie pitches
 				if (result.hasTieStart) {
@@ -1256,38 +1316,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 +1383,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) {
@@ -1333,21 +1403,38 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 			case 'rest': {
 				// For cross-staff notation: pass staff number if different from voice's home staff
 				const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
+				// A pending ottava shift applies to a rest's gestural octave too.
+				applyPendingOttavaShift();
 				const restResult = restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
 				xml += restResult.xml;
+				lastNoteId = restResult.elementId;
+				// An ottava span may open on, run through, or close at a rest (e.g. a
+				// span that starts just before LH rests). Anchor it like a note.
+				extendOttavaEnd(restResult.elementId);
+				applyOttavaAnchor(restResult.elementId);
+				// 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);
-				lastNoteId = restResult.elementId;
 				break;
 			}
 			case 'tuplet':
 			case 'times': {
 				// 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
+				// A pending ottava shift applies to the tuplet's notes' written octave.
+				applyPendingOttavaShift();
 				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals, currentClef);
 				xml += tupletResult.xml;
 
+				// An ottava span can open on, run through, or close at a tuplet (common
+				// in etudes where the 8va covers a whole tuplet run). Anchor the span on
+				// the tuplet's FIRST note and let its LAST note close/extend it — without
+				// this the entire span was dropped (start/close lived only in case 'note').
+				if (tupletResult.firstNoteId) applyOttavaAnchor(tupletResult.firstNoteId);
+				if (tupletResult.lastNoteId) extendOttavaEnd(tupletResult.lastNoteId);
+
 				// Propagate clef change from inside the tuplet to the parent tracker
 				if (tupletResult.endingClef) {
 					currentClef = tupletResult.endingClef as Clef;
@@ -1357,24 +1444,25 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				if (tupletResult.firstNoteId) {
 					flushPendingMarkups(tupletResult.firstNoteId);
 					flushPendingDynamics(tupletResult.firstNoteId);
-					lastNoteId = tupletResult.firstNoteId;
+					lastNoteId = tupletResult.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 +1471,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;
 			}
@@ -1415,9 +1506,22 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 							}
 							currentOctave = null;
 							ottavaExplicitlyClosed = true;  // Mark that we explicitly closed the span
+						} else if (currentOctave && currentOctave.emitted) {
+							// Stop landed at measure START (no note yet in this layer) but the
+							// span was carried+emitted in a PREVIOUS measure: it genuinely ends
+							// here. Its deferred endToken was already resolved to the correct
+							// last note by extendOttavaEnd as the span ran through prior measures
+							// (or by the staff-level carry's endFallbackId), so DON'T rewrite it
+							// here — just clear the slot and mark closed, so a later same-value
+							// ottava opens a NEW span instead of folding into this one.
+							// Without this, sequential cross-measure spans collapse into one
+							// (No.57: 18 spans → 8).
+							currentOctave = null;
+							ottavaExplicitlyClosed = true;
 						}
-						// Note: if no lastNoteId (e.g., at measure start), keep currentOctave alive
-						// It may be continued by a subsequent ottava command with the same value
+						// Note: if no lastNoteId and not yet emitted (e.g., open+close at
+						// measure start with no notes), keep currentOctave alive — it may be
+						// continued by a subsequent ottava command with the same value.
 						currentOttavaShift = 0;  // Reset the shift (will be restored if continued)
 					} else {
 						// Check if this continues an existing span (same value)
@@ -1524,8 +1628,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 +1711,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 +1737,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;
@@ -1783,8 +1903,9 @@ const BARLINE_TO_MEI: Record<string, string> = {
 
 // Encode a measure
 // encodeMeasure accepts mutable tieState, slurState, hairpinState, ottavaState and clefState that persist across measures
-const encodeMeasure = (measure: Measure, measureN: number, indent: string, totalStaves: number, tieState: TieState, slurState: SlurState, hairpinState: HairpinState, ottavaState: OttavaState, keyFifths: number = 0, partInfos: PartInfo[] = [], clefState: ClefState = {}, octaveEndReplacements: Record<string, string> = {}): string => {
+const encodeMeasure = (measure: Measure, measureN: number, indent: string, totalStaves: number, tieState: TieState, slurState: SlurState, hairpinState: HairpinState, ottavaState: OttavaState, keyFifths: number = 0, partInfos: PartInfo[] = [], clefState: ClefState = {}, octaveEndReplacements: Record<string, string> = {}, measureIds?: string[]): string => {
 	const measureId = generateId("measure");
+	if (measureIds) measureIds.push(measureId);
 	let staffContent = '';  // Build staff content first, then add measure tag with barline
 	const allHairpins: HairpinSpan[] = [];
 	const allPedals: PedalMark[] = [];
@@ -2617,6 +2738,33 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	mei += `${indent}${indent}${indent}${indent}<score xml:id="${generateId("score")}">\n`;
 	mei += encodeScoreDef(keySig, currentTimeNum, currentTimeDen, partInfos, `${indent}${indent}${indent}${indent}${indent}`, currentMeterSymbol, doc.metadata?.staves, doc.metadata?.instruments);
 	mei += `${indent}${indent}${indent}${indent}${indent}<section xml:id="${generateId("section")}">\n`;
+	// Splice point for an <expansion> element (must be the FIRST child of
+	// <section>, but its plist needs the measure ids collected during the loop
+	// below — so remember where to insert it and build it afterwards).
+	const expansionInsertPos = mei.length;
+	const measureIds: string[] = [];
+
+	// Volta (1st/2nd-ending) house brackets. The measure-layout directive already
+	// encodes which measures form each alternate; <expansion> replays them but does
+	// NOT draw the 1./2. brackets. So derive each alternate's contiguous measure
+	// span and wrap that run of <measure>s in an <ending n="N"> container (verovio's
+	// own MusicXML import does the same). Keyed by the 1-based measure index where
+	// an ending opens / closes.
+	const endingOpenAt = new Map<number, number>();   // measure index → ending number
+	const endingCloseAt = new Set<number>();           // measure index after which </ending> closes
+	if (doc.metadata?.measureLayout) {
+		try {
+			const spans = collectVoltaSpans(parseMeasureLayout(doc.metadata.measureLayout));
+			for (const s of spans) {
+				// Only wrap a contiguous ascending run (a house is always adjacent bars).
+				const lo = s.measures[0];
+				const hi = s.measures[s.measures.length - 1];
+				const contiguous = s.measures.every((m, k) => m === lo + k);
+				if (contiguous) { endingOpenAt.set(lo, s.number); endingCloseAt.add(hi); }
+			}
+		} catch { /* malformed layout → no house brackets, expansion path handles the rest */ }
+	}
+	let endingOpen = false;   // whether an <ending> is currently open in the output
 
 	// Track tie state across measures for cross-measure ties
 	const tieState: TieState = {};
@@ -2727,8 +2875,53 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 				mei += `${sd}</scoreDef>\n`;
 			}
 		}
-		mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
+		const mIndex = mi + 1;
+		const mIndent = `${indent}${indent}${indent}${indent}${indent}${indent}`;
+		// Open an <ending> house bracket if this measure starts an alternate.
+		const openNum = endingOpenAt.get(mIndex);
+		if (openNum !== undefined && !endingOpen) {
+			const lendsym = openNum === 1 ? ' lendsym="angledown"' : '';
+			mei += `${mIndent}<ending xml:id="${generateId('ending')}" n="${openNum}"${lendsym}>\n`;
+			endingOpen = true;
+		}
+		const measureIndent = endingOpen ? `${mIndent}${indent}` : mIndent;
+		mei += encodeMeasure(measure, mIndex, measureIndent, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements, measureIds);
+		// Close the <ending> after the measure that ends this alternate.
+		if (endingOpen && endingCloseAt.has(mIndex)) {
+			mei += `${mIndent}</ending>\n`;
+			endingOpen = false;
+		}
 	});
+	// Defensive: never leave an <ending> unclosed at the end of the section.
+	if (endingOpen) { mei += `${indent}${indent}${indent}${indent}${indent}${indent}</ending>\n`; endingOpen = false; }
+
+	// Emit an <expansion> describing playback order from the measure-layout
+	// directive ([measures "..."]). Verovio's expand="…" consumes its plist to
+	// unfold repeats for MIDI/time-map output. Inserted as the first child of
+	// <section>; ids were collected in the measure loop above.
+	if (doc.metadata?.measureLayout) {
+		try {
+			const layout = parseMeasureLayout(doc.metadata.measureLayout);
+			const order = expandMeasureLayout(layout);
+			const refs: string[] = [];
+			for (const idx of order) {
+				const id = measureIds[idx - 1];   // 1-based index into notated measures
+				if (id === undefined) {
+					console.warn(`[measures] index ${idx} out of range (only ${measureIds.length} measures); skipping`);
+					continue;
+				}
+				refs.push(`#${id}`);
+			}
+			if (refs.length > 0) {
+				const expIndent = `${indent}${indent}${indent}${indent}${indent}${indent}`;
+				const expXml = `${expIndent}<expansion xml:id="${generateId("expansion")}" plist="${refs.join(" ")}" />\n`;
+				mei = mei.slice(0, expansionInsertPos) + expXml + mei.slice(expansionInsertPos);
+			}
+		}
+		catch (err) {
+			console.warn(`[measures] failed to parse "${doc.metadata.measureLayout}": ${(err as Error).message}`);
+		}
+	}
 
 	mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
 	mei += `${indent}${indent}${indent}${indent}</score>\n`;