@k-l-lambda/lilylet 0.1.62 → 0.1.64

package/source/lilylet/abcDecoder.ts

@@ -758,13 +758,13 @@ const convertEventTerm = (
 	const firstPitch = chord.pitches[0];
 
 	// Check if rest
-	if (firstPitch.phonet === "z" || firstPitch.phonet === "Z" || firstPitch.phonet === "x") {
+	if (firstPitch.phonet === "z" || firstPitch.phonet === "Z" || firstPitch.phonet === "x" || firstPitch.phonet === "y") {
 		const duration = convertDuration(eventData.duration, unitLength);
 		const rest: RestEvent = {
 			type: "rest",
 			duration,
 		};
-		if (firstPitch.phonet === "x") {
+		if (firstPitch.phonet === "x" || firstPitch.phonet === "y") {
 			rest.invisible = true;
 		}
 		if (firstPitch.phonet === "Z") {
@@ -779,7 +779,7 @@ const convertEventTerm = (
 
 	// Note or chord
 	const pitches = chord.pitches.filter(p =>
-		p.phonet !== "z" && p.phonet !== "Z" && p.phonet !== "x"
+		p.phonet !== "z" && p.phonet !== "Z" && p.phonet !== "x" && p.phonet !== "y"
 	).map(convertPitch);
 
 	if (pitches.length === 0) return undefined;
@@ -865,8 +865,17 @@ const decodeTune = (tune: ABC.Tune): LilyletDoc => {
 	let timeSig: TimeSig | undefined;
 	let keySig: KeySignature | undefined;
 	let tempo: Tempo | undefined;
-	const voiceConfigs = new Map<number, VoiceConfig>();
-	const voiceClefs = new Map<number, Clef>();
+	const voiceConfigs = new Map<number | string, VoiceConfig>();
+	const voiceClefs = new Map<number | string, Clef>();
+
+	// Pre-scan for unit length (needed for bare Q: tempo)
+	for (const h of headers) {
+		const hdr = h as { name: string; value: any };
+		if (hdr.name === "L" && hdr.value?.numerator && hdr.value?.denominator) {
+			unitLength = hdr.value;
+			break;
+		}
+	}
 
 	for (const h of headers) {
 		if ((h as any).comment) continue;
@@ -905,24 +914,43 @@ const decodeTune = (tune: ABC.Tune): LilyletDoc => {
 					const beatDuration = convertDuration(header.value.note, { numerator: 1, denominator: 1 });
 					tempo = { beat: beatDuration, bpm: header.value.bpm };
 				} else if (typeof header.value === "number") {
-					tempo = { bpm: header.value };
+					const beat = convertDuration({ numerator: 1, denominator: 1 }, unitLength);
+					tempo = { beat, bpm: header.value };
 				}
 				break;
 			case "V": {
 				const voiceValue = header.value;
 				if (voiceValue) {
-					const voiceNum = typeof voiceValue === "number" ? voiceValue :
-						(voiceValue.name || 1);
-					const clefStr = typeof voiceValue === "string" ? voiceValue :
-						(voiceValue.clef || undefined);
-					voiceConfigs.set(voiceNum, {
-						name: voiceNum,
+					let voiceId: number | string;
+					let clefStr: string | undefined;
+
+					if (typeof voiceValue === "number") {
+						voiceId = voiceValue;
+					} else if (typeof voiceValue === "string") {
+						voiceId = voiceValue;
+					} else {
+						const rawClef = (voiceValue.clef || "").replace(/,+$/, "").trim();
+						const isKnownClef = !!convertClef(rawClef);
+						if (isKnownClef) {
+							// V:1 treble  → voiceId=number, clef=treble
+							voiceId = voiceValue.name || 1;
+							clefStr = rawClef;
+						} else {
+							// V:S clef=treble  → voiceId=voiceName, clef from properties
+							voiceId = rawClef || voiceValue.name || 1;
+							const propClef = (voiceValue.properties?.clef || "").replace(/,+$/, "").trim();
+							clefStr = propClef || undefined;
+						}
+					}
+
+					voiceConfigs.set(voiceId, {
+						name: typeof voiceId === "number" ? voiceId : 1,
 						clef: clefStr,
-						properties: voiceValue.properties,
+						properties: voiceValue?.properties,
 					});
 					if (clefStr) {
 						const clef = convertClef(clefStr);
-						if (clef) voiceClefs.set(voiceNum, clef);
+						if (clef) voiceClefs.set(voiceId, clef);
 					}
 				}
 				break;

package/source/lilylet/lilypondEncoder.ts

@@ -577,6 +577,8 @@ const encodeTupletEvent = (event: TupletEvent | TimesEvent, env: PitchEnv, lastD
 			result += str + ' ';
 			newEnv = ne;
 			newDuration = nd;
+		} else if (subEvent.type === 'context') {
+			result += encodeContextChange(subEvent) + ' ';
 		}
 	}
 

package/source/lilylet/meiEncoder.ts

@@ -655,6 +655,7 @@ interface TupletEventResult {
 	mordents: MordentRef[];
 	turns: TurnRef[];
 	arpeggios: ArpegRef[];
+	endingClef?: string;  // Updated clef name if changed inside the tuplet
 }
 
 // Check if a tuplet has balanced internal beam groups (both [ and ] inside the same tuplet)
@@ -673,7 +674,7 @@ const tupletHasInternalBeams = (event: TupletEvent): boolean => {
 };
 
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>): TupletEventResult => {
+const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>, currentClef?: 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
@@ -701,6 +702,8 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	// Handle internal beam groups: if notes have manual beam marks, respect them
 	const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
 	let beamOpen = false;
+	let activeClef = currentClef;
+	let endingClef: string | undefined;
 
 	for (const e of event.events) {
 		if (e.type === 'note') {
@@ -744,6 +747,19 @@ 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);
+		} else if (e.type === 'context') {
+			const ctx = e as ContextChange;
+			if (ctx.clef && ctx.clef !== activeClef) {
+				const layerStaffNum = layerStaff || 1;
+				const effectiveStaffNum = effectiveStaff ?? layerStaffNum;
+				if (effectiveStaffNum === layerStaffNum) {
+					const clefIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+					const clefInfo = CLEF_SHAPES[ctx.clef] || CLEF_SHAPES.treble;
+					xml += `${clefIndent}<clef xml:id="${generateId('clef')}" shape="${clefInfo.shape}" line="${clefInfo.line}" />\n`;
+				}
+				activeClef = ctx.clef;
+				endingClef = ctx.clef;
+			}
 		}
 	}
 
@@ -753,7 +769,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	}
 
 	xml += `${indent}</tuplet>\n`;
-	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, endingClef };
 };
 
 
@@ -911,6 +927,10 @@ interface PendingOctave {
 	disPlace: 'above' | 'below';
 	startId: string;
 	shift: number;  // The ottava value (1, -1, 2, -2)
+	continued?: boolean;
+	emitted?: boolean;
+	endToken?: string;
+	endFallbackId?: string;
 }
 type OttavaState = Record<string, PendingOctave | null>;  // voice key -> pending octave span
 
@@ -940,6 +960,7 @@ interface LayerResult {
 	endingClef?: Clef;  // For cross-measure clef tracking
 	lastNoteId: string | null;  // For cross-measure ottava span end tracking
 	currentOttavaShift: number;  // Current ottava shift for pitch encoding
+	octaveEndReplacements: Record<string, string>;
 }
 
 
@@ -949,7 +970,7 @@ const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEve
 		const markOptions = extractMarkOptions((event as NoteEvent).marks);
 		return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };
 	}
-	if (event.type === 'tuplet') {
+	if (event.type === 'tuplet' || event.type === 'times') {
 		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>
@@ -990,8 +1011,9 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 
 	// Track octave spans - initialize from previous measure if continuing
 	const octaves: OctaveSpan[] = [];
-	let currentOctave: { dis: 8 | 15; disPlace: 'above' | 'below'; startId: string } | null =
-		initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId } : null;
+	const octaveEndReplacements: Record<string, string> = {};
+	let currentOctave: { dis: 8 | 15; disPlace: 'above' | 'below'; startId: string; continued?: boolean; emitted?: boolean; endToken?: string; endFallbackId?: string } | null =
+		initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId, continued: initialOctave.continued, emitted: initialOctave.emitted, endToken: initialOctave.endToken, endFallbackId: initialOctave.endFallbackId } : null;
 	let pendingOttava: number | null = null;  // Track ottava to apply to next note
 	let currentOttavaShift: number = initialOctave?.shift || 0;  // Track current ottava shift for pitch encoding
 	let lastNoteId: string | null = null;  // Track last note id for ending ottava spans
@@ -1099,6 +1121,9 @@ 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;
+				}
 
 				// Flush any pending markups onto this note
 				flushPendingMarkups(result.elementId);
@@ -1109,9 +1134,14 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					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)) {
-						// Different value - close the old span
-						// Use the lastNoteId from before this note (which we saved before processing)
-						// Note: The span from previous measure will be closed by encodeMeasure
+						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
@@ -1119,6 +1149,11 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 						currentOctave = { dis, disPlace, startId: result.elementId };
 					}
 					pendingOttava = null;
+				} else if (currentOctave?.continued) {
+					if (!currentOctave.endToken) {
+						currentOctave.startId = result.elementId;
+					}
+					currentOctave.continued = false;
 				}
 
 				// Update pending tie pitches
@@ -1210,12 +1245,18 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
 				break;
 			}
-			case 'tuplet': {
+			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
-				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
+				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals, currentClef);
 				xml += tupletResult.xml;
 
+				// Propagate clef change from inside the tuplet to the parent tracker
+				if (tupletResult.endingClef) {
+					currentClef = tupletResult.endingClef as Clef;
+				}
+
 				// Flush any pending markups onto the first note of the tuplet
 				if (tupletResult.firstNoteId) {
 					flushPendingMarkups(tupletResult.firstNoteId);
@@ -1268,12 +1309,14 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					if (ctx.ottava === 0) {
 						// End current ottava span
 						if (currentOctave && lastNoteId) {
-							octaves.push({
-								dis: currentOctave.dis,
-								disPlace: currentOctave.disPlace,
-								startId: currentOctave.startId,
-								endId: lastNoteId,
-							});
+							if (!currentOctave.emitted) {
+								octaves.push({
+									dis: currentOctave.dis,
+									disPlace: currentOctave.disPlace,
+									startId: currentOctave.startId,
+									endId: lastNoteId,
+								});
+							}
 							currentOctave = null;
 							ottavaExplicitlyClosed = true;  // Mark that we explicitly closed the span
 						}
@@ -1285,7 +1328,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 						const dis: 8 | 15 = Math.abs(ctx.ottava) === 2 ? 15 : 8;
 						const disPlace: 'above' | 'below' = ctx.ottava > 0 ? 'above' : 'below';
 						if (currentOctave && currentOctave.dis === dis && currentOctave.disPlace === disPlace) {
-							// Continuation - restore the shift but don't change the span
+							// Continuation - restore the shift and let the existing 8va line reach this measure's first note
 							currentOttavaShift = ctx.ottava;
 						} else {
 							// Different value - start new ottava span (will be applied to next note)
@@ -1361,14 +1404,25 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 		xml += `${baseIndent}</beam>\n`;
 	}
 
-	// Don't close ottava span at measure end - it may continue in the next measure
-	// Build pending octave state to return
+	// Emit one visible octave span for a continuing ottava; a repeated same-value command can extend it to the next measure.
+	if (currentOctave && lastNoteId && !currentOctave.emitted) {
+		const endToken = `__OTTAVA_END_${generateId('octaveEnd')}__`;
+		octaves.push({
+			dis: currentOctave.dis,
+			disPlace: currentOctave.disPlace,
+			startId: currentOctave.startId,
+			endId: endToken,
+		});
+		currentOctave.emitted = true;
+		currentOctave.endToken = endToken;
+		currentOctave.endFallbackId = lastNoteId;
+	}
 	const pendingOctave: PendingOctave | null = currentOctave
-		? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift }
+		? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift, continued: true, emitted: currentOctave.emitted, endToken: currentOctave.endToken, endFallbackId: currentOctave.endFallbackId }
 		: null;
 
 	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 };
+	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 };
 };
 
 // Staff result type
@@ -1395,6 +1449,7 @@ interface StaffResult {
 	pendingOctaves: OttavaState;  // For cross-measure ottava span tracking
 	ottavaExplicitlyClosed: Record<string, boolean>;  // Track which layers had ottava explicitly closed
 	lastNoteIds: Record<string, string | null>;  // For cross-measure ottava span end tracking
+	octaveEndReplacements: Record<string, string>;
 	endingClef?: Clef;  // For cross-measure clef tracking
 }
 
@@ -1423,6 +1478,7 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 	const pendingOctaves: OttavaState = {};
 	const ottavaExplicitlyClosed: Record<string, boolean> = {};
 	const lastNoteIds: Record<string, string | null> = {};
+	const octaveEndReplacements: Record<string, string> = {};
 	let endingClef: Clef | undefined = initialClef;
 
 	if (voices.length === 0) {
@@ -1452,6 +1508,7 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 			allHarmonies.push(...result.harmonies);
 			allBarlines.push(...result.barlines);
 			allMarkups.push(...result.markups);
+			Object.assign(octaveEndReplacements, result.octaveEndReplacements);
 			// Track pending ties for this layer
 			if (result.pendingTiePitches.length > 0) {
 				pendingTies[tieKey] = result.pendingTiePitches;
@@ -1505,6 +1562,7 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 		pendingOctaves,
 		ottavaExplicitlyClosed,
 		lastNoteIds,
+		octaveEndReplacements,
 		endingClef,
 	};
 };
@@ -1592,7 +1650,7 @@ 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 = {}): 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> = {}): string => {
 	const measureId = generateId("measure");
 	let staffContent = '';  // Build staff content first, then add measure tag with barline
 	const allHairpins: HairpinSpan[] = [];
@@ -1668,38 +1726,22 @@ const encodeMeasure = (measure: Measure, measureN: number, indent: string, total
 		allHarmonies.push(...result.harmonies);
 		allBarlines.push(...result.barlines);
 		allMarkups.push(...result.markups);
+		Object.assign(octaveEndReplacements, result.octaveEndReplacements);
 		// Update tie state with pending ties from this staff
 		Object.assign(tieState, result.pendingTies);
 		// Update slur state with pending slurs from this staff
 		Object.assign(slurState, result.pendingSlurs);
 		// Update hairpin state with pending hairpins from this staff
 		Object.assign(hairpinState, result.pendingHairpins);
-		// Update ottava state with pending octaves from this staff
-		// Also handle closing spans when ottava ends
+		// Update ottava state with pending octaves from this staff.
+		// encodeLayer already emits measure-local octave spans, so keep the next measure's start independent.
 		const currentStaffPrefix = `${si}-`;
 		for (const [key, pending] of Object.entries(result.pendingOctaves)) {
 			if (pending) {
-				// Check if this is a continuation or a new span
-				const prevPending = ottavaState[key];
-				if (prevPending && prevPending.shift === pending.shift) {
-					// Same ottava value continues - keep the original startId
-					ottavaState[key] = { ...pending, startId: prevPending.startId };
-				} else {
-					// Different ottava value - close the old span first if exists
-					if (prevPending) {
-						const lastNoteId = result.lastNoteIds[key];
-						if (lastNoteId) {
-							allOctaves.push({
-								dis: prevPending.dis,
-								disPlace: prevPending.disPlace,
-								startId: prevPending.startId,
-								endId: lastNoteId,
-							});
-						}
-					}
-					// Start new span
-					ottavaState[key] = pending;
+				if (pending.endToken && pending.endFallbackId && !octaveEndReplacements[pending.endToken]) {
+					octaveEndReplacements[pending.endToken] = pending.endFallbackId;
 				}
+				ottavaState[key] = pending;
 			}
 		}
 		// For layers in this staff that had pending octaves but didn't in this measure, close the spans
@@ -1944,7 +1986,7 @@ const docHasBeamMarks = (doc: LilyletDoc): boolean => {
 								if (m.markType === 'beam') return true;
 							}
 						}
-					} else if (event.type === 'tuplet') {
+					} else if (event.type === 'tuplet' || event.type === 'times') {
 						const tuplet = event as TupletEvent;
 						for (const e of tuplet.events) {
 							if (e.type === 'note') {
@@ -2119,7 +2161,7 @@ const applyAutoBeamToVoice = (events: Event[], beamGroups: number[]): void => {
 			// Rests break beam groups
 			flushRun();
 			position += dur;
-		} else if (event.type === 'tuplet') {
+		} else if (event.type === 'tuplet' || event.type === 'times') {
 			const tuplet = event as TupletEvent;
 			const ratio = tuplet.ratio; // LilyPond ratio: num/den
 
@@ -2303,6 +2345,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 
 	// Track ottava state across measures for cross-measure ottava spans
 	const ottavaState: OttavaState = {};
+	const octaveEndReplacements: Record<string, string> = {};
 
 	// Initialize clef state from partInfos (convert local staff to global staff)
 	const clefState: ClefState = {};
@@ -2321,7 +2364,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 				for (const event of voice.events) {
 					// Check for actual musical content (not just context changes or pitch resets)
 					if (event.type === 'note' || event.type === 'rest' ||
-						event.type === 'tuplet' || event.type === 'tremolo') {
+						event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
 						return true;
 					}
 				}
@@ -2362,7 +2405,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 				mei += `${indent}${indent}${indent}${indent}${indent}${indent}<scoreDef xml:id="${generateId('scoredef')}"${meterSymAttr} meter.count="${currentTimeNum}" meter.unit="${currentTimeDen}" />\n`;
 			}
 		}
-		mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState);
+		mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
 	});
 
 	mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
@@ -2372,6 +2415,10 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	mei += `${indent}</music>\n`;
 	mei += '</mei>\n';
 
+	for (const [token, endId] of Object.entries(octaveEndReplacements)) {
+		mei = mei.replaceAll(token, endId);
+	}
+
 	return mei;
 };