@k-l-lambda/lilylet 0.1.81 → 0.1.83

package/source/lilylet/highlight.ts

@@ -18,6 +18,7 @@ export type HighlightScope =
 	| "hairpin"
 	| "header"
 	| "keyword"
+	| "lyric"
 	| "markup"
 	| "mode"
 	| "navigation"
@@ -96,6 +97,7 @@ export const HIGHLIGHT_RULES: HighlightRule[] = [
 	{ re: /(?:\\segno\b)/iy, scope: "navigation" },
 	{ re: /(?:\\chords\b)/iy, scope: "keyword" },
 	{ re: /(?:\\markup\b)/iy, scope: "markup" },
+	{ re: /(?:\\addlyrics\b)/iy, scope: "lyric" },
 	{ re: /(?:\\<)/iy, scope: "hairpin" },
 	{ re: /(?:\\>)/iy, scope: "hairpin" },
 	{ re: /(?:\\!)/iy, scope: "hairpin" },
@@ -155,6 +157,13 @@ export const HIGHLIGHT_RULES: HighlightRule[] = [
 	{ re: /(?:=)/iy, scope: "operator" },
 	{ re: /(?:[rR])/iy, scope: "rest" },
 	{ re: /(?:[sS])/iy, scope: "rest" },
+	{ re: /(?:\{)/iy, scope: "brace" },
+	{ re: /(?:\})/iy, scope: "brace" },
+	{ re: /(?:--)/iy, scope: "lyric" },
+	{ re: /(?:__\b)/iy, scope: "lyric" },
+	{ re: /(?:_\b)/iy, scope: "lyric" },
+	{ re: /(?:"([^\"\\]|\\.)*")/iy, scope: "string" },
+	{ re: /(?:[^ \t\r\n{}\"\\]+)/iy, scope: "string" },
 ];
 
 /**

package/source/lilylet/index.ts

@@ -4,6 +4,7 @@ export * from "./parser";
 export * from "./serializer";
 export * from "./staffLayout";
 export * from "./measureLayout";
+export * from "./onsets";
 
 import * as meiEncoder from "./meiEncoder";
 import * as musicXmlDecoder from "./musicXmlDecoder";

package/source/lilylet/lilylet.jison

@@ -34,6 +34,20 @@
 		};
 	};
 
+	// Build a lyric lane (one \addlyrics block) from raw lyric items. `--` is a
+	// connector that hyphenates the preceding syllable (it does not consume a
+	// note slot); `_` is a skipped slot; `__` extends the preceding syllable.
+	const addlyricsLane = (items) => {
+		const syllables = [];
+		for (const it of items) {
+			if (it.text !== undefined) syllables.push({ text: it.text });
+			else if (it.hyphen) { if (syllables.length) syllables[syllables.length - 1].hyphen = true; }
+			else if (it.skip) syllables.push({ skip: true });
+			else if (it.extend) { if (syllables.length) syllables[syllables.length - 1].extend = true; else syllables.push({ extend: true }); }
+		}
+		return { syllables };
+	};
+
 	const restEvent = (dur, options = {}) => ({
 		type: 'rest',
 		duration: dur,
@@ -51,7 +65,7 @@
 		mode,
 	});
 
-	const voice = (staff, events) => {
+	const voice = (staff, events, lyrics) => {
 		// Use the first \staff "N" context event that appears before any musical event
 		// (notes/rests/tuplets) as the authoritative voice.staff.
 		// Skip pitchReset events (from NEWLINE tokens at voice-line boundaries).
@@ -67,9 +81,13 @@
 			}
 			break; // first musical/structural event — stop
 		}
+		// \addlyrics lanes are scoped to THIS voice; verse numbers are 1-based by
+		// order of \addlyrics blocks within the voice.
+		const lanes = lyrics && lyrics.length ? lyrics.map((lane, i) => ({ verse: i + 1, ...lane })) : undefined;
 		return {
 			staff: leadingStaff != null ? leadingStaff : 1,
 			events,
+			lyrics: lanes,
 		};
 	};
 
@@ -241,6 +259,7 @@
 
 %option flex unicode case-insensitive
 
+%x lyric
 
 %%
 
@@ -262,7 +281,7 @@
 \[auto\-beam					return 'HEADER_AUTOBEAM'
 \]								return ']'
 
-\"([^\"\\]|\\.)*\"					return 'STRING'
+\"([^\"\\]|\\.)*\"				return 'STRING'
 
 "\\clef"						return 'CMD_CLEF'
 "\\key"							return 'CMD_KEY'
@@ -292,6 +311,7 @@
 "\\segno"						return 'CMD_SEGNO'
 "\\chords"						return 'CMD_CHORDS'
 "\\markup"						return 'CMD_MARKUP'
+"\\addlyrics"					{ this.pushState('lyric'); return 'CMD_ADDLYRICS'; }
 
 "\\<"							return 'CMD_CRESC_BEGIN'
 "\\>"							return 'CMD_DIM_BEGIN'
@@ -369,6 +389,17 @@
 .								{}
 
 
+<lyric>"{"						return '{'
+<lyric>"}"						{ this.popState(); return '}'; }
+<lyric>[ \t]+					{}
+<lyric>(\r?\n)+					{}
+<lyric>"--"						return 'LYRIC_HYPHEN'
+<lyric>"__"						return 'LYRIC_EXTENDER'
+<lyric>"_"						return 'LYRIC_SKIP'
+<lyric>\"([^\"\\]|\\.)*\"		return 'LYRIC_WORD'
+<lyric>[^ \t\r\n{}\"\\]+		return 'LYRIC_WORD'
+
+
 /lex
 
 %start document
@@ -423,7 +454,7 @@ measures
 	;
 
 measure_content
-	: parts										%{
+	: parts									%{
 		// Check \partial declarations: warn if declared duration ≠ actual voice ticks
 		let partialDur = null;
 		outer: for (const p of $1) {
@@ -454,6 +485,17 @@ measure_content
 	%}
 	;
 
+addlyrics_opt
+	: /* empty */								{ $$ = undefined; }
+	| addlyrics_blocks							{ $$ = $1; }
+	;
+
+addlyrics_blocks
+	: addlyrics_block							{ $$ = [$1]; }
+	| addlyrics_blocks addlyrics_block			{ $$ = $1.concat([$2]); }
+	| addlyrics_blocks NEWLINE					{ $$ = $1; }
+	;
+
 parts
 	: part_voices								{ $$ = [part($1)]; }
 	| parts PART_SEP part_start part_voices		{ $$ = $1.concat([part($4)]); }
@@ -464,8 +506,12 @@ part_start
 	;
 
 part_voices
-	: voice_events								{ $$ = [voice(currentStaff, $1)]; }
-	| part_voices VOICE_SEP voice_events		{ $$ = $1.concat([voice(currentStaff, $3)]); }
+	: voice_block								{ $$ = [voice(currentStaff, $1.events, $1.lyrics)]; }
+	| part_voices VOICE_SEP voice_block			{ $$ = $1.concat([voice(currentStaff, $3.events, $3.lyrics)]); }
+	;
+
+voice_block
+	: voice_events addlyrics_opt				{ $$ = { events: $1, lyrics: $2 }; }
 	;
 
 voice_events
@@ -787,3 +833,19 @@ markup_mark
 glissando_mark
 	: CMD_GLISSANDO								-> glissando()
 	;
+
+addlyrics_block
+	: CMD_ADDLYRICS '{' lyric_sequence '}'		-> addlyricsLane($3)
+	;
+
+lyric_sequence
+	: /* empty */								{ $$ = []; }
+	| lyric_sequence lyric_item					{ $$ = $1.concat([$2]); }
+	;
+
+lyric_item
+	: LYRIC_WORD								-> ({ text: $1.charAt(0) === '"' ? unq($1) : $1 })
+	| LYRIC_HYPHEN								-> ({ hyphen: true })
+	| LYRIC_SKIP								-> ({ skip: true })
+	| LYRIC_EXTENDER							-> ({ extend: true })
+	;

package/source/lilylet/measureLayoutFromXml.ts

@@ -20,7 +20,7 @@
  * always-valid fallback.
  */
 
-import { parseMeasureLayout, expandMeasureLayout } from "./measureLayout";
+import { parseMeasureLayout, expandMeasureLayout, LayoutType } from "./measureLayout";
 import { getDirectChildren, getAttribute } from "./musicXmlUtils";
 
 // One decoded measure's repeat-relevant markup, in source order.
@@ -79,15 +79,9 @@ const simulate = (infos: MeasureRepeatInfo[]): number[] => {
 	const segnoIdx = infos.find(i => i.segno)?.index ?? 1;
 	const codaIdx = infos.find(i => i.coda)?.index;
 
-	// Ending (volta) spans, sorted by start index. On pass P of the enclosing
-	// repeat, the ending whose number === P is played; others are skipped by
-	// jumping to the next ending's start (the last ending is the fallthrough).
-	const endingSpans = infos
-		.filter(i => i.endingStart !== undefined)
-		.map(i => ({ number: i.endingStart!, start: i.index }))
-		.sort((a, b) => a.start - b.start);
-	const nextEndingStartAfter = (idx: number): number | undefined =>
-		endingSpans.find(e => e.start > idx)?.start;
+	// Classify repeat/volta sections once so ending-skip decisions are scoped to
+	// the current repeat section, not a later independent section's endings.
+	const sections = classifyRepeatSections(infos, 1, n);
 
 	const order: number[] = [];
 	const passCount = new Map<number, number>();   // forward-repeat start index → completed passes
@@ -108,12 +102,14 @@ const simulate = (infos: MeasureRepeatInfo[]): number[] => {
 		if (info?.endingStart !== undefined) {
 			const start = repeatStartStack[repeatStartStack.length - 1] ?? 1;
 			const currentPass = (passCount.get(start) ?? 0) + 1;
+			const section = findSectionForIndex(sections, i);
+			const endingSpans = section ? endingSpansForSection(infos, section) : [];
 			const isLastEnding = endingSpans[endingSpans.length - 1]?.start === i;
 			if (info.endingStart !== currentPass && !isLastEnding) {
-				const next = nextEndingStartAfter(i);
+				const next = endingSpans.find(e => e.start > i)?.start;
 				if (next !== undefined) { i = next; continue; }
-				// no further ending: fall past all endings
-				i = i + 1; continue;
+				i = section ? section.hi + 1 : i + 1;
+				continue;
 			}
 		}
 
@@ -125,7 +121,10 @@ const simulate = (infos: MeasureRepeatInfo[]): number[] => {
 		// Fine stop (only after a D.C./D.S. jump has occurred)
 		if (info?.fine && (jumpedDaCapo || jumpedDalSegno)) break;
 
-		// Backward repeat → jump to current repeat-start, counting the pass
+		// Backward repeat → jump to current repeat-start, counting the pass.
+		// If this same measure ALSO carries a D.C./D.S. (e.g. ABC "!D.C.!:|"), the
+		// repeat is resolved FIRST (all passes), then we fall through to the
+		// navigation jump below — the da-capo wraps the repeat, not the reverse.
 		if (info?.repeatEnd) {
 			const start = repeatStartStack[repeatStartStack.length - 1] ?? 1;
 			const times = info.repeatTimes ?? 2;
@@ -133,7 +132,10 @@ const simulate = (infos: MeasureRepeatInfo[]): number[] => {
 			passCount.set(start, done);
 			if (done < times) { i = start; continue; }
 			repeatStartStack = repeatStartStack.filter(s => s !== start);
-			i++; continue;
+			// repeat exhausted: only advance past it when there is no pending
+			// navigation on this measure (otherwise fall through to D.C./D.S.).
+			const hasPendingNav = (info.dacapo && !jumpedDaCapo) || (info.dalsegno && !jumpedDalSegno);
+			if (!hasPendingNav) { i++; continue; }
 		}
 
 		// D.S. (dal segno) — jump back to segno once, arm To-Coda
@@ -157,6 +159,119 @@ const simulate = (infos: MeasureRepeatInfo[]): number[] => {
 
 const rangeCode = (a: number, b: number): string => a === b ? `${a}` : flatToCode(Array.from({ length: b - a + 1 }, (_, k) => a + k));
 
+const isAscendingRun = (seq: number[]): boolean => seq.every((v, i) => i === 0 || v === seq[i - 1] + 1);
+
+const compactFlatToCode = (seq: number[]): string => {
+	const parts: string[] = [];
+	let plain: number[] = [];
+	const flushPlain = (): void => {
+		if (plain.length > 0) {
+			parts.push(flatToCode(plain));
+			plain = [];
+		}
+	};
+
+	let i = 0;
+	while (i < seq.length) {
+		let repeatLen = 0;
+		for (let len = Math.floor((seq.length - i) / 2); len >= 1; len--) {
+			const chunk = seq.slice(i, i + len);
+			if (!isAscendingRun(chunk)) continue;
+			const next = seq.slice(i + len, i + 2 * len);
+			if (JSON.stringify(chunk) === JSON.stringify(next)) { repeatLen = len; break; }
+		}
+
+		if (repeatLen > 0) {
+			flushPlain();
+			parts.push(`2*[${flatToCode(seq.slice(i, i + repeatLen))}]`);
+			i += repeatLen * 2;
+		}
+		else plain.push(seq[i++]);
+	}
+	flushPlain();
+	return parts.join(", ");
+};
+
+const layoutExpandsTo = (code: string, seq: number[], type: LayoutType = LayoutType.Full): boolean => {
+	try {
+		const got = expandMeasureLayout(parseMeasureLayout(code), type);
+		return JSON.stringify(got) === JSON.stringify(seq);
+	} catch { return false; }
+};
+
+interface RepeatSection {
+	lo: number;
+	hi: number;
+	startIdx: number;
+	endIdx?: number;
+	times: number;
+	endingStarts: number[];
+	spurious: boolean;
+}
+
+const classifyRepeatSections = (infos: MeasureRepeatInfo[], lo: number, hi: number): RepeatSection[] => {
+	const inSpan = (idx: number): boolean => idx >= lo && idx <= hi;
+	const repeatEnds = infos.filter(i => i.repeatEnd && inSpan(i.index)).map(i => i.index).sort((a, b) => a - b);
+	const repeatStarts = infos.filter(i => i.repeatStart && inSpan(i.index)).map(i => i.index).sort((a, b) => a - b);
+	const endingStops = infos.filter(i => i.endingStop !== undefined && inSpan(i.index)).map(i => i.index).sort((a, b) => a - b);
+
+	if (repeatEnds.length === 0) {
+		return [{ lo, hi, startIdx: lo, times: 1, endingStarts: [], spurious: false }];
+	}
+
+	const sections: RepeatSection[] = [];
+	let prevHi = lo - 1;
+	for (const e of repeatEnds) {
+		if (e <= prevHi) continue;
+		const sectionLo = prevHi + 1;
+		const nextStart = repeatStarts.find(s => s > e);
+		const sectionEndingStarts = infos
+			.filter(i => i.endingStart !== undefined && i.index >= sectionLo && (nextStart === undefined || i.index < nextStart) && inSpan(i.index))
+			.map(i => i.index)
+			.sort((a, b) => a - b);
+
+		let sectionHi: number;
+		if (repeatEnds.length === 1) sectionHi = hi;
+		else if (sectionEndingStarts.length) {
+			const lastStart = sectionEndingStarts[sectionEndingStarts.length - 1];
+			const stop = endingStops.find(s => s >= lastStart);
+			sectionHi = stop ?? lastStart;
+		}
+		else sectionHi = e;
+
+		const explicitStartInSection = repeatStarts.some(s => s >= sectionLo && s <= e);
+		const implicitFromStart = sectionLo === lo && lo === 1;
+		const spurious = sectionEndingStarts.length === 0 && !explicitStartInSection && !implicitFromStart;
+		const startIdx = repeatStarts.filter(s => s >= sectionLo && s <= e).sort((a, b) => b - a)[0] ?? sectionLo;
+		const endInfo = infos.find(i => i.index === e);
+		sections.push({ lo: sectionLo, hi: sectionHi, startIdx, endIdx: e, times: endInfo?.repeatTimes ?? 2, endingStarts: sectionEndingStarts, spurious });
+		prevHi = sectionHi;
+	}
+
+	if (prevHi < hi) sections.push({ lo: prevHi + 1, hi, startIdx: prevHi + 1, times: 1, endingStarts: [], spurious: false });
+	return sections;
+};
+
+const findSectionForIndex = (sections: RepeatSection[], idx: number): RepeatSection | undefined =>
+	sections.find(s => idx >= s.lo && idx <= s.hi);
+
+const endingSpansForSection = (infos: MeasureRepeatInfo[], section: RepeatSection): Array<{ number: number; start: number; stop: number }> => {
+	const spans: Array<{ number: number; start: number; stop: number }> = [];
+	for (let e = 0; e < section.endingStarts.length; e++) {
+		const start = section.endingStarts[e];
+		const nextStart = section.endingStarts[e + 1];
+		let stop: number;
+		if (nextStart !== undefined) stop = nextStart - 1;
+		else {
+			const stopInfo = infos.find(info => info.index >= start && info.index <= section.hi && info.endingStop !== undefined);
+			stop = stopInfo ? stopInfo.index : start;
+		}
+		const number = infos.find(info => info.index === start)?.endingStart ?? e + 1;
+		spans.push({ number, start, stop });
+	}
+	return spans;
+};
+
 // Render the repeat/volta structure over measures [lo..hi] (no navigation),
 // or null if it isn't a single clean repeat/volta span. Shared by the plain
 // path and the da-capo ABA wrapper.
@@ -229,64 +344,38 @@ const renderRepeatSpan = (infos: MeasureRepeatInfo[], lo: number, hi: number): s
 // Used both for the whole piece (lo=1, hi=total) and recursively for the A / B
 // halves of a da-capo ABA.
 const renderRepeatSections = (infos: MeasureRepeatInfo[], lo: number, hi: number): string | null => {
-	const inSpan = (idx: number) => idx >= lo && idx <= hi;
-	const repeatEnds = infos.filter(i => i.repeatEnd && inSpan(i.index)).map(i => i.index).sort((a, b) => a - b);
-	const repeatStarts = infos.filter(i => i.repeatStart && inSpan(i.index)).map(i => i.index).sort((a, b) => a - b);
-	if (repeatEnds.length <= 1) return renderRepeatSpan(infos, lo, hi);
-
-	const endingStops = infos.filter(i => i.endingStop !== undefined && inSpan(i.index)).map(i => i.index);
-
+	const sections = classifyRepeatSections(infos, lo, hi);
 	const parts: string[] = [];
-	let prevHi = lo - 1;
-	for (const e of repeatEnds) {
-		const sectionLo = prevHi + 1;
-		// The next section's repeat-start bounds this section's voltas (2nd/3rd
-		// endings sit AFTER the repeat-end but BEFORE the next section starts).
-		const nextStart = repeatStarts.find(s => s > e);
-		const sectionEndingStarts = infos
-			.filter(i => i.endingStart !== undefined && i.index >= sectionLo && (nextStart === undefined || i.index < nextStart) && inSpan(i.index))
-			.map(i => i.index)
-			.sort((a, b) => a - b);
-
-		let sectionHi: number;
-		if (sectionEndingStarts.length) {
-			const lastStart = sectionEndingStarts[sectionEndingStarts.length - 1];
-			// the last ending's stop closes the section; else the ending start itself
-			const stop = endingStops.filter(s => s >= lastStart).sort((a, b) => a - b)[0];
-			sectionHi = stop ?? lastStart;
+	for (const section of sections) {
+		if (section.spurious) {
+			parts.push(rangeCode(section.lo, section.hi));
+			continue;
 		}
-		else sectionHi = e;
-
-		const code = renderRepeatSpan(infos, sectionLo, sectionHi);
+		const code = renderRepeatSpan(infos, section.lo, section.hi);
 		if (code === null) return null;
 		parts.push(code);
-		prevHi = sectionHi;
 	}
-	// trailing non-repeated tail
-	if (prevHi < hi) parts.push(rangeCode(prevHi + 1, hi));
 	return parts.join(", ");
 };
 
-const tryStructured = (infos: MeasureRepeatInfo[], total: number): string | null => {
+const tryStructured = (infos: MeasureRepeatInfo[], total: number, performed: number[]): string | null => {
 	const dacapo = infos.find(i => i.dacapo);
 	const dalsegno = infos.some(i => i.dalsegno);
 	const tocoda = infos.some(i => i.tocoda);
 
-	// D.C. (da capo → return to measure 1) over an inner repeat/volta maps cleanly
-	// to ABA <main, rest>: the trailing A' re-expansion uses LayoutType.Once (body
-	// once + the LAST alternate), which is exactly the "over-volta" convention —
-	// on the da-capo pass internal volta repeats are dropped, only the final
-	// pass-through plays, stopping at Fine. D.S. (segno ≠ measure 1) and To-Coda
-	// truncation can't be expressed this way → flat fallback.
-	if (dacapo && !dalsegno && !tocoda) {
-		// D.C. over a volta → ABA <main, rest>; Once re-expansion gives the
-		// over-volta replay (body + last ending, no inner repeat). Plain D.C. al
-		// Fine without a volta can't bound A' at an arbitrary Fine → flat fallback.
-		return buildDaCapoABA(infos, dacapo.index);
+	// D.C. / D.S. jumps that replay from the start can use the ABA form. A real
+	// Segno (not measure 1) and To-Coda still fall back to flat because the DSL has
+	// no "replay from arbitrary middle marker" construct. Bare Fine/Segno/Coda marks
+	// without a jump are visual landmarks only; they must not block repeat structuring.
+	const hasExplicitSegno = infos.some(i => i.segno);
+	if (!tocoda && dacapo) return buildDaCapoABA(infos, dacapo.index, performed);
+	if (!tocoda && dalsegno && !hasExplicitSegno) {
+		const ds = infos.find(i => i.dalsegno);
+		if (ds) return buildDaCapoABA(infos, ds.index, performed);
 	}
-	if (dalsegno || tocoda || infos.some(i => i.fine || i.segno || i.coda)) return null;
+	if (dalsegno || tocoda) return null;
 
-	// No navigation: one or more plain repeat/volta sections in sequence. Most
+	// No playback-changing navigation: one or more plain repeat/volta sections in sequence. Most
 	// real pieces (AABB minuets, sonata exposition+recap) have ≥2 repeat sections;
 	// render each independently and join with commas.
 	return renderRepeatSections(infos, 1, total);
@@ -301,20 +390,19 @@ const tryStructured = (infos: MeasureRepeatInfo[], total: number): string | null
 // via renderRepeatSections. Returns null when the shape doesn't fit (no Fine to
 // bound A, or no rest tail) → caller uses the flat fallback. The end-of-build
 // re-expand check still validates the result against the simulated order.
-const buildDaCapoABA = (infos: MeasureRepeatInfo[], dcIdx: number): string | null => {
+const buildDaCapoABA = (infos: MeasureRepeatInfo[], dcIdx: number, performed: number[]): string | null => {
 	const fineIdx = infos.find(i => i.fine)?.index;
 	if (fineIdx === undefined) {
 		// No explicit Fine: fall back to the legacy single-volta ABA shape, where
 		// A ends at the last pre-D.C. ending and B is the tail to the D.C. measure.
 		return buildDaCapoABALegacy(infos, dcIdx);
 	}
-	if (fineIdx >= dcIdx) return null;          // Fine must precede the D.C. tail
+	if (fineIdx >= dcIdx) return null;          // Fine must precede the D.C./D.S. tail
 	const restLo = fineIdx + 1;
-	if (restLo > dcIdx) return null;            // no B section
 
 	const mainCode = renderRepeatSections(infos, 1, fineIdx);
-	const restCode = renderRepeatSections(infos, restLo, dcIdx);
-	if (mainCode === null || restCode === null) return null;
+	const restCode = restLo > dcIdx ? "" : renderRepeatSections(infos, restLo, dcIdx);
+	if (mainCode === null || restCode === null) return buildDaCapoABAFromReplay(infos, dcIdx, fineIdx, performed);
 
 	// `main` is parsed by the ABA grammar as ONE item (parseItem). It needs wrapping
 	// in [..] when it is a comma sequence ("1, 2*[..]") or a BARE range ("1..37",
@@ -325,7 +413,38 @@ const buildDaCapoABA = (infos: MeasureRepeatInfo[], dcIdx: number): string | nul
 	const isSingleToken = /^\d+$/.test(mainCode) || /^\d+\*\[/.test(mainCode) || /^\[/.test(mainCode);
 	const main = isSingleToken ? mainCode : `[${mainCode}]`;
 	const rest = /,/.test(restCode) ? `[${restCode}]` : restCode;
-	return `<${main}, ${rest}>`;
+	const candidate = `<${main}, ${rest}>`;
+	return layoutExpandsTo(candidate, performed) ? candidate : buildDaCapoABAFromReplay(infos, dcIdx, fineIdx, performed);
+};
+
+const wrapAbaMain = (code: string): string => /^\d+$/.test(code) || /^\d+\*\[/.test(code) || /^\[/.test(code) ? code : `[${code}]`;
+const wrapAbaRest = (code: string): string => code === "" ? "" : (/,/.test(code) ? `[${code}]` : code);
+
+const buildDaCapoABAFromReplay = (infos: MeasureRepeatInfo[], dcIdx: number, fineIdx: number, performed: number[]): string | null => {
+	// Some ABC/MusicXML D.C. exports place repeat-end/start boundaries so the
+	// notated pre-Fine span (1..Fine) is not enough to render main via source flags,
+	// even though the simulated order is a clean ABA: A(full) B A(once). Detect that
+	// shape from the final da-capo replay, then reuse the section renderer for the
+	// longer A candidate and derive B from the performed middle slice.
+	for (let k = Math.min(fineIdx, performed.length - 1); k >= 1; k--) {
+		const replay = Array.from({ length: k }, (_, i) => i + 1);
+		if (JSON.stringify(performed.slice(-k)) !== JSON.stringify(replay)) continue;
+
+		for (let mainHi = k; mainHi < dcIdx; mainHi++) {
+			const mainCode = renderRepeatSections(infos, 1, mainHi);
+			if (mainCode === null) continue;
+			const mainFull = expandMeasureLayout(parseMeasureLayout(mainCode));
+			const mainOnce = expandMeasureLayout(parseMeasureLayout(mainCode), LayoutType.Once);
+			if (JSON.stringify(mainOnce) !== JSON.stringify(replay)) continue;
+			if (JSON.stringify(performed.slice(0, mainFull.length)) !== JSON.stringify(mainFull)) continue;
+
+			const restSeq = performed.slice(mainFull.length, performed.length - mainOnce.length);
+			const restCode = compactFlatToCode(restSeq);
+			const candidate = `<${wrapAbaMain(mainCode)}, ${wrapAbaRest(restCode)}>`;
+			if (layoutExpandsTo(candidate, performed)) return candidate;
+		}
+	}
+	return null;
 };
 
 // Legacy ABA builder for D.C. WITHOUT an explicit Fine: main = the single
@@ -359,9 +478,9 @@ const buildDaCapoABALegacy = (infos: MeasureRepeatInfo[], dcIdx: number): string
 
 	const pre = startIdx > 1 ? rangeCode(1, startIdx - 1) + ", " : "";
 	const main = pre ? `[${pre}${voltaCode}]` : voltaCode;
-	// rest = the tail from after the last ending to the D.C. measure
-	if (lastStop >= dcIdx) return null;   // no tail to form the ABA "rest"
-	const rest = rangeCode(lastStop + 1, dcIdx);
+	// rest = the tail from after the last ending to the D.C. measure. It may be
+	// empty when the navigation jump follows immediately after the main repeat.
+	const rest = lastStop >= dcIdx ? "" : rangeCode(lastStop + 1, dcIdx);
 	return `<${main}, ${rest}>`;
 };
 
@@ -382,7 +501,7 @@ export const buildMeasureLayout = (infos: MeasureRepeatInfo[], totalMeasures: nu
 	// No actual unfolding happened (e.g. a lone start-repeat with no end): skip.
 	if (performed.length === totalMeasures && performed.every((v, k) => v === k + 1)) return undefined;
 
-	const structured = tryStructured(infos, totalMeasures);
+	const structured = tryStructured(infos, totalMeasures, performed);
 	if (structured) {
 		// Trust the structured form only if it reproduces the simulated order.
 		try {
@@ -390,6 +509,8 @@ export const buildMeasureLayout = (infos: MeasureRepeatInfo[], totalMeasures: nu
 			if (JSON.stringify(got) === JSON.stringify(performed)) return structured;
 		} catch { /* fall through to flat */ }
 	}
+	const compacted = compactFlatToCode(performed);
+	if (compacted !== flatToCode(performed) && layoutExpandsTo(compacted, performed)) return compacted;
 	return flatToCode(performed);
 };