@k-l-lambda/lilylet 0.1.63 → 0.1.64

package/lib/tests/unit/tupletWithBaseDuration.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Unit test: \tuplet N/M D { notes } with base-duration argument must
+ * preserve the tuplet wrapper in the decoded doc.
+ *
+ * Bug: The LilyPond decoder accessed args[1].body to find the tuplet body,
+ * but \tuplet 3/2 4 { ... } has args = ["3/2", "4", {body}].
+ * args[1] is "4" (the base duration), not the music block, so body was
+ * empty and all notes were silently decoded as plain notes outside any tuplet.
+ *
+ * Real-world case: chopin-28-14.ly — every measure is wrapped in
+ *   \tuplet 3/2 4 { | notes }
+ * producing 12 eighth notes in the time of 8, but the decoded lyl had
+ * no \times wrapper at all.
+ *
+ * Usage: npx tsx tests/unit/tupletWithBaseDuration.test.ts
+ */
+export {};

package/lib/tests/unit/tupletWithBaseDuration.test.js

@@ -0,0 +1,139 @@
+/**
+ * Unit test: \tuplet N/M D { notes } with base-duration argument must
+ * preserve the tuplet wrapper in the decoded doc.
+ *
+ * Bug: The LilyPond decoder accessed args[1].body to find the tuplet body,
+ * but \tuplet 3/2 4 { ... } has args = ["3/2", "4", {body}].
+ * args[1] is "4" (the base duration), not the music block, so body was
+ * empty and all notes were silently decoded as plain notes outside any tuplet.
+ *
+ * Real-world case: chopin-28-14.ly — every measure is wrapped in
+ *   \tuplet 3/2 4 { | notes }
+ * producing 12 eighth notes in the time of 8, but the decoded lyl had
+ * no \times wrapper at all.
+ *
+ * Usage: npx tsx tests/unit/tupletWithBaseDuration.test.ts
+ */
+import { decode } from "../../source/lilylet/lilypondDecoder.js";
+import { serializeLilyletDoc } from "../../source/lilylet/serializer.js";
+let passed = 0;
+let failed = 0;
+function assert(condition, message) {
+    if (condition) {
+        console.log(`  ✓ ${message}`);
+        passed++;
+    }
+    else {
+        console.error(`  ✗ FAIL: ${message}`);
+        failed++;
+    }
+}
+const LY_BOILERPLATE = `
+\\version "2.22.0"
+\\language "english"
+\\header { tagline = ##f }
+\\layout { \\context { \\Score autoBeaming = ##f } }
+`;
+// Warm-up
+{
+    const w = console.warn, a = console.assert;
+    console.warn = () => { };
+    console.assert = () => { };
+    try {
+        await decode('{ c }');
+    }
+    catch { }
+    console.warn = w;
+    console.assert = a;
+}
+// ─── Test 1: \tuplet 3/2 4 { notes } preserves tuplet ─────────────────────
+// Chopin 28-14 pattern: \tuplet 3/2 4 wraps 12 eighth notes per measure.
+// Without base-duration: \tuplet 3/2 { ef8 bf gf ... } = 12 notes
+// With base-duration:    \tuplet 3/2 4 { | ef8 bf gf ... } = same semantics
+console.log('\nTest 1: \\tuplet 3/2 4 { notes } — tuplet wrapper preserved');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 4 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    assert(doc.measures.length >= 1, `decoded 1 measure (got ${doc.measures.length})`);
+    if (!doc.measures[0])
+        return;
+    const voice = doc.measures[0].parts[0]?.voices[0];
+    assert(!!voice, 'voice exists');
+    if (!voice)
+        return;
+    // The voice should have a tuplet event, NOT 12 bare note events
+    const tuplets = voice.events.filter(e => e.type === 'tuplet' || e.type === 'times');
+    const bareNotes = voice.events.filter(e => e.type === 'note');
+    assert(tuplets.length >= 1, `voice contains at least 1 tuplet/times event (got ${tuplets.length}) — not bare notes`);
+    assert(bareNotes.length === 0, `no bare notes at top level (got ${bareNotes.length}) — all should be inside tuplet`);
+    if (tuplets.length >= 1) {
+        const t = tuplets[0];
+        const innerNotes = t.events.filter(e => e.type === 'note');
+        assert(innerNotes.length === 12, `tuplet contains 12 inner notes (got ${innerNotes.length})`);
+        assert(t.ratio.numerator === 2 && t.ratio.denominator === 3, `ratio is 2/3 (lilylet: play 12 eighth notes in time of 8) — got ${t.ratio.numerator}/${t.ratio.denominator}`);
+    }
+})();
+// ─── Test 2: \tuplet 3/2 (no base duration) — should still work ────────────
+console.log('\nTest 2: \\tuplet 3/2 { notes } without base duration (baseline)');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    const voice = doc.measures[0]?.parts[0]?.voices[0];
+    const tuplets = voice?.events.filter(e => e.type === 'tuplet' || e.type === 'times') ?? [];
+    assert(tuplets.length >= 1, `\\tuplet 3/2 (no base dur) also produces tuplet event (got ${tuplets.length})`);
+})();
+// ─── Test 3: serialized lyl contains \tuplet or \times wrapper ─────────────
+console.log('\nTest 3: serialized lyl contains tuplet notation');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 4 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    const lyl = serializeLilyletDoc(doc);
+    console.log(`  lyl: ${lyl.trim().split('\n').find(l => l.includes('time') || l.includes('tuplet') || l.includes('times')) ?? '(not found)'}`);
+    assert(lyl.includes('\\tuplet') || lyl.includes('\\times'), `serialized lyl contains \\tuplet or \\times notation (got no tuplet wrapper)`);
+})();
+// ─── summary ─────────────────────────────────────────────────────────────────
+console.log(`\n${'═'.repeat(50)}`);
+console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
+process.exit(failed > 0 ? 1 : 0);

package/lib/tests/unit/voiceStaffParsing.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unit tests for voice.staff parsing edge cases from GPT review of the
+ * leadingStaff fix (commit c0763a4, 47fcf61).
+ *
+ * Cases:
+ *   A. non-staff context before \staff "N" in same voice line
+ *   B. second voice after \\ with no explicit \staff (fallback)
+ *   C. trailing | + newline → spurious empty measure filtered
+ *   D. measure with only \bar → filtered as empty
+ *
+ * Usage: npx tsx tests/unit/voiceStaffParsing.test.ts
+ */
+export {};

package/lib/tests/unit/voiceStaffParsing.test.js

@@ -0,0 +1,118 @@
+/**
+ * Unit tests for voice.staff parsing edge cases from GPT review of the
+ * leadingStaff fix (commit c0763a4, 47fcf61).
+ *
+ * Cases:
+ *   A. non-staff context before \staff "N" in same voice line
+ *   B. second voice after \\ with no explicit \staff (fallback)
+ *   C. trailing | + newline → spurious empty measure filtered
+ *   D. measure with only \bar → filtered as empty
+ *
+ * Usage: npx tsx tests/unit/voiceStaffParsing.test.ts
+ */
+import { parseCode } from '../../source/lilylet/parser.js';
+let passed = 0;
+let failed = 0;
+function assert(condition, message) {
+    if (condition) {
+        console.log(`  ✓ ${message}`);
+        passed++;
+    }
+    else {
+        console.error(`  ✗ FAIL: ${message}`);
+        failed++;
+    }
+}
+function voiceStaff(lyl, measureIdx = 0, voiceIdx = 0) {
+    const doc = parseCode(lyl);
+    return doc.measures[measureIdx]?.parts[0]?.voices[voiceIdx]?.staff ?? -1;
+}
+function measureCount(lyl) {
+    return parseCode(lyl).measures.length;
+}
+// ─── Case A1: \clef before \staff "2" ────────────────────────────────────────
+console.log('\nCase A1: \\clef before \\staff "2" — staff must be 2');
+{
+    const lyl = `\\clef "bass" \\staff "2" c4 d e f |`;
+    assert(voiceStaff(lyl) === 2, `\\clef "bass" \\staff "2" c4 → voice.staff=2 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case A2: \key before \staff "2" ─────────────────────────────────────────
+console.log('\nCase A2: \\key before \\staff "2" — staff must be 2');
+{
+    const lyl = `\\key g \\major \\staff "2" c4 d e f |`;
+    assert(voiceStaff(lyl) === 2, `\\key g \\major \\staff "2" → voice.staff=2 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case A3: \time \clef \key before \staff "2" \times ──────────────────────
+console.log('\nCase A3: multiple context events before \\staff "2" \\times');
+{
+    const lyl = `\\time 4/4 \\clef "treble" \\key c \\major \\staff "2" \\times 2/3 { c8 d e } r2. |`;
+    const doc = parseCode(lyl);
+    const voice = doc.measures[0]?.parts[0]?.voices[0];
+    assert(!!voice, 'voice exists');
+    if (voice) {
+        assert(voice.staff === 2, `context chain before \\staff "2" → voice.staff=2 (got ${voice.staff})`);
+        // Verify the event stream: leading context events (non-staff) then staff=2 context before tuplet
+        const staffCtxIdx = voice.events.findIndex((e) => e.type === 'context' && e.staff === 2);
+        const tupletIdx = voice.events.findIndex((e) => e.type === 'tuplet' || e.type === 'times');
+        assert(staffCtxIdx >= 0, `context{staff:2} event exists in events`);
+        assert(tupletIdx >= 0, `tuplet event exists in events`);
+        assert(staffCtxIdx < tupletIdx, `context{staff:2} (idx=${staffCtxIdx}) appears before tuplet (idx=${tupletIdx})`);
+    }
+}
+// ─── Case A4: \staff "1" first, cross-staff switch — staff must be 1 ─────────
+console.log('\nCase A4: \\staff "1" then \\staff "2" — leading staff is 1');
+{
+    const lyl = `\\staff "1" c4 d \\staff "2" e f |`;
+    assert(voiceStaff(lyl) === 1, `\\staff "1" c4 d \\staff "2" e f → voice.staff=1 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case B1: second voice — stale currentStaff=2 must NOT leak ──────────────
+// Voice 0 ends after switching to \staff "2" (currentStaff=2 is stale).
+// Voice 1 has no explicit \staff — should default to staff=1 (part_start reset),
+// NOT inherit the stale currentStaff=2 from voice 0.
+console.log('\nCase B1: second voice (no \\staff) must NOT inherit stale currentStaff=2');
+{
+    const lyl = `\\staff "1" c4 \\staff "2" d e f \\\\ g4 a b c |`;
+    const doc = parseCode(lyl);
+    const voices = doc.measures[0]?.parts[0]?.voices ?? [];
+    assert(voices.length === 2, `two voices parsed (got ${voices.length})`);
+    assert(voices[0].staff === 1, `voice 0 leading \\staff "1" (got ${voices[0]?.staff})`);
+    // part_start resets currentStaff=1 for each part_voices attempt;
+    // if stale currentStaff=2 leaked, voice 1 would wrongly get staff=2
+    assert(voices[1].staff === 1, `voice 1 no \\staff → defaults to 1, not stale 2 (got ${voices[1]?.staff})`);
+}
+// ─── Case B2: \\ then \staff "2" ─────────────────────────────────────────────
+console.log('\nCase B2: second voice starts with \\staff "2"');
+{
+    const lyl = `\\staff "1" c4 d e f \\\\ \\staff "2" c4 d e f |`;
+    const doc = parseCode(lyl);
+    const voices = doc.measures[0]?.parts[0]?.voices ?? [];
+    assert(voices.length === 2, `two voices parsed (got ${voices.length})`);
+    assert(voices[1].staff === 2, `voice 1 \\staff "2" → staff=2 (got ${voices[1]?.staff})`);
+}
+// ─── Case C: trailing newline after last | — no spurious measure ─────────────
+console.log('\nCase C: trailing newline after last | — no spurious empty measure');
+{
+    // lyl with explicit trailing newline
+    const lyl = `\\staff "1" c4 d e f |\n`;
+    const count = measureCount(lyl);
+    assert(count === 1, `exactly 1 measure (got ${count})`);
+}
+// ─── Case D: measure with only \bar — filtered as empty ──────────────────────
+console.log('\nCase D: measure with only \\bar "|." — filtered as empty');
+{
+    const lyl = `\\staff "1" c4 d e f | \\bar "|." |`;
+    const count = measureCount(lyl);
+    // The real measure (c4 d e f) is kept; the barline-only measure is filtered
+    assert(count === 1, `barline-only measure filtered, 1 real measure remains (got ${count})`);
+}
+// ─── Case E: measure with notes then trailing empty measure ──────────────────
+console.log('\nCase E: two real measures, no spurious third');
+{
+    const lyl = `\\staff "1" c4 d e f | g4 a b c |\n`;
+    const count = measureCount(lyl);
+    assert(count === 2, `exactly 2 measures (got ${count})`);
+}
+// ─── Summary ─────────────────────────────────────────────────────────────────
+console.log(`\n${'═'.repeat(50)}`);
+console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
+process.exit(failed > 0 ? 1 : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",

package/source/lilylet/meiEncoder.ts

@@ -927,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
 
@@ -956,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>;
 }
 
 
@@ -1006,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
@@ -1115,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);
@@ -1125,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
@@ -1135,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
@@ -1290,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
 						}
@@ -1307,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)
@@ -1383,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
@@ -1417,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
 }
 
@@ -1445,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) {
@@ -1474,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;
@@ -1527,6 +1562,7 @@ const encodeStaff = (voices: Voice[], staffN: number, indent: string, tieState:
 		pendingOctaves,
 		ottavaExplicitlyClosed,
 		lastNoteIds,
+		octaveEndReplacements,
 		endingClef,
 	};
 };
@@ -1614,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[] = [];
@@ -1690,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
@@ -2325,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 = {};
@@ -2384,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`;
@@ -2394,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;
 };