@k-l-lambda/lilylet 0.1.73 → 0.1.74

package/lib/lilylet/meiEncoder.js

@@ -333,8 +333,10 @@ const extractMarkOptions = (marks) => {
         beamStart: false,
         beamEnd: false,
         dynamic: undefined,
+        dynamics: [],
         hairpin: undefined,
         pedal: undefined,
+        pedals: [],
         tremolo: undefined,
         fingerings: [],
         navigation: undefined,
@@ -380,7 +382,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 +394,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 +498,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 +507,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 +560,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 +569,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 +587,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 +603,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
@@ -627,6 +649,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;
@@ -656,8 +681,9 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
             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 +694,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 +712,10 @@ 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;
+            if (restResult.fermata)
+                fermatas.push({ startid: restResult.elementId, shape: restResult.fermata === 'short' ? 'angular' : undefined });
         }
         else if (e.type === 'context') {
             const ctx = e;
@@ -697,7 +736,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, 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 +842,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 +866,15 @@ 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
+    // 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
@@ -962,38 +1011,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 +1080,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) {
@@ -1039,6 +1103,9 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
                 const restResult = restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
                 xml += restResult.xml;
+                // 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);
@@ -1061,20 +1128,21 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     flushPendingDynamics(tupletResult.firstNoteId);
                     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 +1150,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':
@@ -1222,8 +1293,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 +1346,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 +1372,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;

package/lib/lilylet/musicXmlDecoder.d.ts

@@ -8,13 +8,23 @@ import { LilyletDoc } from './types';
 /**
  * Decode MusicXML string to LilyletDoc
  */
-export declare const decode: (xmlString: string) => LilyletDoc;
+/**
+ * Decode raw MusicXML bytes (or a string) into a clean UTF-8/UTF-16-correct
+ * JS string. MuseScore/Finale/Sibelius frequently export `.xml` as UTF-16 LE
+ * with a BOM; reading those as UTF-8 yields mojibake and a failed parse.
+ *
+ * Detection order: byte-order mark → declared `encoding="..."` in the XML
+ * prolog → default UTF-8. A leading BOM is always stripped (xmldom chokes on a
+ * U+FEFF before `<?xml`).
+ */
+export declare const readXmlString: (input: string | Uint8Array) => string;
+export declare const decode: (input: string | Uint8Array) => LilyletDoc;
 /**
  * Decode MusicXML file to LilyletDoc
  */
 export declare const decodeFile: (filePath: string) => Promise<LilyletDoc>;
 declare const _default: {
-    decode: (xmlString: string) => LilyletDoc;
+    decode: (input: string | Uint8Array) => LilyletDoc;
     decodeFile: (filePath: string) => Promise<LilyletDoc>;
 };
 export default _default;