@k-l-lambda/lilylet 0.1.75 → 0.1.78

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/measureLayoutFromXml.d.ts

@@ -39,6 +39,7 @@ export interface MeasureRepeatInfo {
  * guaranteed to expand (via measureLayout.ts) to the simulated performed order.
  */
 export declare const buildMeasureLayout: (infos: MeasureRepeatInfo[], totalMeasures: number) => string | undefined;
+export declare const applyNavText: (info: MeasureRepeatInfo, raw: string) => void;
 export declare const collectRepeatInfo: (partEl: Element) => MeasureRepeatInfo[];
 /**
  * Derive metadata.measureLayout from a <part> element, or undefined if no

package/lib/lilylet/measureLayoutFromXml.js

@@ -298,7 +298,9 @@ export const buildMeasureLayout = (infos, totalMeasures) => {
 // "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, raw) => {
+// 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, raw) => {
     const t = raw.trim().toLowerCase().replace(/\s+/g, " ");
     if (!t)
         return;

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",
@@ -342,6 +342,8 @@ const extractMarkOptions = (marks) => {
         fingerings: [],
         navigation: undefined,
         markups: [],
+        breath: false,
+        glissando: false,
     };
     if (!marks)
         return result;
@@ -379,6 +381,9 @@ const extractMarkOptions = (marks) => {
                 else if (mark.type === OrnamentType.prall) {
                     result.mordent = 'upper';
                 }
+                else if (mark.type === OrnamentType.breath) {
+                    result.breath = true;
+                }
                 break;
             case 'dynamic': {
                 const dynStr = DYNAMIC_MAP[mark.type];
@@ -449,6 +454,9 @@ const extractMarkOptions = (marks) => {
                     placement: mark.placement,
                 });
                 break;
+            case 'glissando':
+                result.glissando = true;
+                break;
         }
         // Tremolo (special case - from parser internal mark)
         if ('tremolo' in mark && typeof mark.tremolo === 'number') {
@@ -514,6 +522,8 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
             fingerings: markOptions.fingerings,
             navigation: markOptions.navigation,
             markups: markOptions.markups,
+            breath: markOptions.breath,
+            glissando: markOptions.glissando,
         };
     }
     // Chord
@@ -576,6 +586,8 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
         fingerings: markOptions.fingerings,
         navigation: markOptions.navigation,
         markups: markOptions.markups,
+        breath: markOptions.breath,
+        glissando: markOptions.glissando,
     };
 };
 // Convert RestEvent to MEI
@@ -846,7 +858,7 @@ const getEventBeamMarks = (event) => {
     return { beamStart: false, beamEnd: false };
 };
 // Encode a layer (voice)
-const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths = 0, initialClef, initialSlurs = [], initialHairpin = null, initialOctave = null) => {
+const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths = 0, initialClef, initialSlurs = [], initialHairpin = null, initialOctave = null, initialGliss = null) => {
     const layerId = generateId("layer");
     let xml = `${indent}<layer xml:id="${layerId}" n="${layerN}">\n`;
     let beamElementOpen = false; // Whether actual <beam> element is open (passed to tuplets)
@@ -921,6 +933,12 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     // Track ornament refs
     const fermatas = [];
     const trills = [];
+    const breaths = [];
+    // Glissando: a note-to-note slide. Record the start note id and close it on the
+    // NEXT encoded note (endid), mirroring slur start→end pairing. A trailing
+    // glissando with no following note in the layer is dropped (no target).
+    const glissandos = [];
+    let pendingGlissStart = initialGliss;
     const mordents = [];
     const turns = [];
     const dynamics = [];
@@ -1082,6 +1100,19 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 if (result.trill) {
                     trills.push({ startid: result.elementId });
                 }
+                // Breath mark follows this note.
+                if (result.breath) {
+                    breaths.push({ startid: result.elementId });
+                }
+                // Glissando: close a pending start onto this note, then open a new one
+                // if this note itself carries a glissando.
+                if (pendingGlissStart) {
+                    glissandos.push({ startid: pendingGlissStart, endid: result.elementId });
+                    pendingGlissStart = null;
+                }
+                if (result.glissando) {
+                    pendingGlissStart = result.elementId;
+                }
                 if (result.mordent) {
                     mordents.push({
                         startid: result.elementId,
@@ -1350,10 +1381,10 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
         }
     }
     xml += `${indent}</layer>\n`;
-    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: openSlurs.map(s => s.startId), pendingHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
+    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, breaths, glissandos, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: openSlurs.map(s => s.startId), pendingGliss: pendingGlissStart, pendingHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
 };
 // Encode a staff
-const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, ottavaState = {}, keyFifths = 0, initialClef) => {
+const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, ottavaState = {}, keyFifths = 0, initialClef, glissState = {}) => {
     const staffId = generateId("staff");
     let xml = `${indent}<staff xml:id="${staffId}" n="${staffN}">\n`;
     const allHairpins = [];
@@ -1363,6 +1394,8 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
     const allArpeggios = [];
     const allFermatas = [];
     const allTrills = [];
+    const allBreaths = [];
+    const allGlissandos = [];
     const allMordents = [];
     const allTurns = [];
     const allDynamics = [];
@@ -1373,6 +1406,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
     const allMarkups = [];
     const pendingTies = {};
     const pendingSlurs = {};
+    const pendingGlisses = {};
     const pendingHairpins = {};
     const pendingOctaves = {};
     const ottavaExplicitlyClosed = {};
@@ -1390,7 +1424,8 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             const initialSlur = slurState[tieKey] || [];
             const initialHairpin = hairpinState[tieKey] || null;
             const initialOctave = ottavaState[tieKey] || null;
-            const result = encodeLayer(voice, layerN, indent + '    ', initialTies, keyFifths, endingClef, initialSlur, initialHairpin, initialOctave);
+            const initialGliss = glissState[tieKey] || null;
+            const result = encodeLayer(voice, layerN, indent + '    ', initialTies, keyFifths, endingClef, initialSlur, initialHairpin, initialOctave, initialGliss);
             xml += result.xml;
             allHairpins.push(...result.hairpins);
             allPedals.push(...result.pedals);
@@ -1399,6 +1434,8 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             allArpeggios.push(...result.arpeggios);
             allFermatas.push(...result.fermatas);
             allTrills.push(...result.trills);
+            allBreaths.push(...result.breaths);
+            allGlissandos.push(...result.glissandos);
             allMordents.push(...result.mordents);
             allTurns.push(...result.turns);
             allDynamics.push(...result.dynamics);
@@ -1416,6 +1453,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             // Always record (even empty) so a measure that closed all its slurs
             // clears the carried stack rather than leaving a stale open slur.
             pendingSlurs[tieKey] = result.pendingSlur;
+            pendingGlisses[tieKey] = result.pendingGliss;
             // Track pending hairpins for this layer
             if (result.pendingHairpin) {
                 pendingHairpins[tieKey] = result.pendingHairpin;
@@ -1446,6 +1484,8 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
         arpeggios: allArpeggios,
         fermatas: allFermatas,
         trills: allTrills,
+        breaths: allBreaths,
+        glissandos: allGlissandos,
         mordents: allMordents,
         turns: allTurns,
         dynamics: allDynamics,
@@ -1456,6 +1496,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
         markups: allMarkups,
         pendingTies,
         pendingSlurs,
+        pendingGlisses,
         pendingHairpins,
         pendingOctaves,
         ottavaExplicitlyClosed,
@@ -1566,7 +1607,7 @@ const BARLINE_TO_MEI = {
 };
 // Encode a measure
 // encodeMeasure accepts mutable tieState, slurState, hairpinState, ottavaState and clefState that persist across measures
-const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}, octaveEndReplacements = {}, measureIds) => {
+const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}, octaveEndReplacements = {}, measureIds, glissState = {}) => {
     const measureId = generateId("measure");
     if (measureIds)
         measureIds.push(measureId);
@@ -1578,6 +1619,8 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
     const allArpeggios = [];
     const allFermatas = [];
     const allTrills = [];
+    const allBreaths = [];
+    const allGlissandos = [];
     const allMordents = [];
     const allTurns = [];
     const allDynamics = [];
@@ -1624,7 +1667,7 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
     for (let si = 1; si <= totalStaves; si++) {
         const voices = voicesByStaff[si] || [];
         const initialClef = clefState[si];
-        const result = encodeStaff(voices, si, indent + '    ', tieState, slurState, hairpinState, ottavaState, keyFifths, initialClef);
+        const result = encodeStaff(voices, si, indent + '    ', tieState, slurState, hairpinState, ottavaState, keyFifths, initialClef, glissState);
         staffContent += result.xml;
         allHairpins.push(...result.hairpins);
         allPedals.push(...result.pedals);
@@ -1633,6 +1676,8 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
         allArpeggios.push(...result.arpeggios);
         allFermatas.push(...result.fermatas);
         allTrills.push(...result.trills);
+        allBreaths.push(...result.breaths);
+        allGlissandos.push(...result.glissandos);
         allMordents.push(...result.mordents);
         allTurns.push(...result.turns);
         allDynamics.push(...result.dynamics);
@@ -1646,6 +1691,7 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
         Object.assign(tieState, result.pendingTies);
         // Update slur state with pending slurs from this staff
         Object.assign(slurState, result.pendingSlurs);
+        Object.assign(glissState, result.pendingGlisses);
         // Update hairpin state with pending hairpins from this staff
         Object.assign(hairpinState, result.pendingHairpins);
         // Update ottava state with pending octaves from this staff.
@@ -1718,6 +1764,14 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
     for (const tr of allTrills) {
         staffContent += `${indent}    <trill xml:id="${generateId('trill')}" startid="#${tr.startid}" />\n`;
     }
+    // Generate breath marks (the breath follows its startid note)
+    for (const br of allBreaths) {
+        staffContent += `${indent}    <breath xml:id="${generateId('breath')}" startid="#${br.startid}" />\n`;
+    }
+    // Generate glissando spans (note-to-note slide)
+    for (const gl of allGlissandos) {
+        staffContent += `${indent}    <gliss xml:id="${generateId('gliss')}" startid="#${gl.startid}" endid="#${gl.endid}" />\n`;
+    }
     // Generate mordent control events
     for (const mord of allMordents) {
         const formAttr = mord.form ? ` form="${mord.form}"` : '';
@@ -2294,35 +2348,75 @@ 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
     const slurState = {};
+    const glissState = {};
     // Track hairpin state across measures for cross-measure hairpins
     const hairpinState = {};
     // Track ottava state across measures for cross-measure ottava spans
@@ -2344,26 +2438,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 +2501,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;
-        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;
-        }
+        // 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, glissState);
+        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);