@k-l-lambda/lilylet 0.1.75 → 0.1.76

package/lib/lilylet/grammar.jison.js

@@ -108,34 +108,34 @@ case 13:
 this.$ = mergeHeaders($$[$0-2], $$[$0]);
 break;
 case 14:
-this.$ = ({ title: $$[$0-1].slice(1, -1) });
+this.$ = ({ title: unq($$[$0-1]) });
 break;
 case 15:
-this.$ = ({ subtitle: $$[$0-1].slice(1, -1) });
+this.$ = ({ subtitle: unq($$[$0-1]) });
 break;
 case 16:
-this.$ = ({ composer: $$[$0-1].slice(1, -1) });
+this.$ = ({ composer: unq($$[$0-1]) });
 break;
 case 17:
-this.$ = ({ arranger: $$[$0-1].slice(1, -1) });
+this.$ = ({ arranger: unq($$[$0-1]) });
 break;
 case 18:
-this.$ = ({ lyricist: $$[$0-1].slice(1, -1) });
+this.$ = ({ lyricist: unq($$[$0-1]) });
 break;
 case 19:
-this.$ = ({ opus: $$[$0-1].slice(1, -1) });
+this.$ = ({ opus: unq($$[$0-1]) });
 break;
 case 20:
-this.$ = ({ instrument: $$[$0-1].slice(1, -1) });
+this.$ = ({ instrument: unq($$[$0-1]) });
 break;
 case 21:
-this.$ = instrumentStaff($$[$0-2], $$[$0-1].slice(1, -1));
+this.$ = instrumentStaff($$[$0-2], unq($$[$0-1]));
 break;
 case 22:
-this.$ = instrumentStaff($$[$0-3], $$[$0-2].slice(1, -1), $$[$0-1].slice(1, -1));
+this.$ = instrumentStaff($$[$0-3], unq($$[$0-2]), unq($$[$0-1]));
 break;
 case 23:
-this.$ = ({ genre: $$[$0-1].slice(1, -1) });
+this.$ = ({ genre: unq($$[$0-1]) });
 break;
 case 24:
 this.$ = ({ staves: $$[$0-1].slice(1, -1) });
@@ -214,13 +214,13 @@ case 50:
 this.$ = harmonyEvent($$[$0].slice(1, -1));
 break;
 case 51:
-this.$ = markupEvent($$[$0].slice(1, -1));
+this.$ = markupEvent(unq($$[$0]));
 break;
 case 52:
-this.$ = markupEvent($$[$0].slice(1, -1), 'above');
+this.$ = markupEvent(unq($$[$0]), 'above');
 break;
 case 53:
-this.$ = markupEvent($$[$0].slice(1, -1), 'below');
+this.$ = markupEvent(unq($$[$0]), 'below');
 break;
 case 54:
 this.$ = dynamicEvent($$[$0].type);
@@ -351,10 +351,10 @@ case 95:
  numericTimeSignature = false; this.$ = null; 
 break;
 case 97:
-this.$ = ({ text: $$[$0-3].slice(1, -1), beat: $$[$0-2], bpm: Number($$[$0]) });
+this.$ = ({ text: unq($$[$0-3]), beat: $$[$0-2], bpm: Number($$[$0]) });
 break;
 case 98:
-this.$ = ({ text: $$[$0].slice(1, -1) });
+this.$ = ({ text: unq($$[$0]) });
 break;
 case 99:
 this.$ = ({ beat: $$[$0-2], bpm: Number($$[$0]) });
@@ -525,7 +525,7 @@ case 187:
 this.$ = navigation('segno');
 break;
 case 188:
-this.$ = markupMark($$[$0].slice(1, -1));
+this.$ = markupMark(unq($$[$0]));
 break;
 }
 },
@@ -808,6 +808,13 @@ parse: function parse(input) {
 	const dynamicEvent = (type) => ({ type: 'dynamic', dynamicType: type });
 	const markupMark = (content) => ({ markType: 'markup', content });
 
+	// 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
 	// staff id ("1", "v1", "b") or a range ("1-2", "pl-pr") — taken verbatim after the

package/lib/lilylet/lilypondEncoder.js

@@ -622,26 +622,29 @@ const encodeVoice = (voice, measureContext, voiceIndex) => {
  */
 const encodeMetadata = (metadata) => {
     const entries = [];
+    // 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) => 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');
     return entries.join('\n');

package/lib/lilylet/measureLayout.d.ts

@@ -64,5 +64,16 @@ export interface VoltaEndingSpan {
     measures: number[];
 }
 export declare const collectVoltaSpans: (layout: MeasureLayout) => VoltaEndingSpan[];
+export interface LayoutSegment {
+    id: string;
+    kind: "section" | "ending";
+    endingNumber?: number;
+    measures: number[];
+}
+export interface SegmentDecomposition {
+    segments: LayoutSegment[];
+    order: string[];
+}
+export declare const decomposeToSegments: (layout: MeasureLayout) => SegmentDecomposition | null;
 /** Serialize an AST back to the canonical index-wise DSL string. */
 export declare const serializeMeasureLayout: (layout: MeasureLayout) => string;

package/lib/lilylet/measureLayout.js

@@ -362,6 +362,103 @@ export const collectVoltaSpans = (layout) => {
     walk(layout);
     return spans;
 };
+export const decomposeToSegments = (layout) => {
+    const segments = [];
+    let hasEnding = false;
+    let counter = 0;
+    const newId = (k) => `seg-${k}-${counter++}`;
+    // Indices a node covers in notation order (each measure once, ascending).
+    const indicesOf = (node) => {
+        switch (node.kind) {
+            case "single": return [node.measure];
+            case "block": return [].concat(...node.seq.map(indicesOf));
+            case "volta": return [].concat(...node.body.map(indicesOf), ...(node.alternates ? [].concat(...node.alternates.map(a => [].concat(...a.map(indicesOf)))) : []));
+            case "aba": return [].concat(indicesOf(node.main), ...node.rest.map(indicesOf));
+        }
+    };
+    const contiguousAsc = (xs) => 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 = [];
+    const flushRun = () => {
+        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) => {
+        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();
+    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 = [];
+    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/lib/lilylet/meiEncoder.js

@@ -1,7 +1,7 @@
 import { Clef, Accidental, OrnamentType, StemDirection, HairpinType, PedalType, } from "./types.js";
 import { parseStaffLayout, StaffGroupType } from "./staffLayout.js";
 import { gmProgramOf } from "./gmInstruments.js";
-import { parseMeasureLayout, expandMeasureLayout, collectVoltaSpans } from "./measureLayout.js";
+import { parseMeasureLayout, expandMeasureLayout, decomposeToSegments } from "./measureLayout.js";
 // MEI key signatures: positive = sharps, negative = flats
 const KEY_SIGS = {
     0: "0",
@@ -2294,31 +2294,70 @@ const encode = (doc, options = {}) => {
     // below — so remember where to insert it and build it afterwards).
     const expansionInsertPos = mei.length;
     const measureIds = [];
-    // 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(); // measure index → ending number
-    const endingCloseAt = new Set(); // measure index after which </ending> closes
+    // Volta playback + house brackets. A flat measure-level <expansion> conflicts
+    // with <ending> wrappers in verovio (it then drops the volta measures). Verovio
+    // instead wants nested <section>/<ending> groups with a SECTION-LEVEL expansion
+    // whose plist references those segment ids. So when the layout decomposes into
+    // volta segments, emit that structure; otherwise keep the simpler flat path.
+    // See [[volta-rendering-gaps]] / [[lilylet-measure-layout]].
+    // Helper to check if a measure has any musical content
+    const measureHasContent = (measure) => {
+        for (const part of measure.parts) {
+            for (const voice of part.voices) {
+                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 === 'times' || event.type === 'tremolo') {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    // Filter out trailing empty measures (done before segment setup so the segment
+    // guard below knows the true emitted measure count).
+    let measures = doc.measures;
+    while (measures.length > 0 && !measureHasContent(measures[measures.length - 1])) {
+        measures = measures.slice(0, -1);
+    }
+    let segDecomp = null;
+    const segOpenAt = new Map(); // measure index → opening tag for its segment
+    const segCloseAt = new Map(); // measure index → closing tag after it
+    const segIdById = new Map(); // layout segment id → emitted xml:id
     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);
-                }
+            segDecomp = decomposeToSegments(parseMeasureLayout(doc.metadata.measureLayout));
+        }
+        catch {
+            segDecomp = null;
+        }
+    }
+    // A layout that references a measure beyond the emitted range (e.g. a volta
+    // alternate whose bar was a trailing empty measure that got trimmed) cannot be
+    // emitted as nested sections without a dangling <ending>/<section> id or an
+    // unbalanced wrapper. Drop to the flat measure-level expansion path, which
+    // already warns-and-skips out-of-range refs.
+    if (segDecomp && segDecomp.segments.some(seg => seg.measures.some(m => m > measures.length))) {
+        segDecomp = null;
+    }
+    if (segDecomp) {
+        const segIndent = `${indent}${indent}${indent}${indent}${indent}${indent}`;
+        for (const seg of segDecomp.segments) {
+            const xmlId = generateId(seg.kind === "ending" ? "ending" : "section");
+            segIdById.set(seg.id, xmlId);
+            const lo = seg.measures[0];
+            const hi = seg.measures[seg.measures.length - 1];
+            if (seg.kind === "ending") {
+                const lendsym = seg.endingNumber === 1 ? ' lendsym="angledown"' : '';
+                segOpenAt.set(lo, `${segIndent}<ending xml:id="${xmlId}" n="${seg.endingNumber}"${lendsym}>\n`);
+            }
+            else {
+                segOpenAt.set(lo, `${segIndent}<section xml:id="${xmlId}">\n`);
             }
+            segCloseAt.set(hi, `${segIndent}</${seg.kind === "ending" ? "ending" : "section"}>\n`);
         }
-        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 = {};
     // Track slur state across measures for cross-measure slurs
@@ -2344,26 +2383,6 @@ const encode = (doc, options = {}) => {
             transState[globalStaff] = `${t.diat},${t.semi}`;
         }
     }
-    // Helper to check if a measure has any musical content
-    const measureHasContent = (measure) => {
-        for (const part of measure.parts) {
-            for (const voice of part.voices) {
-                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 === 'times' || event.type === 'tremolo') {
-                        return true;
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    // Filter out trailing empty measures
-    let measures = doc.measures;
-    while (measures.length > 0 && !measureHasContent(measures[measures.length - 1])) {
-        measures = measures.slice(0, -1);
-    }
     // Encode measures
     measures.forEach((measure, mi) => {
         // Check for key signature change and output scoreDef if needed
@@ -2427,31 +2446,33 @@ const encode = (doc, options = {}) => {
         }
         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;
+        // When the layout decomposes into volta segments, wrap each measure run in
+        // its <section>/<ending> container (opened/closed by measure index).
+        const openTag = segOpenAt.get(mIndex);
+        if (openTag)
+            mei += openTag;
+        const measureIndent = segDecomp ? `${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;
-        }
+        const closeTag = segCloseAt.get(mIndex);
+        if (closeTag)
+            mei += closeTag;
     });
-    // 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) {
+    // directive ([measures "..."]). Verovio consumes its plist to unfold repeats
+    // for MIDI/time-map output. Inserted as the first child of <section>.
+    //   - voltas present (segDecomp): plist references the SECTION/ENDING segment
+    //     ids in performed order (a body segment id repeats per pass). This is the
+    //     only form verovio plays correctly alongside <ending> house brackets.
+    //   - otherwise: the simpler flat measure-level plist (one ref per played bar).
+    if (segDecomp) {
+        const refs = segDecomp.order.map(segId => segIdById.get(segId)).filter((x) => x !== undefined).map(id => `#${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);
+        }
+    }
+    else if (doc.metadata?.measureLayout) {
         try {
             const layout = parseMeasureLayout(doc.metadata.measureLayout);
             const order = expandMeasureLayout(layout);

package/lib/lilylet/serializer.js

@@ -507,7 +507,7 @@ const serializeEvent = (event, env, prevDuration, suppressGracePrefix = false) =
         case 'markup': {
             const mk = event;
             const prefix = mk.placement === 'above' ? '^' : mk.placement === 'below' ? '_' : '';
-            return { str: `${prefix}\\markup "${mk.content}"`, newEnv: env };
+            return { str: `${prefix}\\markup "${escapeString(mk.content)}"`, newEnv: env };
         }
         case 'dynamic': {
             const dynStr = DYNAMIC_MAP[event.dynamicType];
@@ -841,7 +841,12 @@ const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false,
 };
 // Escape string for serialization (quotes and backslashes)
 const escapeString = (str) => {
-    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
 };
 // Serialize metadata
 const serializeMetadata = (metadata) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.75",
+  "version": "0.1.76",
   "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/grammar.jison.js

@@ -108,34 +108,34 @@ case 13:
 this.$ = mergeHeaders($$[$0-2], $$[$0]);
 break;
 case 14:
-this.$ = ({ title: $$[$0-1].slice(1, -1) });
+this.$ = ({ title: unq($$[$0-1]) });
 break;
 case 15:
-this.$ = ({ subtitle: $$[$0-1].slice(1, -1) });
+this.$ = ({ subtitle: unq($$[$0-1]) });
 break;
 case 16:
-this.$ = ({ composer: $$[$0-1].slice(1, -1) });
+this.$ = ({ composer: unq($$[$0-1]) });
 break;
 case 17:
-this.$ = ({ arranger: $$[$0-1].slice(1, -1) });
+this.$ = ({ arranger: unq($$[$0-1]) });
 break;
 case 18:
-this.$ = ({ lyricist: $$[$0-1].slice(1, -1) });
+this.$ = ({ lyricist: unq($$[$0-1]) });
 break;
 case 19:
-this.$ = ({ opus: $$[$0-1].slice(1, -1) });
+this.$ = ({ opus: unq($$[$0-1]) });
 break;
 case 20:
-this.$ = ({ instrument: $$[$0-1].slice(1, -1) });
+this.$ = ({ instrument: unq($$[$0-1]) });
 break;
 case 21:
-this.$ = instrumentStaff($$[$0-2], $$[$0-1].slice(1, -1));
+this.$ = instrumentStaff($$[$0-2], unq($$[$0-1]));
 break;
 case 22:
-this.$ = instrumentStaff($$[$0-3], $$[$0-2].slice(1, -1), $$[$0-1].slice(1, -1));
+this.$ = instrumentStaff($$[$0-3], unq($$[$0-2]), unq($$[$0-1]));
 break;
 case 23:
-this.$ = ({ genre: $$[$0-1].slice(1, -1) });
+this.$ = ({ genre: unq($$[$0-1]) });
 break;
 case 24:
 this.$ = ({ staves: $$[$0-1].slice(1, -1) });
@@ -214,13 +214,13 @@ case 50:
 this.$ = harmonyEvent($$[$0].slice(1, -1));
 break;
 case 51:
-this.$ = markupEvent($$[$0].slice(1, -1));
+this.$ = markupEvent(unq($$[$0]));
 break;
 case 52:
-this.$ = markupEvent($$[$0].slice(1, -1), 'above');
+this.$ = markupEvent(unq($$[$0]), 'above');
 break;
 case 53:
-this.$ = markupEvent($$[$0].slice(1, -1), 'below');
+this.$ = markupEvent(unq($$[$0]), 'below');
 break;
 case 54:
 this.$ = dynamicEvent($$[$0].type);
@@ -351,10 +351,10 @@ case 95:
  numericTimeSignature = false; this.$ = null; 
 break;
 case 97:
-this.$ = ({ text: $$[$0-3].slice(1, -1), beat: $$[$0-2], bpm: Number($$[$0]) });
+this.$ = ({ text: unq($$[$0-3]), beat: $$[$0-2], bpm: Number($$[$0]) });
 break;
 case 98:
-this.$ = ({ text: $$[$0].slice(1, -1) });
+this.$ = ({ text: unq($$[$0]) });
 break;
 case 99:
 this.$ = ({ beat: $$[$0-2], bpm: Number($$[$0]) });
@@ -525,7 +525,7 @@ case 187:
 this.$ = navigation('segno');
 break;
 case 188:
-this.$ = markupMark($$[$0].slice(1, -1));
+this.$ = markupMark(unq($$[$0]));
 break;
 }
 },
@@ -808,6 +808,13 @@ parse: function parse(input) {
 	const dynamicEvent = (type) => ({ type: 'dynamic', dynamicType: type });
 	const markupMark = (content) => ({ markType: 'markup', content });
 
+	// 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
 	// staff id ("1", "v1", "b") or a range ("1-2", "pl-pr") — taken verbatim after the

package/source/lilylet/lilylet.jison

@@ -130,6 +130,13 @@
 	const dynamicEvent = (type) => ({ type: 'dynamic', dynamicType: type });
 	const markupMark = (content) => ({ markType: 'markup', content });
 
+	// 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
 	// staff id ("1", "v1", "b") or a range ("1-2", "pl-pr") — taken verbatim after the
@@ -391,16 +398,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 +493,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 +613,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) })
 	;
 
@@ -769,5 +776,5 @@ navigation_mark
 	;
 
 markup_mark
-	: CMD_MARKUP STRING							-> markupMark($2.slice(1, -1))
+	: CMD_MARKUP STRING							-> markupMark(unq($2))
 	;

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/meiEncoder.ts

@@ -29,7 +29,7 @@ import {
 } from "./types";
 import { parseStaffLayout, StaffGroup, StaffGroupType } from "./staffLayout";
 import { gmProgramOf } from "./gmInstruments";
-import { parseMeasureLayout, expandMeasureLayout, collectVoltaSpans } from "./measureLayout";
+import { parseMeasureLayout, expandMeasureLayout, decomposeToSegments } from "./measureLayout";
 
 
 // MEI key signatures: positive = sharps, negative = flats
@@ -2744,27 +2744,68 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	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
+	// Volta playback + house brackets. A flat measure-level <expansion> conflicts
+	// with <ending> wrappers in verovio (it then drops the volta measures). Verovio
+	// instead wants nested <section>/<ending> groups with a SECTION-LEVEL expansion
+	// whose plist references those segment ids. So when the layout decomposes into
+	// volta segments, emit that structure; otherwise keep the simpler flat path.
+	// See [[volta-rendering-gaps]] / [[lilylet-measure-layout]].
+	// Helper to check if a measure has any musical content
+	const measureHasContent = (measure: Measure): boolean => {
+		for (const part of measure.parts) {
+			for (const voice of part.voices) {
+				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 === 'times' || event.type === 'tremolo') {
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	};
+
+	// Filter out trailing empty measures (done before segment setup so the segment
+	// guard below knows the true emitted measure count).
+	let measures = doc.measures;
+	while (measures.length > 0 && !measureHasContent(measures[measures.length - 1])) {
+		measures = measures.slice(0, -1);
+	}
+
+	let segDecomp: ReturnType<typeof decomposeToSegments> = null;
+	const segOpenAt = new Map<number, string>();    // measure index → opening tag for its segment
+	const segCloseAt = new Map<number, string>();   // measure index → closing tag after it
+	const segIdById = new Map<string, string>();    // layout segment id → emitted xml:id
 	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); }
+			segDecomp = decomposeToSegments(parseMeasureLayout(doc.metadata.measureLayout));
+		} catch { segDecomp = null; }
+	}
+	// A layout that references a measure beyond the emitted range (e.g. a volta
+	// alternate whose bar was a trailing empty measure that got trimmed) cannot be
+	// emitted as nested sections without a dangling <ending>/<section> id or an
+	// unbalanced wrapper. Drop to the flat measure-level expansion path, which
+	// already warns-and-skips out-of-range refs.
+	if (segDecomp && segDecomp.segments.some(seg => seg.measures.some(m => m > measures.length))) {
+		segDecomp = null;
+	}
+	if (segDecomp) {
+		const segIndent = `${indent}${indent}${indent}${indent}${indent}${indent}`;
+		for (const seg of segDecomp.segments) {
+			const xmlId = generateId(seg.kind === "ending" ? "ending" : "section");
+			segIdById.set(seg.id, xmlId);
+			const lo = seg.measures[0];
+			const hi = seg.measures[seg.measures.length - 1];
+			if (seg.kind === "ending") {
+				const lendsym = seg.endingNumber === 1 ? ' lendsym="angledown"' : '';
+				segOpenAt.set(lo, `${segIndent}<ending xml:id="${xmlId}" n="${seg.endingNumber}"${lendsym}>\n`);
+			} else {
+				segOpenAt.set(lo, `${segIndent}<section xml:id="${xmlId}">\n`);
 			}
-		} catch { /* malformed layout → no house brackets, expansion path handles the rest */ }
+			segCloseAt.set(hi, `${segIndent}</${seg.kind === "ending" ? "ending" : "section"}>\n`);
+		}
 	}
-	let endingOpen = false;   // whether an <ending> is currently open in the output
 
 	// Track tie state across measures for cross-measure ties
 	const tieState: TieState = {};
@@ -2796,28 +2837,6 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 		}
 	}
 
-	// Helper to check if a measure has any musical content
-	const measureHasContent = (measure: Measure): boolean => {
-		for (const part of measure.parts) {
-			for (const voice of part.voices) {
-				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 === 'times' || event.type === 'tremolo') {
-						return true;
-					}
-				}
-			}
-		}
-		return false;
-	};
-
-	// Filter out trailing empty measures
-	let measures = doc.measures;
-	while (measures.length > 0 && !measureHasContent(measures[measures.length - 1])) {
-		measures = measures.slice(0, -1);
-	}
-
 	// Encode measures
 	measures.forEach((measure, mi) => {
 		// Check for key signature change and output scoreDef if needed
@@ -2877,29 +2896,32 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 		}
 		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;
+		// When the layout decomposes into volta segments, wrap each measure run in
+		// its <section>/<ending> container (opened/closed by measure index).
+		const openTag = segOpenAt.get(mIndex);
+		if (openTag) mei += openTag;
+		const measureIndent = segDecomp ? `${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;
-		}
+		const closeTag = segCloseAt.get(mIndex);
+		if (closeTag) mei += closeTag;
 	});
-	// 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) {
+	// directive ([measures "..."]). Verovio consumes its plist to unfold repeats
+	// for MIDI/time-map output. Inserted as the first child of <section>.
+	//   - voltas present (segDecomp): plist references the SECTION/ENDING segment
+	//     ids in performed order (a body segment id repeats per pass). This is the
+	//     only form verovio plays correctly alongside <ending> house brackets.
+	//   - otherwise: the simpler flat measure-level plist (one ref per played bar).
+	if (segDecomp) {
+		const refs = segDecomp.order.map(segId => segIdById.get(segId)).filter((x): x is string => x !== undefined).map(id => `#${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);
+		}
+	}
+	else if (doc.metadata?.measureLayout) {
 		try {
 			const layout = parseMeasureLayout(doc.metadata.measureLayout);
 			const order = expandMeasureLayout(layout);

package/source/lilylet/serializer.ts

@@ -631,7 +631,7 @@ const serializeEvent = (
 		case 'markup': {
 			const mk = event as MarkupEvent;
 			const prefix = mk.placement === 'above' ? '^' : mk.placement === 'below' ? '_' : '';
-			return { str: `${prefix}\\markup "${mk.content}"`, newEnv: env };
+			return { str: `${prefix}\\markup "${escapeString(mk.content)}"`, newEnv: env };
 		}
 		case 'dynamic': {
 			const dynStr = DYNAMIC_MAP[(event as DynamicEvent).dynamicType];
@@ -1011,7 +1011,12 @@ const serializeMeasure = (
 
 // Escape string for serialization (quotes and backslashes)
 const escapeString = (str: string): string => {
-	return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+	return str
+		.replace(/\\/g, '\\\\')
+		.replace(/"/g, '\\"')
+		.replace(/\n/g, '\\n')
+		.replace(/\r/g, '\\r')
+		.replace(/\t/g, '\\t');
 };
 
 // Serialize metadata