@k-l-lambda/lilylet 0.1.75 → 0.1.78

package/source/lilylet/lilylet.jison

@@ -129,6 +129,14 @@
 	const markupEvent = (content, placement) => ({ type: 'markup', content, placement: placement || undefined });
 	const dynamicEvent = (type) => ({ type: 'dynamic', dynamicType: type });
 	const markupMark = (content) => ({ markType: 'markup', content });
+	const glissando = () => ({ markType: 'glissando' });
+
+	// Strip the surrounding quotes from a STRING token and unescape the control
+	// sequences the serializer emits (escapeString): \n \r \t \" \\ . A single
+	// left-to-right pass over each \x pair avoids the sequential-replace bug where
+	// an escaped backslash (\\) followed by n would be misread as a newline.
+	const UNESCAPE = { n: '\n', r: '\r', t: '\t', '"': '"', '\\': '\\' };
+	const unq = (s) => s.slice(1, -1).replace(/\\(.)/g, (m, c) => (c in UNESCAPE ? UNESCAPE[c] : m));
 
 	// Build an { instruments: { <key>: { name, shortName? } } } fragment from a
 	// `[instrument-<key>` header token. <key> is a staff-layout group key — a single
@@ -254,7 +262,7 @@
 \[auto\-beam					return 'HEADER_AUTOBEAM'
 \]								return ']'
 
-\"[^"]*\"						return 'STRING'
+\"([^\"\\]|\\.)*\"					return 'STRING'
 
 "\\clef"						return 'CMD_CLEF'
 "\\key"							return 'CMD_KEY'
@@ -303,6 +311,8 @@
 "\\fermata"						return 'ORN_FERMATA'
 "\\shortfermata"				return 'ORN_SHORTFERMATA'
 "\\arpeggio"					return 'ORN_ARPEGGIO'
+"\\breathe"						return 'ORN_BREATHE'
+"\\glissando"					return 'CMD_GLISSANDO'
 
 "\\ppp"							return 'DYN_PPP'
 "\\pp"							return 'DYN_PP'
@@ -391,16 +401,16 @@ headers
 	;
 
 header
-	: HEADER_TITLE STRING ']'					-> ({ title: $2.slice(1, -1) })
-	| HEADER_SUBTITLE STRING ']'				-> ({ subtitle: $2.slice(1, -1) })
-	| HEADER_COMPOSER STRING ']'				-> ({ composer: $2.slice(1, -1) })
-	| HEADER_ARRANGER STRING ']'				-> ({ arranger: $2.slice(1, -1) })
-	| HEADER_LYRICIST STRING ']'				-> ({ lyricist: $2.slice(1, -1) })
-	| HEADER_OPUS STRING ']'					-> ({ opus: $2.slice(1, -1) })
-	| HEADER_INSTRUMENT STRING ']'				-> ({ instrument: $2.slice(1, -1) })
-	| HEADER_INSTRUMENT_STAFF STRING ']'		-> instrumentStaff($1, $2.slice(1, -1))
-	| HEADER_INSTRUMENT_STAFF STRING STRING ']'	-> instrumentStaff($1, $2.slice(1, -1), $3.slice(1, -1))
-	| HEADER_GENRE STRING ']'					-> ({ genre: $2.slice(1, -1) })
+	: HEADER_TITLE STRING ']'					-> ({ title: unq($2) })
+	| HEADER_SUBTITLE STRING ']'				-> ({ subtitle: unq($2) })
+	| HEADER_COMPOSER STRING ']'				-> ({ composer: unq($2) })
+	| HEADER_ARRANGER STRING ']'				-> ({ arranger: unq($2) })
+	| HEADER_LYRICIST STRING ']'				-> ({ lyricist: unq($2) })
+	| HEADER_OPUS STRING ']'					-> ({ opus: unq($2) })
+	| HEADER_INSTRUMENT STRING ']'				-> ({ instrument: unq($2) })
+	| HEADER_INSTRUMENT_STAFF STRING ']'		-> instrumentStaff($1, unq($2))
+	| HEADER_INSTRUMENT_STAFF STRING STRING ']'	-> instrumentStaff($1, unq($2), unq($3))
+	| HEADER_GENRE STRING ']'					-> ({ genre: unq($2) })
 	| HEADER_STAVES STRING ']'					-> ({ staves: $2.slice(1, -1) })
 	| HEADER_MEASURES STRING ']'				-> ({ measureLayout: $2.slice(1, -1) })
 	| HEADER_AUTOBEAM STRING ']'				-> ({ autoBeam: $2.slice(1, -1) })
@@ -486,9 +496,9 @@ harmony_event
 	;
 
 markup_event
-	: CMD_MARKUP STRING							-> markupEvent($2.slice(1, -1))
-	| '^' CMD_MARKUP STRING						-> markupEvent($3.slice(1, -1), 'above')
-	| '_' CMD_MARKUP STRING						-> markupEvent($3.slice(1, -1), 'below')
+	: CMD_MARKUP STRING							-> markupEvent(unq($2))
+	| '^' CMD_MARKUP STRING						-> markupEvent(unq($3), 'above')
+	| '_' CMD_MARKUP STRING						-> markupEvent(unq($3), 'below')
 	;
 
 dynamic_event
@@ -606,8 +616,8 @@ partial_cmd
 	;
 
 tempo_cmd
-	: CMD_TEMPO STRING duration '=' NUMBER		-> ({ text: $2.slice(1, -1), beat: $3, bpm: Number($5) })
-	| CMD_TEMPO STRING							-> ({ text: $2.slice(1, -1) })
+	: CMD_TEMPO STRING duration '=' NUMBER		-> ({ text: unq($2), beat: $3, bpm: Number($5) })
+	| CMD_TEMPO STRING							-> ({ text: unq($2) })
 	| CMD_TEMPO duration '=' NUMBER				-> ({ beat: $2, bpm: Number($4) })
 	;
 
@@ -670,6 +680,7 @@ post_event
 	| fingering_number
 	| navigation_mark
 	| markup_mark
+	| glissando_mark
 	;
 
 rest_mark
@@ -704,6 +715,7 @@ ornament_mark
 	| ORN_FERMATA								-> ornament('fermata')
 	| ORN_SHORTFERMATA							-> ornament('shortFermata')
 	| ORN_ARPEGGIO								-> ornament('arpeggio')
+	| ORN_BREATHE								-> ornament('breath')
 	;
 
 dynamic_mark
@@ -769,5 +781,9 @@ navigation_mark
 	;
 
 markup_mark
-	: CMD_MARKUP STRING							-> markupMark($2.slice(1, -1))
+	: CMD_MARKUP STRING							-> markupMark(unq($2))
+	;
+
+glissando_mark
+	: CMD_GLISSANDO								-> glissando()
 	;

package/source/lilylet/lilypondEncoder.ts

@@ -751,26 +751,30 @@ const encodeVoice = (
 const encodeMetadata = (metadata: Metadata): string => {
 	const entries: string[] = [];
 
+	// LilyPond strings escape backslash and double-quote with a backslash. An
+	// unescaped " (or \) inside a header value otherwise breaks the \header block.
+	const ly = (s: string): string => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+
 	if (metadata.title) {
-		entries.push(`  title = "${metadata.title}"`);
+		entries.push(`  title = "${ly(metadata.title)}"`);
 	}
 	if (metadata.subtitle) {
-		entries.push(`  subtitle = "${metadata.subtitle}"`);
+		entries.push(`  subtitle = "${ly(metadata.subtitle)}"`);
 	}
 	if (metadata.composer) {
-		entries.push(`  composer = "${metadata.composer}"`);
+		entries.push(`  composer = "${ly(metadata.composer)}"`);
 	}
 	if (metadata.arranger) {
-		entries.push(`  arranger = "${metadata.arranger}"`);
+		entries.push(`  arranger = "${ly(metadata.arranger)}"`);
 	}
 	if (metadata.lyricist) {
-		entries.push(`  poet = "${metadata.lyricist}"`);
+		entries.push(`  poet = "${ly(metadata.lyricist)}"`);
 	}
 	if (metadata.opus) {
-		entries.push(`  opus = "${metadata.opus}"`);
+		entries.push(`  opus = "${ly(metadata.opus)}"`);
 	}
 	if (metadata.instrument) {
-		entries.push(`  instrument = "${metadata.instrument}"`);
+		entries.push(`  instrument = "${ly(metadata.instrument)}"`);
 	}
 
 	entries.push('  tagline = ##f');

package/source/lilylet/measureLayout.ts

@@ -412,6 +412,98 @@ export const collectVoltaSpans = (layout: MeasureLayout): VoltaEndingSpan[] => {
 };
 
 
+// ── Segment decomposition (for MEI nested sections + section-level expansion) ──
+// Verovio draws volta house brackets only from <ending> containers, and only
+// plays an <expansion> correctly when the plist references SECTION/ENDING ids
+// (not bare measures) over a properly nested structure. So decompose the layout
+// into contiguous measure groups — a "section" for plain runs and volta bodies,
+// an "ending" for each volta alternate — and a performance order over those
+// segment ids (a body segment id repeats once per pass). Returns null when the
+// layout has no voltas (caller uses the simpler flat measure-level expansion) or
+// can't be cleanly decomposed (non-contiguous segment → fall back to flat).
+
+export interface LayoutSegment { id: string; kind: "section" | "ending"; endingNumber?: number; measures: number[]; }
+export interface SegmentDecomposition { segments: LayoutSegment[]; order: string[]; }
+
+export const decomposeToSegments = (layout: MeasureLayout): SegmentDecomposition | null => {
+	const segments: LayoutSegment[] = [];
+	let hasEnding = false;
+	let counter = 0;
+	const newId = (k: string) => `seg-${k}-${counter++}`;
+
+	// Indices a node covers in notation order (each measure once, ascending).
+	const indicesOf = (node: MeasureLayout): number[] => {
+		switch (node.kind) {
+		case "single": return [node.measure];
+		case "block": return ([] as number[]).concat(...node.seq.map(indicesOf));
+		case "volta": return ([] as number[]).concat(...node.body.map(indicesOf),
+			...(node.alternates ? ([] as number[]).concat(...node.alternates.map(a => ([] as number[]).concat(...a.map(indicesOf)))) : []));
+		case "aba": return ([] as number[]).concat(indicesOf(node.main), ...node.rest.map(indicesOf));
+		}
+	};
+	const contiguousAsc = (xs: number[]): boolean => xs.length > 0 && xs.every((v, i) => i === 0 || v === xs[i - 1] + 1);
+
+	// Accumulate a run of plain (non-volta/non-aba) measures into one section,
+	// flushing whenever a structural node (volta/aba) interrupts the run.
+	let run: number[] = [];
+	const flushRun = (): void => {
+		if (run.length === 0) return;
+		if (!contiguousAsc(run)) throw new Error("non-contiguous section run");
+		segments.push({ id: newId("sec"), kind: "section", measures: run });
+		run = [];
+	};
+
+	// Emit segments for a node in document order. Plain singles/blocks extend the
+	// current run; a volta flushes the run then emits body-section + ending(s); an
+	// aba flushes then recurses into main and rest (so the replayed main is its own
+	// segment run). Throws on any non-contiguous group → caller falls back to flat.
+	const emit = (node: MeasureLayout): void => {
+		switch (node.kind) {
+		case "single": run.push(node.measure); break;
+		case "block": node.seq.forEach(emit); break;
+		case "aba": flushRun(); emit(node.main); flushRun(); node.rest.forEach(emit); flushRun(); break;
+		case "volta": {
+			flushRun();
+			const body = indicesOf({ kind: "block", seq: node.body });
+			if (!contiguousAsc(body)) throw new Error("non-contiguous volta body");
+			segments.push({ id: newId("body"), kind: "section", measures: body });
+			if (node.alternates) {
+				hasEnding = true;
+				node.alternates.forEach((alt, ai) => {
+					const m = indicesOf({ kind: "block", seq: alt });
+					if (!contiguousAsc(m)) throw new Error("non-contiguous ending");
+					segments.push({ id: newId("end"), kind: "ending", endingNumber: ai + 1, measures: m });
+				});
+			}
+			break;
+		}
+		}
+	};
+
+	try { emit(layout); flushRun(); } catch { return null; }
+	if (!hasEnding) return null;   // no voltas → flat measure-level path is fine
+
+	// Map each measure index to the segment whose `measures` contains it. A volta
+	// body measure belongs to its body section; alternate measures to their ending.
+	const segOfMeasure = new Map<number, string>();
+	for (const s of segments) for (const m of s.measures) if (!segOfMeasure.has(m)) segOfMeasure.set(m, s.id);
+
+	// Performance order over segment ids: walk the flat Full expansion and collapse
+	// consecutive measures that map to the same segment into one segment ref. This
+	// reproduces the exact playback order (body repeats → body id appears twice,
+	// ABA replay → main segment id reappears), keyed off the proven expander.
+	const flat = expandMeasureLayout(layout, LayoutType.Full);
+	const order: string[] = [];
+	for (const m of flat) {
+		const id = segOfMeasure.get(m);
+		if (id === undefined) return null;   // a played measure isn't in any segment → bail to flat
+		if (order.length === 0 || order[order.length - 1] !== id) order.push(id);
+		else if (segments.find(s => s.id === id)!.measures[0] === m) order.push(id);  // same seg restarting (repeat) → new ref
+	}
+	return { segments, order };
+};
+
+
 // ── Serializer ───────────────────────────────────────────────────────────
 // Canonical index-wise form, collapsing runs of ≥3 consecutive singles into
 // "A..B" ranges (lotus's seqToCode).

package/source/lilylet/measureLayoutFromXml.ts

@@ -309,7 +309,9 @@ export const buildMeasureLayout = (infos: MeasureRepeatInfo[], totalMeasures: nu
 // "D.C. al Fine" → dacapo (the Fine stop is marked separately where "Fine"
 // appears); "D.S. al Coda"/"D.S." → dalsegno; "To Coda" → tocoda; bare "Fine"
 // → fine; bare "Coda"/"Segno" → mark the landing point.
-const applyNavText = (info: MeasureRepeatInfo, raw: string): void => {
+// Exported so the ABC decoder can feed its !D.C.!/!D.S.!/!fine! decoration text
+// through the SAME recognizer, keeping the ABC and MusicXML nav semantics identical.
+export const applyNavText = (info: MeasureRepeatInfo, raw: string): void => {
 	const t = raw.trim().toLowerCase().replace(/\s+/g, " ");
 	if (!t) return;
 	const isDC = /\bd\.?\s*c\.?\b|\bda\s*capo\b/.test(t);