@k-l-lambda/lilylet 0.1.73 → 0.1.75

package/lib/lilylet/meiEncoder.js

@@ -1,6 +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";
 // MEI key signatures: positive = sharps, negative = flats
 const KEY_SIGS = {
     0: "0",
@@ -333,8 +334,10 @@ const extractMarkOptions = (marks) => {
         beamStart: false,
         beamEnd: false,
         dynamic: undefined,
+        dynamics: [],
         hairpin: undefined,
         pedal: undefined,
+        pedals: [],
         tremolo: undefined,
         fingerings: [],
         navigation: undefined,
@@ -380,7 +383,8 @@ const extractMarkOptions = (marks) => {
             case 'dynamic': {
                 const dynStr = DYNAMIC_MAP[mark.type];
                 if (dynStr) {
-                    result.dynamic = dynStr;
+                    result.dynamic = dynStr; // kept for back-compat (first dynamic)
+                    result.dynamics.push(dynStr);
                 }
                 break;
             }
@@ -391,16 +395,22 @@ const extractMarkOptions = (marks) => {
                 else if (mark.type === HairpinType.diminuendoStart) {
                     result.hairpin = 'dimStart';
                 }
-                else if (mark.type === HairpinType.crescendoEnd || mark.type === HairpinType.diminuendoEnd) {
-                    result.hairpin = 'end';
+                else if (mark.type === HairpinType.crescendoEnd) {
+                    result.hairpin = 'crescEnd';
+                }
+                else if (mark.type === HairpinType.diminuendoEnd) {
+                    result.hairpin = 'dimEnd';
                 }
                 break;
             case 'pedal':
+                // A note can carry more than one pedal mark (a pedal "bounce": an up
+                // to release the previous pedal and an immediate down to re-pedal on
+                // the same note), so collect ALL of them rather than keep one scalar.
                 if (mark.type === PedalType.sustainOn) {
-                    result.pedal = 'down';
+                    result.pedals.push('down');
                 }
                 else if (mark.type === PedalType.sustainOff) {
-                    result.pedal = 'up';
+                    result.pedals.push('up');
                 }
                 break;
             case 'tie':
@@ -489,6 +499,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
             elementId: noteId,
             hairpin: markOptions.hairpin,
             pedal: markOptions.pedal,
+            pedals: markOptions.pedals,
             hasTieStart: markOptions.tieStart,
             pitches: event.pitches,
             arpeggio: markOptions.arpeggio,
@@ -497,6 +508,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
             mordent: markOptions.mordent,
             turn: markOptions.turn,
             dynamic: markOptions.dynamic,
+            dynamics: markOptions.dynamics,
             slurStart: markOptions.slurStart,
             slurEnd: markOptions.slurEnd,
             fingerings: markOptions.fingerings,
@@ -549,6 +561,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
         elementId: chordId,
         hairpin: markOptions.hairpin,
         pedal: markOptions.pedal,
+        pedals: markOptions.pedals,
         hasTieStart: markOptions.tieStart,
         pitches: event.pitches,
         arpeggio: markOptions.arpeggio,
@@ -557,6 +570,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
         mordent: markOptions.mordent,
         turn: markOptions.turn,
         dynamic: markOptions.dynamic,
+        dynamics: markOptions.dynamics,
         slurStart: markOptions.slurStart,
         slurEnd: markOptions.slurEnd,
         fingerings: markOptions.fingerings,
@@ -574,6 +588,15 @@ const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAc
     // Cross-staff attribute
     if (crossStaff)
         attrs += ` staff="${crossStaff}"`;
+    // A rest may carry a fermata (held silence). Surface it so the layer loop can
+    // emit a <fermata> control event referencing this rest's id.
+    let fermata;
+    if (event.marks) {
+        for (const mk of event.marks) {
+            if (mk.markType === 'ornament' && mk.type === 'fermata')
+                fermata = 'normal';
+        }
+    }
     // Pitched rest (positioned at specific pitch)
     if (event.pitch) {
         const pitch = encodePitch(event.pitch, keyFifths, ottavaShift);
@@ -581,14 +604,14 @@ const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAc
     }
     // Space rest (invisible)
     if (event.invisible) {
-        return { xml: `${indent}<space ${attrs} />\n`, elementId: restId };
+        return { xml: `${indent}<space ${attrs} />\n`, elementId: restId, fermata };
     }
     // Full measure rest
     if (event.fullMeasure) {
         const mRestId = generateId('mrest');
-        return { xml: `${indent}<mRest xml:id="${mRestId}" />\n`, elementId: mRestId };
+        return { xml: `${indent}<mRest xml:id="${mRestId}" />\n`, elementId: mRestId, fermata };
     }
-    return { xml: `${indent}<rest ${attrs} />\n`, elementId: restId };
+    return { xml: `${indent}<rest ${attrs} />\n`, elementId: restId, fermata };
 };
 // Check if a tuplet has balanced internal beam groups (both [ and ] inside the same tuplet)
 // Returns false for cross-tuplet beams where [ is in one tuplet and ] in another
@@ -619,6 +642,7 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
     const effectiveStaff = currentStaff ?? layerStaff;
     // Collect control event info from notes inside tuplet
     let firstNoteId = null;
+    let lastNoteId = null; // last note/rest id — anchors an ottava span end
     const slurStarts = [];
     const slurEnds = [];
     const dynamics = [];
@@ -627,6 +651,9 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
     const mordents = [];
     const turns = [];
     const arpeggios = [];
+    const pedals = [];
+    const fingerings = [];
+    const markups = [];
     // Handle internal beam groups: if notes have manual beam marks, respect them
     const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
     let beamOpen = false;
@@ -650,14 +677,16 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
             xml += result.xml;
             if (!firstNoteId)
                 firstNoteId = result.elementId;
+            lastNoteId = result.elementId;
             // Collect slur info
             if (result.slurStart)
                 slurStarts.push(result.elementId);
             if (result.slurEnd)
                 slurEnds.push(result.elementId);
             // Collect other control events
-            if (result.dynamic)
-                dynamics.push({ startid: result.elementId, label: result.dynamic });
+            if (result.dynamics)
+                for (const label of result.dynamics)
+                    dynamics.push({ startid: result.elementId, label });
             if (result.fermata)
                 fermatas.push({ startid: result.elementId, shape: result.fermata === 'short' ? 'angular' : undefined });
             if (result.trill)
@@ -668,6 +697,16 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
                 turns.push({ startid: result.elementId });
             if (result.arpeggio)
                 arpeggios.push({ plist: result.elementId });
+            if (result.pedals)
+                for (const dir of result.pedals)
+                    pedals.push({ startId: result.elementId, dir });
+            // Fingerings and text directions (markup) on inner notes are control
+            // events that attach by id — collect them so the layer loop can emit
+            // <fing>/<dir> for them (previously silently dropped inside tuplets).
+            for (const fing of result.fingerings)
+                fingerings.push({ startid: result.elementId, finger: fing.finger, placement: fing.placement });
+            for (const mkup of result.markups)
+                markups.push({ startid: result.elementId, content: mkup.content, placement: mkup.placement });
             // Close beam if this note ends a beam group
             if (hasInternalBeams && markOptions.beamEnd && beamOpen) {
                 xml += `${baseIndent}</beam>\n`;
@@ -676,7 +715,11 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
         }
         else if (e.type === 'rest') {
             const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-            xml += restEventToMEI(e, restIndent, keyFifths, ottavaShift, measureAccidentals).xml;
+            const restResult = restEventToMEI(e, restIndent, keyFifths, ottavaShift, measureAccidentals);
+            xml += restResult.xml;
+            lastNoteId = restResult.elementId;
+            if (restResult.fermata)
+                fermatas.push({ startid: restResult.elementId, shape: restResult.fermata === 'short' ? 'angular' : undefined });
         }
         else if (e.type === 'context') {
             const ctx = e;
@@ -697,7 +740,7 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
         xml += `${baseIndent}</beam>\n`;
     }
     xml += `${indent}</tuplet>\n`;
-    return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, endingClef };
+    return { xml, firstNoteId, lastNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, pedals, fingerings, markups, endingClef };
 };
 // Convert TremoloEvent to MEI (fingered tremolo - alternating between two notes)
 const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
@@ -803,16 +846,20 @@ const getEventBeamMarks = (event) => {
     return { beamStart: false, beamEnd: false };
 };
 // Encode a layer (voice)
-const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths = 0, initialClef, initialSlur = null, initialHairpin = null, initialOctave = null) => {
+const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths = 0, initialClef, initialSlurs = [], initialHairpin = null, initialOctave = 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)
     const baseIndent = indent + '    ';
     // Track current clef to only emit changes
     let currentClef = initialClef;
-    // Track hairpin spans
+    // Track hairpin spans. Use a stack of open hairpins (not a single slot): the
+    // flattened layer stream can interleave overlapping/cross-staff hairpins
+    // (e.g. a crescendo starting before the previous one ended), and a single slot
+    // would silently overwrite the earlier one. Seed with any hairpin still open
+    // from the previous measure (cross-measure carry).
     const hairpins = [];
-    let currentHairpin = initialHairpin;
+    const openHairpins = initialHairpin ? [initialHairpin] : [];
     // Track pedal marks (each is independent, not paired spans)
     const pedals = [];
     // Track octave spans - initialize from previous measure if continuing
@@ -823,9 +870,52 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     let currentOttavaShift = initialOctave?.shift || 0; // Track current ottava shift for pitch encoding
     let lastNoteId = null; // Track last note id for ending ottava spans
     let ottavaExplicitlyClosed = false; // Track if ottava was explicitly closed by \ottava #0
-    // Track slur spans - slurs must be encoded as control events in MEI
+    // ── Ottava span anchoring (shared by note / rest / tuplet cases) ──
+    // Originally the open/extend/close logic lived ONLY in `case 'note'`, so an
+    // ottava span running over a tuplet run (ubiquitous in etudes) or over rests
+    // was never opened — the whole span vanished (No.26 10→0, No.20 7→0). These
+    // helpers let any event type anchor a span. Mirror the note-case ordering:
+    // the caller updates lastNoteId to the event's first emitted id, THEN calls
+    // these.
+    // Apply a pending ottava's pitch shift before the event's notes are encoded.
+    const applyPendingOttavaShift = () => {
+        if (pendingOttava !== null && pendingOttava !== 0)
+            currentOttavaShift = pendingOttava;
+    };
+    // Extend a carried (endToken) span's end to this event's last emitted id.
+    const extendOttavaEnd = (lastId) => {
+        if (currentOctave?.endToken)
+            octaveEndReplacements[currentOctave.endToken] = lastId;
+    };
+    // Open the pending ottava span on `anchorId` (the event's FIRST emitted id),
+    // closing any open span of a different value first; or resolve a continued span.
+    const applyOttavaAnchor = (anchorId) => {
+        if (pendingOttava !== null && pendingOttava !== 0) {
+            const dis = Math.abs(pendingOttava) === 2 ? 15 : 8;
+            const disPlace = pendingOttava > 0 ? 'above' : 'below';
+            if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
+                octaves.push({ dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, endId: anchorId });
+                currentOctave = null;
+            }
+            if (!currentOctave)
+                currentOctave = { dis, disPlace, startId: anchorId };
+            pendingOttava = null;
+        }
+        else if (currentOctave?.continued) {
+            if (!currentOctave.endToken)
+                currentOctave.startId = anchorId;
+            currentOctave.continued = false;
+        }
+    };
+    // Track slur spans - slurs must be encoded as control events in MEI.
+    // A single slot can't hold the overlapping/concurrent slurs that piano writing
+    // produces (measured up to 3 open at once per voice); a new start while one was
+    // open overwrote it and the span was lost. Use a STACK and pair each end to the
+    // most-recent open slur (LIFO), matching the hairpin fix. `currentSlur` is kept
+    // as a view of the stack top for the existing cross-measure carry plumbing.
     const slurs = [];
-    let currentSlur = initialSlur ? { startId: initialSlur } : null;
+    const openSlurs = initialSlurs.map(startId => ({ startId }));
+    let currentSlur = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
     // Track arpeggio refs
     const arpeggios = [];
     // Track ornament refs
@@ -908,9 +998,7 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 // Check if this note should have tie="t" (matches pending tie)
                 const tieEnd = pendingTiePitches.length > 0 && pitchesMatch(pendingTiePitches, noteEvent.pitches);
                 // If there's a pending ottava, apply it BEFORE encoding the note
-                if (pendingOttava !== null && pendingOttava !== 0) {
-                    currentOttavaShift = pendingOttava; // Apply the shift for this note
-                }
+                applyPendingOttavaShift();
                 // For cross-staff notation: set note's staff to currentStaff if different from voice.staff
                 const effectiveNoteEvent = currentStaff !== voice.staff
                     ? { ...noteEvent, staff: currentStaff }
@@ -918,41 +1006,13 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
                 xml += result.xml;
                 lastNoteId = result.elementId;
-                if (currentOctave?.endToken) {
-                    octaveEndReplacements[currentOctave.endToken] = result.elementId;
-                }
+                extendOttavaEnd(result.elementId);
                 // Flush any pending markups onto this note
                 flushPendingMarkups(result.elementId);
                 // Flush any pending leading dynamics onto this note
                 flushPendingDynamics(result.elementId);
                 // If there's a pending ottava, start the span on this note
-                if (pendingOttava !== null && pendingOttava !== 0) {
-                    const dis = Math.abs(pendingOttava) === 2 ? 15 : 8;
-                    const disPlace = pendingOttava > 0 ? 'above' : 'below';
-                    // Close existing span first if it has a different value
-                    if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
-                        if (lastNoteId) {
-                            octaves.push({
-                                dis: currentOctave.dis,
-                                disPlace: currentOctave.disPlace,
-                                startId: currentOctave.startId,
-                                endId: lastNoteId,
-                            });
-                        }
-                        currentOctave = null;
-                    }
-                    // Start new span if we don't already have one with the same value
-                    if (!currentOctave) {
-                        currentOctave = { dis, disPlace, startId: result.elementId };
-                    }
-                    pendingOttava = null;
-                }
-                else if (currentOctave?.continued) {
-                    if (!currentOctave.endToken) {
-                        currentOctave.startId = result.elementId;
-                    }
-                    currentOctave.continued = false;
-                }
+                applyOttavaAnchor(result.elementId);
                 // Update pending tie pitches
                 if (result.hasTieStart) {
                     pendingTiePitches = result.pitches;
@@ -962,38 +1022,52 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 }
                 // Track hairpin spans
                 if (result.hairpin === 'crescStart') {
-                    currentHairpin = { form: 'cres', startId: result.elementId };
+                    openHairpins.push({ form: 'cres', startId: result.elementId });
                 }
                 else if (result.hairpin === 'dimStart') {
-                    currentHairpin = { form: 'dim', startId: result.elementId };
-                }
-                else if (result.hairpin === 'end' && currentHairpin) {
+                    openHairpins.push({ form: 'dim', startId: result.elementId });
+                }
+                else if ((result.hairpin === 'crescEnd' || result.hairpin === 'dimEnd') && openHairpins.length > 0) {
+                    const endForm = result.hairpin === 'crescEnd' ? 'cres' : 'dim';
+                    // Close the most-recent open hairpin of the matching form; if none
+                    // matches (interleaved/malformed input), fall back to the newest open.
+                    let idx = -1;
+                    for (let i = openHairpins.length - 1; i >= 0; i--) {
+                        if (openHairpins[i].form === endForm) {
+                            idx = i;
+                            break;
+                        }
+                    }
+                    if (idx < 0)
+                        idx = openHairpins.length - 1;
+                    const open = openHairpins.splice(idx, 1)[0];
                     hairpins.push({
-                        form: currentHairpin.form,
-                        startId: currentHairpin.startId,
+                        form: open.form,
+                        startId: open.startId,
                         endId: result.elementId,
                     });
-                    currentHairpin = null;
                 }
-                // Track pedal marks (each is independent)
-                if (result.pedal === 'down' || result.pedal === 'up') {
-                    pedals.push({
-                        startId: result.elementId,
-                        dir: result.pedal,
-                    });
+                // Track pedal marks (each is independent; a note may carry several,
+                // e.g. an up+down pedal bounce at the same beat).
+                if (result.pedals) {
+                    for (const dir of result.pedals) {
+                        pedals.push({ startId: result.elementId, dir });
+                    }
                 }
                 // Track slur spans - end must be processed before start
-                // in case a note ends one slur and starts another
-                if (result.slurEnd && currentSlur) {
+                // in case a note ends one slur and starts another.
+                // Pair an end to the most-recent open slur (LIFO).
+                if (result.slurEnd && openSlurs.length > 0) {
+                    const open = openSlurs.pop();
                     slurs.push({
-                        startId: currentSlur.startId,
+                        startId: open.startId,
                         endId: result.elementId,
                     });
-                    currentSlur = null;
                 }
                 if (result.slurStart) {
-                    currentSlur = { startId: result.elementId };
+                    openSlurs.push({ startId: result.elementId });
                 }
+                currentSlur = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
                 // Track arpeggio refs
                 if (result.arpeggio) {
                     arpeggios.push({ plist: result.elementId });
@@ -1017,8 +1091,9 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 if (result.turn) {
                     turns.push({ startid: result.elementId });
                 }
-                if (result.dynamic) {
-                    dynamics.push({ startid: result.elementId, label: result.dynamic });
+                if (result.dynamics) {
+                    for (const label of result.dynamics)
+                        dynamics.push({ startid: result.elementId, label });
                 }
                 // Track fingerings
                 for (const fing of result.fingerings) {
@@ -1037,20 +1112,39 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
             case 'rest': {
                 // For cross-staff notation: pass staff number if different from voice's home staff
                 const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
+                // A pending ottava shift applies to a rest's gestural octave too.
+                applyPendingOttavaShift();
                 const restResult = restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
                 xml += restResult.xml;
+                lastNoteId = restResult.elementId;
+                // An ottava span may open on, run through, or close at a rest (e.g. a
+                // span that starts just before LH rests). Anchor it like a note.
+                extendOttavaEnd(restResult.elementId);
+                applyOttavaAnchor(restResult.elementId);
+                // Fermata over a rest (held silence) — emit as a control event on the rest.
+                if (restResult.fermata)
+                    fermatas.push({ startid: restResult.elementId, shape: restResult.fermata === 'short' ? 'angular' : undefined });
                 // A leading dynamic/markup attaches to the next event, which may be this rest
                 flushPendingMarkups(restResult.elementId);
                 flushPendingDynamics(restResult.elementId);
-                lastNoteId = restResult.elementId;
                 break;
             }
             case 'tuplet':
             case 'times': {
                 // Tuplet can be nested inside beam in MEI: <beam><tuplet>...</tuplet></beam>
                 // Pass beamElementOpen to tuplet so it knows not to create its own beam
+                // A pending ottava shift applies to the tuplet's notes' written octave.
+                applyPendingOttavaShift();
                 const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals, currentClef);
                 xml += tupletResult.xml;
+                // An ottava span can open on, run through, or close at a tuplet (common
+                // in etudes where the 8va covers a whole tuplet run). Anchor the span on
+                // the tuplet's FIRST note and let its LAST note close/extend it — without
+                // this the entire span was dropped (start/close lived only in case 'note').
+                if (tupletResult.firstNoteId)
+                    applyOttavaAnchor(tupletResult.firstNoteId);
+                if (tupletResult.lastNoteId)
+                    extendOttavaEnd(tupletResult.lastNoteId);
                 // Propagate clef change from inside the tuplet to the parent tracker
                 if (tupletResult.endingClef) {
                     currentClef = tupletResult.endingClef;
@@ -1059,22 +1153,23 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 if (tupletResult.firstNoteId) {
                     flushPendingMarkups(tupletResult.firstNoteId);
                     flushPendingDynamics(tupletResult.firstNoteId);
-                    lastNoteId = tupletResult.firstNoteId;
+                    lastNoteId = tupletResult.lastNoteId ?? tupletResult.firstNoteId;
                 }
-                // Process slur ends first (to close any pending slurs from before this tuplet)
+                // Process slur ends first (to close open slurs, LIFO), then starts.
                 for (const endId of tupletResult.slurEnds) {
-                    if (currentSlur) {
+                    if (openSlurs.length > 0) {
+                        const open = openSlurs.pop();
                         slurs.push({
-                            startId: currentSlur.startId,
+                            startId: open.startId,
                             endId: endId,
                         });
-                        currentSlur = null;
                     }
                 }
                 // Then process slur starts (to open new slurs)
                 for (const startId of tupletResult.slurStarts) {
-                    currentSlur = { startId };
+                    openSlurs.push({ startId });
                 }
+                currentSlur = openSlurs.length ? openSlurs[openSlurs.length - 1] : null;
                 // Collect other control events from tuplet
                 dynamics.push(...tupletResult.dynamics);
                 fermatas.push(...tupletResult.fermatas);
@@ -1082,6 +1177,9 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 mordents.push(...tupletResult.mordents);
                 turns.push(...tupletResult.turns);
                 arpeggios.push(...tupletResult.arpeggios);
+                pedals.push(...tupletResult.pedals);
+                fingerings.push(...tupletResult.fingerings);
+                markups.push(...tupletResult.markups);
                 break;
             }
             case 'tremolo':
@@ -1114,8 +1212,22 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                             currentOctave = null;
                             ottavaExplicitlyClosed = true; // Mark that we explicitly closed the span
                         }
-                        // Note: if no lastNoteId (e.g., at measure start), keep currentOctave alive
-                        // It may be continued by a subsequent ottava command with the same value
+                        else if (currentOctave && currentOctave.emitted) {
+                            // Stop landed at measure START (no note yet in this layer) but the
+                            // span was carried+emitted in a PREVIOUS measure: it genuinely ends
+                            // here. Its deferred endToken was already resolved to the correct
+                            // last note by extendOttavaEnd as the span ran through prior measures
+                            // (or by the staff-level carry's endFallbackId), so DON'T rewrite it
+                            // here — just clear the slot and mark closed, so a later same-value
+                            // ottava opens a NEW span instead of folding into this one.
+                            // Without this, sequential cross-measure spans collapse into one
+                            // (No.57: 18 spans → 8).
+                            currentOctave = null;
+                            ottavaExplicitlyClosed = true;
+                        }
+                        // Note: if no lastNoteId and not yet emitted (e.g., open+close at
+                        // measure start with no notes), keep currentOctave alive — it may be
+                        // continued by a subsequent ottava command with the same value.
                         currentOttavaShift = 0; // Reset the shift (will be restored if continued)
                     }
                     else {
@@ -1222,8 +1334,23 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     const pendingOctave = currentOctave
         ? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift, continued: true, emitted: currentOctave.emitted, endToken: currentOctave.endToken, endFallbackId: currentOctave.endFallbackId }
         : null;
+    // Resolve hairpins still open at layer end. The cross-measure carry supports a
+    // single pending hairpin, so keep the OLDEST open span (bottom of stack — most
+    // likely to legitimately continue into the next measure) as pendingHairpin, and
+    // flush the rest here, ending them at the last note so they aren't dropped
+    // (MusicXML files routinely leave wedges unclosed). Without a last note id there
+    // is nothing to attach to, so those are unavoidably dropped.
+    let pendingHairpin = null;
+    if (openHairpins.length > 0) {
+        pendingHairpin = openHairpins[0];
+        for (let i = 1; i < openHairpins.length; i++) {
+            if (lastNoteId) {
+                hairpins.push({ form: openHairpins[i].form, startId: openHairpins[i].startId, endId: lastNoteId });
+            }
+        }
+    }
     xml += `${indent}</layer>\n`;
-    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
+    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 };
 };
 // Encode a staff
 const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, ottavaState = {}, keyFifths = 0, initialClef) => {
@@ -1260,7 +1387,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             const layerN = vi + 1;
             const tieKey = `${staffN}-${layerN}`;
             const initialTies = tieState[tieKey] || [];
-            const initialSlur = slurState[tieKey] || null;
+            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);
@@ -1286,9 +1413,9 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
                 pendingTies[tieKey] = result.pendingTiePitches;
             }
             // Track pending slurs for this layer
-            if (result.pendingSlur) {
-                pendingSlurs[tieKey] = result.pendingSlur;
-            }
+            // 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;
             // Track pending hairpins for this layer
             if (result.pendingHairpin) {
                 pendingHairpins[tieKey] = result.pendingHairpin;
@@ -1439,8 +1566,10 @@ 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 = {}) => {
+const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}, octaveEndReplacements = {}, measureIds) => {
     const measureId = generateId("measure");
+    if (measureIds)
+        measureIds.push(measureId);
     let staffContent = ''; // Build staff content first, then add measure tag with barline
     const allHairpins = [];
     const allPedals = [];
@@ -2160,6 +2289,36 @@ const encode = (doc, options = {}) => {
     mei += `${indent}${indent}${indent}${indent}<score xml:id="${generateId("score")}">\n`;
     mei += encodeScoreDef(keySig, currentTimeNum, currentTimeDen, partInfos, `${indent}${indent}${indent}${indent}${indent}`, currentMeterSymbol, doc.metadata?.staves, doc.metadata?.instruments);
     mei += `${indent}${indent}${indent}${indent}${indent}<section xml:id="${generateId("section")}">\n`;
+    // Splice point for an <expansion> element (must be the FIRST child of
+    // <section>, but its plist needs the measure ids collected during the loop
+    // 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
+    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);
+                }
+            }
+        }
+        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
@@ -2266,8 +2425,55 @@ const encode = (doc, options = {}) => {
                 mei += `${sd}</scoreDef>\n`;
             }
         }
-        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
+        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;
+        }
     });
+    // 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) {
+        try {
+            const layout = parseMeasureLayout(doc.metadata.measureLayout);
+            const order = expandMeasureLayout(layout);
+            const refs = [];
+            for (const idx of order) {
+                const id = measureIds[idx - 1]; // 1-based index into notated measures
+                if (id === undefined) {
+                    console.warn(`[measures] index ${idx} out of range (only ${measureIds.length} measures); skipping`);
+                    continue;
+                }
+                refs.push(`#${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);
+            }
+        }
+        catch (err) {
+            console.warn(`[measures] failed to parse "${doc.metadata.measureLayout}": ${err.message}`);
+        }
+    }
     mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
     mei += `${indent}${indent}${indent}${indent}</score>\n`;
     mei += `${indent}${indent}${indent}</mdiv>\n`;