@k-l-lambda/lilylet 0.1.30

package/lib/meiEncoder.js

@@ -0,0 +1,1386 @@
+import { Clef, Accidental, OrnamentType, StemDirection, HairpinType, PedalType, } from "./types.js";
+// MEI key signatures: positive = sharps, negative = flats
+const KEY_SIGS = {
+    0: "0",
+    1: "1s",
+    2: "2s",
+    3: "3s",
+    4: "4s",
+    5: "5s",
+    6: "6s",
+    7: "7s",
+    [-1]: "1f",
+    [-2]: "2f",
+    [-3]: "3f",
+    [-4]: "4f",
+    [-5]: "5f",
+    [-6]: "6f",
+    [-7]: "7f",
+};
+// Key signature to fifths number
+const keyToFifths = (key) => {
+    if (!key)
+        return 0;
+    // Major keys
+    const majorKeys = {
+        'c': 0, 'd': 2, 'e': 4, 'f': -1, 'g': 1, 'a': 3, 'b': 5,
+    };
+    let fifths = majorKeys[key.pitch] || 0;
+    if (key.accidental === Accidental.sharp)
+        fifths += 7;
+    else if (key.accidental === Accidental.flat)
+        fifths -= 7;
+    if (key.mode === 'minor')
+        fifths -= 3;
+    return fifths;
+};
+const CLEF_SHAPES = {
+    treble: { shape: "G", line: 2 },
+    bass: { shape: "F", line: 4 },
+    alto: { shape: "C", line: 3 },
+    // Also support uppercase letter clef names
+    G: { shape: "G", line: 2 },
+    F: { shape: "F", line: 4 },
+    C: { shape: "C", line: 3 },
+};
+// Lilylet duration division to MEI dur
+// division: 1=whole, 2=half, 4=quarter, 8=eighth, etc.
+const DURATIONS = {
+    1: "1", // whole
+    2: "2", // half
+    4: "4", // quarter
+    8: "8", // eighth
+    16: "16",
+    32: "32",
+    64: "64",
+    128: "128",
+};
+// Accidental mapping
+const ACCIDENTALS = {
+    natural: "n",
+    sharp: "s",
+    flat: "f",
+    doubleSharp: "x",
+    doubleFlat: "ff",
+};
+// Articulation to MEI artic
+const ARTIC_MAP = {
+    staccato: "stacc",
+    staccatissimo: "stacciss",
+    tenuto: "ten",
+    marcato: "marc",
+    accent: "acc",
+    portato: "stacc ten", // Both staccato and tenuto (portato)
+};
+// Dynamic to MEI
+const DYNAMIC_MAP = {
+    ppp: "ppp",
+    pp: "pp",
+    p: "p",
+    mp: "mp",
+    mf: "mf",
+    f: "f",
+    ff: "ff",
+    fff: "fff",
+    sfz: "sfz",
+    rfz: "rfz",
+};
+// ID generation state - uses session prefix to prevent collisions in concurrent encoding
+let idCounter = 0;
+let sessionPrefix = '';
+const generateId = (prefix) => {
+    return `${prefix}-${sessionPrefix}${String(++idCounter).padStart(10, "0")}`;
+};
+const resetIdCounter = () => {
+    idCounter = 0;
+    // Generate a unique 4-char hex session prefix for this encode call
+    sessionPrefix = Math.random().toString(16).substring(2, 6);
+};
+// Sharp and flat order for key signatures (circle of fifths)
+const SHARP_ORDER = ['f', 'c', 'g', 'd', 'a', 'e', 'b'];
+const FLAT_ORDER = ['b', 'e', 'a', 'd', 'g', 'c', 'f'];
+// Get the accidentals implied by a key signature
+// fifths > 0 = sharps, fifths < 0 = flats
+const getKeyAccidentals = (fifths) => {
+    const result = {};
+    if (fifths > 0) {
+        // Sharps
+        for (let i = 0; i < Math.min(fifths, 7); i++) {
+            result[SHARP_ORDER[i]] = 's'; // sharp
+        }
+    }
+    else if (fifths < 0) {
+        // Flats
+        for (let i = 0; i < Math.min(-fifths, 7); i++) {
+            result[FLAT_ORDER[i]] = 'f'; // flat
+        }
+    }
+    return result;
+};
+// Convert Pitch to MEI attributes, checking against key signature
+// ottavaShift: current ottava level (1 = 8va up, -1 = 8vb down, 2 = 15ma up, etc.)
+// The written pitch should be adjusted by subtracting the ottava shift
+const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0) => {
+    // Lilylet octave: 0 = middle C octave (C4), positive = higher, negative = lower
+    // When ottava is active, the source pitch is the sounding pitch, but we need to output the written pitch
+    // For 8va up (ottavaShift=1), written pitch is one octave lower than sounding
+    const oct = 4 + pitch.octave - ottavaShift;
+    // Get the accidental implied by the key signature for this note
+    const keyAccidentals = getKeyAccidentals(keyFifths);
+    const keyAccid = keyAccidentals[pitch.phonet];
+    // Determine if we need to output an accid attribute
+    let accid;
+    if (pitch.accidental) {
+        const noteAccid = ACCIDENTALS[pitch.accidental];
+        // Only output accid if it's different from what the key implies
+        if (noteAccid !== keyAccid) {
+            accid = noteAccid;
+        }
+    }
+    else if (keyAccid) {
+        // Note has no accidental but key implies one - output natural
+        accid = 'n';
+    }
+    return { pname: pitch.phonet, oct, accid };
+};
+// Convert tremolo division to stem.mod value
+const tremoloToStemMod = (division) => {
+    // 8 = 1slash (eighth note strokes), 16 = 2slash, 32 = 3slash, etc.
+    const slashes = Math.log2(division) - 2; // 8->1, 16->2, 32->3
+    if (slashes >= 1 && slashes <= 6) {
+        return `${slashes}slash`;
+    }
+    return undefined;
+};
+// Build note element
+const buildNoteElement = (pitch, dur, dots, indent, inChord, options = {}, noteId) => {
+    const id = noteId || generateId('note');
+    let attrs = `xml:id="${id}" pname="${pitch.pname}" oct="${pitch.oct}"`;
+    if (!inChord) {
+        attrs += ` dur="${dur}"`;
+    }
+    if (pitch.accid)
+        attrs += ` accid="${pitch.accid}"`;
+    if (!inChord && dots > 0)
+        attrs += ` dots="${dots}"`;
+    if (!inChord && options.grace)
+        attrs += ` grace="unacc"`;
+    if (!inChord && options.tie)
+        attrs += ` tie="${options.tie}"`;
+    if (!inChord && options.stemDir)
+        attrs += ` stem.dir="${options.stemDir}"`;
+    if (!inChord && options.layerStaff && options.staff && options.staff !== options.layerStaff) {
+        attrs += ` staff="${options.staff}"`;
+    }
+    if (!inChord && options.tremolo) {
+        const stemMod = tremoloToStemMod(options.tremolo);
+        if (stemMod)
+            attrs += ` stem.mod="${stemMod}"`;
+    }
+    // Only artics remain as child elements; ornaments are control events
+    const hasChildren = !inChord && options.artics && options.artics.length > 0;
+    if (!hasChildren) {
+        return `${indent}<note ${attrs} />\n`;
+    }
+    let result = `${indent}<note ${attrs}>\n`;
+    if (options.artics && options.artics.length > 0) {
+        // Group artics by placement
+        const aboveArtics = options.artics.filter(a => a.placement === 'above').map(a => a.type);
+        const belowArtics = options.artics.filter(a => a.placement === 'below').map(a => a.type);
+        const defaultArtics = options.artics.filter(a => !a.placement).map(a => a.type);
+        if (aboveArtics.length > 0) {
+            result += `${indent}    <artic artic="${aboveArtics.join(' ')}" place="above" />\n`;
+        }
+        if (belowArtics.length > 0) {
+            result += `${indent}    <artic artic="${belowArtics.join(' ')}" place="below" />\n`;
+        }
+        if (defaultArtics.length > 0) {
+            result += `${indent}    <artic artic="${defaultArtics.join(' ')}" />\n`;
+        }
+    }
+    result += `${indent}</note>\n`;
+    return result;
+};
+// Extract mark properties from note event
+const extractMarkOptions = (marks) => {
+    const result = {
+        artics: [],
+        fermata: false,
+        trill: false,
+        arpeggio: false,
+        turn: false,
+        mordent: false, // lower = mordent, upper = prall
+        slurStart: false,
+        slurEnd: false,
+        tieStart: false,
+        beamStart: false,
+        beamEnd: false,
+        dynamic: undefined,
+        hairpin: undefined,
+        pedal: undefined,
+        tremolo: undefined,
+        fingerings: [],
+        navigation: undefined,
+        markups: [],
+    };
+    if (!marks)
+        return result;
+    for (const mark of marks) {
+        switch (mark.markType) {
+            case 'articulation': {
+                const articType = ARTIC_MAP[mark.type];
+                if (articType) {
+                    result.artics.push({
+                        type: articType,
+                        placement: mark.placement,
+                    });
+                }
+                break;
+            }
+            case 'ornament':
+                if (mark.type === OrnamentType.fermata) {
+                    result.fermata = 'normal';
+                }
+                else if (mark.type === OrnamentType.shortFermata) {
+                    result.fermata = 'short';
+                }
+                else if (mark.type === OrnamentType.trill) {
+                    result.trill = true;
+                }
+                else if (mark.type === OrnamentType.arpeggio) {
+                    result.arpeggio = true;
+                }
+                else if (mark.type === OrnamentType.turn) {
+                    result.turn = true;
+                }
+                else if (mark.type === OrnamentType.mordent) {
+                    result.mordent = 'lower';
+                }
+                else if (mark.type === OrnamentType.prall) {
+                    result.mordent = 'upper';
+                }
+                break;
+            case 'dynamic': {
+                const dynStr = DYNAMIC_MAP[mark.type];
+                if (dynStr) {
+                    result.dynamic = dynStr;
+                }
+                break;
+            }
+            case 'hairpin':
+                if (mark.type === HairpinType.crescendoStart) {
+                    result.hairpin = 'crescStart';
+                }
+                else if (mark.type === HairpinType.diminuendoStart) {
+                    result.hairpin = 'dimStart';
+                }
+                else if (mark.type === HairpinType.crescendoEnd || mark.type === HairpinType.diminuendoEnd) {
+                    result.hairpin = 'end';
+                }
+                break;
+            case 'pedal':
+                if (mark.type === PedalType.sustainOn) {
+                    result.pedal = 'down';
+                }
+                else if (mark.type === PedalType.sustainOff) {
+                    result.pedal = 'up';
+                }
+                break;
+            case 'tie':
+                if (mark.start) {
+                    result.tieStart = true;
+                }
+                break;
+            case 'slur':
+                if (mark.start) {
+                    result.slurStart = true;
+                }
+                else {
+                    result.slurEnd = true;
+                }
+                break;
+            case 'beam':
+                if (mark.start) {
+                    result.beamStart = true;
+                }
+                else {
+                    result.beamEnd = true;
+                }
+                break;
+            case 'fingering':
+                result.fingerings.push({
+                    finger: mark.finger,
+                    placement: mark.placement,
+                });
+                break;
+            case 'navigation':
+                result.navigation = mark.type;
+                break;
+            case 'markup':
+                result.markups.push({
+                    content: mark.content,
+                    placement: mark.placement,
+                });
+                break;
+        }
+        // Tremolo (special case - from parser internal mark)
+        if ('tremolo' in mark && typeof mark.tremolo === 'number') {
+            result.tremolo = mark.tremolo;
+        }
+    }
+    return result;
+};
+// Convert NoteEvent to MEI
+const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFifths = 0, ottavaShift = 0) => {
+    const dur = DURATIONS[event.duration.division] || "4";
+    const dots = event.duration.dots || 0;
+    const markOptions = extractMarkOptions(event.marks);
+    // Stem direction - use event's own or context's
+    const effectiveStemDir = event.stemDirection ?? contextStemDir;
+    let stemDir;
+    if (effectiveStemDir === StemDirection.up)
+        stemDir = 'up';
+    else if (effectiveStemDir === StemDirection.down)
+        stemDir = 'down';
+    // Determine tie attribute: 'i' = initial, 'm' = medial, 't' = terminal
+    let tie;
+    if (markOptions.tieStart && tieEnd) {
+        tie = 'm'; // Both start and end = medial
+    }
+    else if (markOptions.tieStart) {
+        tie = 'i'; // Start only = initial
+    }
+    else if (tieEnd) {
+        tie = 't'; // End only = terminal
+    }
+    // Note options - ornaments are now control events, not inline
+    const noteOptions = {
+        grace: event.grace,
+        tie,
+        stemDir,
+        staff: event.staff,
+        layerStaff,
+        artics: markOptions.artics,
+        tremolo: markOptions.tremolo,
+    };
+    // Single note
+    if (event.pitches.length === 1) {
+        const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift);
+        const noteId = generateId('note');
+        return {
+            xml: buildNoteElement(pitch, dur, dots, indent, false, noteOptions, noteId),
+            elementId: noteId,
+            hairpin: markOptions.hairpin,
+            pedal: markOptions.pedal,
+            hasTieStart: markOptions.tieStart,
+            pitches: event.pitches,
+            arpeggio: markOptions.arpeggio,
+            fermata: markOptions.fermata,
+            trill: markOptions.trill,
+            mordent: markOptions.mordent,
+            turn: markOptions.turn,
+            dynamic: markOptions.dynamic,
+            slurStart: markOptions.slurStart,
+            slurEnd: markOptions.slurEnd,
+            fingerings: markOptions.fingerings,
+            navigation: markOptions.navigation,
+            markups: markOptions.markups,
+        };
+    }
+    // Chord
+    const chordId = generateId('chord');
+    let chordAttrs = `xml:id="${chordId}" dur="${dur}"`;
+    if (dots > 0)
+        chordAttrs += ` dots="${dots}"`;
+    if (noteOptions.grace)
+        chordAttrs += ` grace="unacc"`;
+    if (noteOptions.tie)
+        chordAttrs += ` tie="${noteOptions.tie}"`;
+    if (noteOptions.stemDir)
+        chordAttrs += ` stem.dir="${noteOptions.stemDir}"`;
+    if (layerStaff && noteOptions.staff && noteOptions.staff !== layerStaff) {
+        chordAttrs += ` staff="${noteOptions.staff}"`;
+    }
+    let result = `${indent}<chord ${chordAttrs}>\n`;
+    for (const p of event.pitches) {
+        const pitch = encodePitch(p, keyFifths, ottavaShift);
+        result += buildNoteElement(pitch, dur, dots, indent + '    ', true);
+    }
+    // Artics for chord - group by placement
+    if (noteOptions.artics.length > 0) {
+        const aboveArtics = noteOptions.artics.filter(a => a.placement === 'above').map(a => a.type);
+        const belowArtics = noteOptions.artics.filter(a => a.placement === 'below').map(a => a.type);
+        const defaultArtics = noteOptions.artics.filter(a => !a.placement).map(a => a.type);
+        if (aboveArtics.length > 0) {
+            result += `${indent}    <artic artic="${aboveArtics.join(' ')}" place="above" />\n`;
+        }
+        if (belowArtics.length > 0) {
+            result += `${indent}    <artic artic="${belowArtics.join(' ')}" place="below" />\n`;
+        }
+        if (defaultArtics.length > 0) {
+            result += `${indent}    <artic artic="${defaultArtics.join(' ')}" />\n`;
+        }
+    }
+    result += `${indent}</chord>\n`;
+    return {
+        xml: result,
+        elementId: chordId,
+        hairpin: markOptions.hairpin,
+        pedal: markOptions.pedal,
+        hasTieStart: markOptions.tieStart,
+        pitches: event.pitches,
+        arpeggio: markOptions.arpeggio,
+        fermata: markOptions.fermata,
+        trill: markOptions.trill,
+        mordent: markOptions.mordent,
+        turn: markOptions.turn,
+        dynamic: markOptions.dynamic,
+        slurStart: markOptions.slurStart,
+        slurEnd: markOptions.slurEnd,
+        fingerings: markOptions.fingerings,
+        navigation: markOptions.navigation,
+        markups: markOptions.markups,
+    };
+};
+// Convert RestEvent to MEI
+const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
+    const dur = DURATIONS[event.duration.division] || "4";
+    let attrs = `xml:id="${generateId('rest')}" dur="${dur}"`;
+    if (event.duration.dots > 0)
+        attrs += ` dots="${event.duration.dots}"`;
+    // Pitched rest (positioned at specific pitch)
+    if (event.pitch) {
+        const pitch = encodePitch(event.pitch, keyFifths, ottavaShift);
+        attrs += ` ploc="${pitch.pname}" oloc="${pitch.oct}"`;
+    }
+    // Space rest (invisible)
+    if (event.invisible) {
+        return `${indent}<space ${attrs} />\n`;
+    }
+    // Full measure rest
+    if (event.fullMeasure) {
+        return `${indent}<mRest xml:id="${generateId('mrest')}" />\n`;
+    }
+    return `${indent}<rest ${attrs} />\n`;
+};
+// Convert TupletEvent to MEI
+const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff, ottavaShift = 0) => {
+    // LilyPond \times 2/3 means "multiply duration by 2/3"
+    // So 3 notes × 2/3 = 2 beats worth (3 in time of 2)
+    // MEI: num = number of notes written, numbase = normal equivalent
+    const num = event.ratio.denominator; // denominator = actual note count
+    const numbase = event.ratio.numerator; // numerator = time equivalent
+    let xml = `${indent}<tuplet xml:id="${generateId('tuplet')}" num="${num}" numbase="${numbase}">\n`;
+    let inBeam = false;
+    const baseIndent = indent + '    ';
+    // Effective staff for cross-staff notation
+    const effectiveStaff = currentStaff ?? layerStaff;
+    // Collect control event info from notes inside tuplet
+    const slurStarts = [];
+    const slurEnds = [];
+    const dynamics = [];
+    const fermatas = [];
+    const trills = [];
+    const mordents = [];
+    const turns = [];
+    const arpeggios = [];
+    for (const e of event.events) {
+        // Check for beam marks in note events
+        let beamStart = false;
+        let beamEnd = false;
+        if (e.type === 'note') {
+            const markOptions = extractMarkOptions(e.marks);
+            beamStart = markOptions.beamStart;
+            beamEnd = markOptions.beamEnd;
+        }
+        // Open beam element if beam starts
+        if (beamStart && !inBeam) {
+            xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
+            inBeam = true;
+        }
+        const currentIndent = inBeam ? baseIndent + '    ' : baseIndent;
+        if (e.type === 'note') {
+            // For cross-staff notation: set note's staff if different from layerStaff
+            const noteEvent = e;
+            const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
+                ? { ...noteEvent, staff: effectiveStaff }
+                : noteEvent;
+            const result = noteEventToMEI(effectiveNoteEvent, currentIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
+            xml += result.xml;
+            // 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.fermata)
+                fermatas.push({ startid: result.elementId, shape: result.fermata === 'short' ? 'angular' : undefined });
+            if (result.trill)
+                trills.push({ startid: result.elementId });
+            if (result.mordent)
+                mordents.push({ startid: result.elementId, form: result.mordent === 'upper' ? 'upper' : undefined });
+            if (result.turn)
+                turns.push({ startid: result.elementId });
+            if (result.arpeggio)
+                arpeggios.push({ plist: result.elementId });
+        }
+        else if (e.type === 'rest') {
+            xml += restEventToMEI(e, currentIndent, keyFifths, ottavaShift);
+        }
+        // Close beam element if beam ends
+        if (beamEnd && inBeam) {
+            xml += `${baseIndent}</beam>\n`;
+            inBeam = false;
+        }
+    }
+    // Close any unclosed beam
+    if (inBeam) {
+        xml += `${baseIndent}</beam>\n`;
+    }
+    xml += `${indent}</tuplet>\n`;
+    return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+};
+// Convert TremoloEvent to MEI (fingered tremolo - alternating between two notes)
+const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
+    const ftremId = generateId('fTrem');
+    // For \repeat tremolo 4 { c16 d16 }:
+    // - count = 4 (repetitions)
+    // - division = 16 (note value)
+    // - Total duration = 4 × 2 × 16th = 8 × 16th = half note
+    // - Each visible note = half of total = quarter note
+    // Calculate beams (tremolo strokes) based on division
+    // 8th = 1 beam, 16th = 2 beams, 32nd = 3 beams
+    const beams = Math.max(1, Math.log2(event.division / 8) + 1);
+    // Calculate visual duration for each note
+    // For \repeat tremolo 4 { c16 d16 }:
+    // - Total strokes = 4 × 2 = 8 sixteenth notes = 1/2 whole note
+    // - Each visible note = 1/4 whole note = quarter note (dur="4")
+    // Formula: dur = division / count (e.g., 16 / 4 = 4 for quarter note)
+    const noteDur = Math.round(event.division / event.count) || 4; // Default to quarter if calculation fails
+    let result = `${indent}<fTrem xml:id="${ftremId}" beams="${beams}">\n`;
+    // First note (or chord)
+    if (event.pitchA.length === 1) {
+        const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift);
+        let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
+        if (pitch.accid)
+            attrs += ` accid="${pitch.accid}"`;
+        result += `${indent}    <note ${attrs} />\n`;
+    }
+    else if (event.pitchA.length > 1) {
+        result += `${indent}    <chord xml:id="${generateId('chord')}" dur="${noteDur}">\n`;
+        for (const p of event.pitchA) {
+            const pitch = encodePitch(p, keyFifths, ottavaShift);
+            let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
+            if (pitch.accid)
+                attrs += ` accid="${pitch.accid}"`;
+            result += `${indent}        <note ${attrs} />\n`;
+        }
+        result += `${indent}    </chord>\n`;
+    }
+    // Second note (or chord)
+    if (event.pitchB.length === 1) {
+        const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift);
+        let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
+        if (pitch.accid)
+            attrs += ` accid="${pitch.accid}"`;
+        result += `${indent}    <note ${attrs} />\n`;
+    }
+    else if (event.pitchB.length > 1) {
+        result += `${indent}    <chord xml:id="${generateId('chord')}" dur="${noteDur}">\n`;
+        for (const p of event.pitchB) {
+            const pitch = encodePitch(p, keyFifths, ottavaShift);
+            let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
+            if (pitch.accid)
+                attrs += ` accid="${pitch.accid}"`;
+            result += `${indent}        <note ${attrs} />\n`;
+        }
+        result += `${indent}    </chord>\n`;
+    }
+    result += `${indent}</fTrem>\n`;
+    return result;
+};
+// Encode a layer (voice)
+const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths = 0, initialClef, initialSlur = null, initialHairpin = null) => {
+    const layerId = generateId("layer");
+    let xml = `${indent}<layer xml:id="${layerId}" n="${layerN}">\n`;
+    let inBeam = false;
+    const baseIndent = indent + '    ';
+    // Track current clef to only emit changes
+    let currentClef = initialClef;
+    // Track hairpin spans
+    const hairpins = [];
+    let currentHairpin = initialHairpin;
+    // Track pedal marks (each is independent, not paired spans)
+    const pedals = [];
+    // Track octave spans
+    const octaves = [];
+    let currentOctave = null;
+    let pendingOttava = null; // Track ottava to apply to next note
+    let currentOttavaShift = 0; // Track current ottava shift for pitch encoding
+    let lastNoteId = null; // Track last note id for ending ottava spans
+    // Track slur spans - slurs must be encoded as control events in MEI
+    const slurs = [];
+    let currentSlur = initialSlur ? { startId: initialSlur } : null;
+    // Track arpeggio refs
+    const arpeggios = [];
+    // Track ornament refs
+    const fermatas = [];
+    const trills = [];
+    const mordents = [];
+    const turns = [];
+    const dynamics = [];
+    const fingerings = [];
+    const navigations = [];
+    const harmonies = [];
+    const barlines = [];
+    const markups = [];
+    // Track current stem direction from context changes
+    let currentStemDirection = undefined;
+    // Track current staff for cross-staff notation
+    let currentStaff = voice.staff || 1;
+    // Track pending tie pitches (for tie="t" on next note) - initialized from previous measure
+    let pendingTiePitches = [...initialTiePitches];
+    // Helper to check if pitches match for tie continuation
+    const pitchesMatch = (p1, p2) => {
+        if (p1.length !== p2.length)
+            return false;
+        for (let i = 0; i < p1.length; i++) {
+            if (p1[i].phonet !== p2[i].phonet || p1[i].octave !== p2[i].octave)
+                return false;
+        }
+        return true;
+    };
+    for (const event of voice.events) {
+        // Check for beam start/end in note events
+        let beamStart = false;
+        let beamEnd = false;
+        if (event.type === 'note') {
+            const noteEvent = event;
+            const markOptions = extractMarkOptions(noteEvent.marks);
+            beamStart = markOptions.beamStart;
+            beamEnd = markOptions.beamEnd;
+        }
+        // Open beam element if beam starts
+        if (beamStart && !inBeam) {
+            xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
+            inBeam = true;
+        }
+        const currentIndent = inBeam ? baseIndent + '    ' : baseIndent;
+        switch (event.type) {
+            case 'note': {
+                const noteEvent = event;
+                // 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
+                }
+                // For cross-staff notation: set note's staff to currentStaff if different from voice.staff
+                const effectiveNoteEvent = currentStaff !== voice.staff
+                    ? { ...noteEvent, staff: currentStaff }
+                    : noteEvent;
+                const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift);
+                xml += result.xml;
+                lastNoteId = 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';
+                    currentOctave = { dis, disPlace, startId: result.elementId };
+                    pendingOttava = null;
+                }
+                // Update pending tie pitches
+                if (result.hasTieStart) {
+                    pendingTiePitches = result.pitches;
+                }
+                else if (tieEnd) {
+                    pendingTiePitches = [];
+                }
+                // Track hairpin spans
+                if (result.hairpin === 'crescStart') {
+                    currentHairpin = { form: 'cres', startId: result.elementId };
+                }
+                else if (result.hairpin === 'dimStart') {
+                    currentHairpin = { form: 'dim', startId: result.elementId };
+                }
+                else if (result.hairpin === 'end' && currentHairpin) {
+                    hairpins.push({
+                        form: currentHairpin.form,
+                        startId: currentHairpin.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 slur spans - end must be processed before start
+                // in case a note ends one slur and starts another
+                if (result.slurEnd && currentSlur) {
+                    slurs.push({
+                        startId: currentSlur.startId,
+                        endId: result.elementId,
+                    });
+                    currentSlur = null;
+                }
+                if (result.slurStart) {
+                    currentSlur = { startId: result.elementId };
+                }
+                // Track arpeggio refs
+                if (result.arpeggio) {
+                    arpeggios.push({ plist: result.elementId });
+                }
+                // Track ornament refs (fermata, trill, mordent, turn)
+                if (result.fermata) {
+                    fermatas.push({
+                        startid: result.elementId,
+                        shape: result.fermata === 'short' ? 'angular' : undefined,
+                    });
+                }
+                if (result.trill) {
+                    trills.push({ startid: result.elementId });
+                }
+                if (result.mordent) {
+                    mordents.push({
+                        startid: result.elementId,
+                        form: result.mordent === 'upper' ? 'upper' : undefined,
+                    });
+                }
+                if (result.turn) {
+                    turns.push({ startid: result.elementId });
+                }
+                if (result.dynamic) {
+                    dynamics.push({ startid: result.elementId, label: result.dynamic });
+                }
+                // Track fingerings
+                for (const fing of result.fingerings) {
+                    fingerings.push({ startid: result.elementId, finger: fing.finger, placement: fing.placement });
+                }
+                // Track markups from note marks
+                for (const mkup of result.markups) {
+                    markups.push({ startid: result.elementId, content: mkup.content, placement: mkup.placement });
+                }
+                // Track navigation marks
+                if (result.navigation) {
+                    navigations.push({ type: result.navigation });
+                }
+                break;
+            }
+            case 'rest':
+                xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift);
+                break;
+            case 'tuplet': {
+                const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift);
+                xml += tupletResult.xml;
+                // Process slur ends first (to close any pending slurs from before this tuplet)
+                for (const endId of tupletResult.slurEnds) {
+                    if (currentSlur) {
+                        slurs.push({
+                            startId: currentSlur.startId,
+                            endId: endId,
+                        });
+                        currentSlur = null;
+                    }
+                }
+                // Then process slur starts (to open new slurs)
+                for (const startId of tupletResult.slurStarts) {
+                    currentSlur = { startId };
+                }
+                // Collect other control events from tuplet
+                dynamics.push(...tupletResult.dynamics);
+                fermatas.push(...tupletResult.fermatas);
+                trills.push(...tupletResult.trills);
+                mordents.push(...tupletResult.mordents);
+                turns.push(...tupletResult.turns);
+                arpeggios.push(...tupletResult.arpeggios);
+                break;
+            }
+            case 'tremolo':
+                xml += tremoloEventToMEI(event, currentIndent, keyFifths, currentOttavaShift);
+                break;
+            case 'context': {
+                const ctx = event;
+                // Check for clef changes - emit <clef> element only if different from current
+                if (ctx.clef && ctx.clef !== currentClef) {
+                    const clefInfo = CLEF_SHAPES[ctx.clef] || CLEF_SHAPES.treble;
+                    xml += `${currentIndent}<clef xml:id="${generateId('clef')}" shape="${clefInfo.shape}" line="${clefInfo.line}" />\n`;
+                    currentClef = ctx.clef;
+                }
+                // Check for ottava changes
+                if (ctx.ottava !== undefined) {
+                    if (ctx.ottava === 0) {
+                        // End current ottava span
+                        if (currentOctave && lastNoteId) {
+                            octaves.push({
+                                dis: currentOctave.dis,
+                                disPlace: currentOctave.disPlace,
+                                startId: currentOctave.startId,
+                                endId: lastNoteId,
+                            });
+                            currentOctave = null;
+                        }
+                        currentOttavaShift = 0; // Reset the shift
+                    }
+                    else {
+                        // Start new ottava span - will be applied to next note
+                        pendingOttava = ctx.ottava;
+                    }
+                }
+                // Check for stem direction changes
+                if (ctx.stemDirection !== undefined) {
+                    currentStemDirection = ctx.stemDirection;
+                }
+                // Check for staff changes (cross-staff notation)
+                if (ctx.staff !== undefined) {
+                    currentStaff = ctx.staff;
+                }
+                // Other context changes are handled at measure level
+                break;
+            }
+            case 'pitchReset':
+                // Pitch reset events are only used during pitch resolution in the parser.
+                // They don't produce any MEI output - just skip them.
+                break;
+            case 'barline':
+                barlines.push({ style: event.style });
+                break;
+            case 'harmony':
+                // Harmony needs a note ID to attach to - use the last note if available
+                if (lastNoteId) {
+                    harmonies.push({ startid: lastNoteId, text: event.text });
+                }
+                break;
+            case 'markup':
+                // Markup needs a note ID to attach to - use the last note if available
+                if (lastNoteId) {
+                    const mkupEvent = event;
+                    markups.push({
+                        startid: lastNoteId,
+                        content: mkupEvent.content,
+                        placement: mkupEvent.placement,
+                    });
+                }
+                break;
+        }
+        // Close beam element if beam ends
+        if (beamEnd && inBeam) {
+            xml += `${baseIndent}</beam>\n`;
+            inBeam = false;
+        }
+    }
+    // Close any unclosed beam
+    if (inBeam) {
+        xml += `${baseIndent}</beam>\n`;
+    }
+    // Close any unclosed ottava span at end of layer
+    if (currentOctave && lastNoteId) {
+        octaves.push({
+            dis: currentOctave.dis,
+            disPlace: currentOctave.disPlace,
+            startId: currentOctave.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, endingClef: currentClef };
+};
+// Encode a staff
+const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, keyFifths = 0, initialClef) => {
+    const staffId = generateId("staff");
+    let xml = `${indent}<staff xml:id="${staffId}" n="${staffN}">\n`;
+    const allHairpins = [];
+    const allPedals = [];
+    const allOctaves = [];
+    const allSlurs = [];
+    const allArpeggios = [];
+    const allFermatas = [];
+    const allTrills = [];
+    const allMordents = [];
+    const allTurns = [];
+    const allDynamics = [];
+    const allFingerings = [];
+    const allNavigations = [];
+    const allHarmonies = [];
+    const allBarlines = [];
+    const allMarkups = [];
+    const pendingTies = {};
+    const pendingSlurs = {};
+    const pendingHairpins = {};
+    let endingClef = initialClef;
+    if (voices.length === 0) {
+        xml += `${indent}    <layer xml:id="${generateId('layer')}" n="1" />\n`;
+    }
+    else {
+        voices.forEach((voice, vi) => {
+            const layerN = vi + 1;
+            const tieKey = `${staffN}-${layerN}`;
+            const initialTies = tieState[tieKey] || [];
+            const initialSlur = slurState[tieKey] || null;
+            const initialHairpin = hairpinState[tieKey] || null;
+            const result = encodeLayer(voice, layerN, indent + '    ', initialTies, keyFifths, endingClef, initialSlur, initialHairpin);
+            xml += result.xml;
+            allHairpins.push(...result.hairpins);
+            allPedals.push(...result.pedals);
+            allOctaves.push(...result.octaves);
+            allSlurs.push(...result.slurs);
+            allArpeggios.push(...result.arpeggios);
+            allFermatas.push(...result.fermatas);
+            allTrills.push(...result.trills);
+            allMordents.push(...result.mordents);
+            allTurns.push(...result.turns);
+            allDynamics.push(...result.dynamics);
+            allFingerings.push(...result.fingerings);
+            allNavigations.push(...result.navigations);
+            allHarmonies.push(...result.harmonies);
+            allBarlines.push(...result.barlines);
+            allMarkups.push(...result.markups);
+            // Track pending ties for this layer
+            if (result.pendingTiePitches.length > 0) {
+                pendingTies[tieKey] = result.pendingTiePitches;
+            }
+            // Track pending slurs for this layer
+            if (result.pendingSlur) {
+                pendingSlurs[tieKey] = result.pendingSlur;
+            }
+            // Track pending hairpins for this layer
+            if (result.pendingHairpin) {
+                pendingHairpins[tieKey] = result.pendingHairpin;
+            }
+            // Track ending clef for cross-measure tracking
+            if (result.endingClef) {
+                endingClef = result.endingClef;
+            }
+        });
+    }
+    xml += `${indent}</staff>\n`;
+    return {
+        xml,
+        hairpins: allHairpins,
+        pedals: allPedals,
+        octaves: allOctaves,
+        slurs: allSlurs,
+        arpeggios: allArpeggios,
+        fermatas: allFermatas,
+        trills: allTrills,
+        mordents: allMordents,
+        turns: allTurns,
+        dynamics: allDynamics,
+        fingerings: allFingerings,
+        navigations: allNavigations,
+        harmonies: allHarmonies,
+        barlines: allBarlines,
+        markups: allMarkups,
+        pendingTies,
+        pendingSlurs,
+        pendingHairpins,
+        endingClef,
+    };
+};
+// Generate tempo element
+const generateTempoElement = (tempo, indent, staff = 1) => {
+    let attrs = `xml:id="${generateId('tempo')}" tstamp="1" staff="${staff}"`;
+    // Add BPM if specified
+    if (tempo.bpm) {
+        attrs += ` midi.bpm="${tempo.bpm}"`;
+        if (tempo.beat) {
+            attrs += ` mm="${tempo.bpm}" mm.unit="${tempo.beat.division}"`;
+        }
+    }
+    // Generate content
+    let content = '';
+    if (tempo.text) {
+        content = escapeXml(tempo.text);
+    }
+    if (tempo.beat && tempo.bpm) {
+        const beatSymbol = tempo.beat.division === 4 ? '♩' : tempo.beat.division === 2 ? '𝅗𝅥' : '♪';
+        if (content)
+            content += ' ';
+        content += `${beatSymbol} = ${tempo.bpm}`;
+    }
+    if (content) {
+        return `${indent}<tempo ${attrs}>${content}</tempo>\n`;
+    }
+    return `${indent}<tempo ${attrs} />\n`;
+};
+// Barline style to MEI @right attribute mapping
+const BARLINE_TO_MEI = {
+    '|': 'single',
+    '||': 'dbl',
+    '|.': 'end',
+    '.|:': 'rptstart',
+    ':|.': 'rptend',
+    ':..:|': 'rptboth',
+    ':..:': 'rptboth',
+};
+// Encode a measure
+// encodeMeasure accepts mutable tieState, slurState, hairpinState and clefState that persist across measures
+const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, keyFifths = 0, partInfos = [], clefState = {}) => {
+    const measureId = generateId("measure");
+    let staffContent = ''; // Build staff content first, then add measure tag with barline
+    const allHairpins = [];
+    const allPedals = [];
+    const allOctaves = [];
+    const allSlurs = [];
+    const allArpeggios = [];
+    const allFermatas = [];
+    const allTrills = [];
+    const allMordents = [];
+    const allTurns = [];
+    const allDynamics = [];
+    const allFingerings = [];
+    const allNavigations = [];
+    const allHarmonies = [];
+    const allBarlines = [];
+    const allMarkups = [];
+    // Extract tempo from context changes (track which staff it came from)
+    let measureTempo;
+    let tempoStaff = 1;
+    for (let pi = 0; pi < measure.parts.length; pi++) {
+        const part = measure.parts[pi];
+        const partOffset = partInfos[pi]?.staffOffset || 0;
+        for (const voice of part.voices) {
+            const localStaff = voice.staff || 1;
+            const globalStaff = partOffset + localStaff;
+            for (const event of voice.events) {
+                if (event.type === 'context') {
+                    const ctx = event;
+                    if (ctx.tempo) {
+                        measureTempo = ctx.tempo;
+                        tempoStaff = globalStaff;
+                    }
+                }
+            }
+        }
+    }
+    // Group voices by global staff (local staff + part offset)
+    const voicesByStaff = {};
+    for (let pi = 0; pi < measure.parts.length; pi++) {
+        const part = measure.parts[pi];
+        const partOffset = partInfos[pi]?.staffOffset || 0;
+        for (const voice of part.voices) {
+            const localStaff = voice.staff || 1;
+            const globalStaff = partOffset + localStaff;
+            if (!voicesByStaff[globalStaff]) {
+                voicesByStaff[globalStaff] = [];
+            }
+            voicesByStaff[globalStaff].push(voice);
+        }
+    }
+    // Encode each staff, passing and updating tie state, slur state, hairpin state and clef state
+    for (let si = 1; si <= totalStaves; si++) {
+        const voices = voicesByStaff[si] || [];
+        const initialClef = clefState[si];
+        const result = encodeStaff(voices, si, indent + '    ', tieState, slurState, hairpinState, keyFifths, initialClef);
+        staffContent += result.xml;
+        allHairpins.push(...result.hairpins);
+        allPedals.push(...result.pedals);
+        allOctaves.push(...result.octaves);
+        allSlurs.push(...result.slurs);
+        allArpeggios.push(...result.arpeggios);
+        allFermatas.push(...result.fermatas);
+        allTrills.push(...result.trills);
+        allMordents.push(...result.mordents);
+        allTurns.push(...result.turns);
+        allDynamics.push(...result.dynamics);
+        allFingerings.push(...result.fingerings);
+        allNavigations.push(...result.navigations);
+        allHarmonies.push(...result.harmonies);
+        allBarlines.push(...result.barlines);
+        allMarkups.push(...result.markups);
+        // Update tie state with pending ties from this staff
+        Object.assign(tieState, result.pendingTies);
+        // Update slur state with pending slurs from this staff
+        Object.assign(slurState, result.pendingSlurs);
+        // Update hairpin state with pending hairpins from this staff
+        Object.assign(hairpinState, result.pendingHairpins);
+        // Update clef state with ending clef from this staff
+        if (result.endingClef) {
+            clefState[si] = result.endingClef;
+        }
+    }
+    // Generate tempo element if present
+    if (measureTempo) {
+        staffContent += generateTempoElement(measureTempo, indent + '    ', tempoStaff);
+    }
+    // Generate hairpin control events
+    for (const hp of allHairpins) {
+        staffContent += `${indent}    <hairpin xml:id="${generateId('hairpin')}" form="${hp.form}" startid="#${hp.startId}" endid="#${hp.endId}" />\n`;
+    }
+    // Generate pedal control events (each mark is independent)
+    for (const ped of allPedals) {
+        staffContent += `${indent}    <pedal xml:id="${generateId('pedal')}" dir="${ped.dir}" startid="#${ped.startId}" />\n`;
+    }
+    // Generate octave control events
+    for (const oct of allOctaves) {
+        staffContent += `${indent}    <octave xml:id="${generateId('octave')}" dis="${oct.dis}" dis.place="${oct.disPlace}" startid="#${oct.startId}" endid="#${oct.endId}" />\n`;
+    }
+    // Generate slur control events
+    for (const sl of allSlurs) {
+        staffContent += `${indent}    <slur xml:id="${generateId('slur')}" startid="#${sl.startId}" endid="#${sl.endId}" />\n`;
+    }
+    // Generate arpeggio control events
+    for (const arp of allArpeggios) {
+        staffContent += `${indent}    <arpeg xml:id="${generateId('arpeg')}" plist="#${arp.plist}" />\n`;
+    }
+    // Generate fermata control events
+    for (const ferm of allFermatas) {
+        const shapeAttr = ferm.shape ? ` shape="${ferm.shape}"` : '';
+        staffContent += `${indent}    <fermata xml:id="${generateId('fermata')}" startid="#${ferm.startid}"${shapeAttr} />\n`;
+    }
+    // Generate trill control events
+    for (const tr of allTrills) {
+        staffContent += `${indent}    <trill xml:id="${generateId('trill')}" startid="#${tr.startid}" />\n`;
+    }
+    // Generate mordent control events
+    for (const mord of allMordents) {
+        const formAttr = mord.form ? ` form="${mord.form}"` : '';
+        staffContent += `${indent}    <mordent xml:id="${generateId('mordent')}" startid="#${mord.startid}"${formAttr} />\n`;
+    }
+    // Generate turn control events
+    for (const tu of allTurns) {
+        staffContent += `${indent}    <turn xml:id="${generateId('turn')}" startid="#${tu.startid}" />\n`;
+    }
+    // Generate dynamic control events
+    for (const dyn of allDynamics) {
+        staffContent += `${indent}    <dynam xml:id="${generateId('dynam')}" startid="#${dyn.startid}">${dyn.label}</dynam>\n`;
+    }
+    // Generate fingering control events
+    for (const fing of allFingerings) {
+        const placeAttr = fing.placement ? ` place="${fing.placement}"` : '';
+        staffContent += `${indent}    <fing xml:id="${generateId('fing')}" startid="#${fing.startid}"${placeAttr}>${fing.finger}</fing>\n`;
+    }
+    // Generate dir elements for navigation marks (coda, segno)
+    for (const nav of allNavigations) {
+        // Use <dir> element with appropriate glyph
+        const glyph = nav.type === 'coda' ? '𝄌' : '𝄋'; // Unicode coda/segno symbols
+        staffContent += `${indent}    <dir xml:id="${generateId('dir')}" tstamp="1">${glyph}</dir>\n`;
+    }
+    // Generate harm elements for chord symbols
+    for (const harm of allHarmonies) {
+        staffContent += `${indent}    <harm xml:id="${generateId('harm')}" startid="#${harm.startid}">${escapeXml(harm.text)}</harm>\n`;
+    }
+    // Generate dir elements for markups
+    for (const mkup of allMarkups) {
+        const placeAttr = mkup.placement ? ` place="${mkup.placement}"` : '';
+        staffContent += `${indent}    <dir xml:id="${generateId('dir')}" startid="#${mkup.startid}"${placeAttr}>${escapeXml(mkup.content)}</dir>\n`;
+    }
+    // Determine barline attribute from collected barlines
+    let barlineAttr = '';
+    if (allBarlines.length > 0) {
+        const lastBarline = allBarlines[allBarlines.length - 1];
+        const meiBarline = BARLINE_TO_MEI[lastBarline.style];
+        if (meiBarline && meiBarline !== 'single') {
+            barlineAttr = ` right="${meiBarline}"`;
+        }
+    }
+    // Build final XML with measure tag including barline
+    let xml = `${indent}<measure xml:id="${measureId}" n="${measureN}"${barlineAttr}>\n`;
+    xml += staffContent;
+    xml += `${indent}</measure>\n`;
+    return xml;
+};
+// Analyze document to get part structure
+const analyzePartStructure = (doc) => {
+    // Find maximum number of parts in any measure
+    let maxParts = 0;
+    for (const measure of doc.measures) {
+        maxParts = Math.max(maxParts, measure.parts.length);
+    }
+    // Initialize part info
+    const partInfos = [];
+    for (let i = 0; i < maxParts; i++) {
+        partInfos.push({ maxStaff: 1, staffOffset: 0, clefs: {} });
+    }
+    // Analyze each measure to find max staff per part and clefs
+    for (const measure of doc.measures) {
+        for (let pi = 0; pi < measure.parts.length; pi++) {
+            const part = measure.parts[pi];
+            for (const voice of part.voices) {
+                const localStaff = voice.staff || 1;
+                partInfos[pi].maxStaff = Math.max(partInfos[pi].maxStaff, localStaff);
+                // Get FIRST clef from context changes (for initial staffDef)
+                for (const event of voice.events) {
+                    if (event.type === 'context') {
+                        const ctx = event;
+                        if (ctx.clef && !partInfos[pi].clefs[localStaff]) {
+                            // Only set if not already set - take the FIRST clef
+                            partInfos[pi].clefs[localStaff] = ctx.clef;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Calculate staff offsets
+    let offset = 0;
+    for (const info of partInfos) {
+        info.staffOffset = offset;
+        offset += info.maxStaff;
+    }
+    return partInfos;
+};
+// Encode scoreDef with part groups
+const encodeScoreDef = (keySig, timeNum, timeDen, partInfos, indent) => {
+    const scoreDefId = generateId("scoredef");
+    let xml = `${indent}<scoreDef xml:id="${scoreDefId}" key.sig="${keySig}" meter.count="${timeNum}" meter.unit="${timeDen}">\n`;
+    xml += `${indent}    <staffGrp xml:id="${generateId("staffgrp")}">\n`;
+    for (let pi = 0; pi < partInfos.length; pi++) {
+        const info = partInfos[pi];
+        // If part has multiple staves (grand staff), wrap in staffGrp with brace
+        if (info.maxStaff > 1) {
+            xml += `${indent}        <staffGrp xml:id="${generateId("staffgrp")}" symbol="brace" bar.thru="true">\n`;
+            for (let ls = 1; ls <= info.maxStaff; ls++) {
+                const globalStaff = info.staffOffset + ls;
+                const clef = info.clefs[ls] || Clef.treble;
+                const clefInfo = CLEF_SHAPES[clef] || CLEF_SHAPES.treble;
+                xml += `${indent}            <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" clef.shape="${clefInfo.shape}" clef.line="${clefInfo.line}" />\n`;
+            }
+            xml += `${indent}        </staffGrp>\n`;
+        }
+        else {
+            // Single staff part
+            const globalStaff = info.staffOffset + 1;
+            const clef = info.clefs[1] || Clef.treble;
+            const clefInfo = CLEF_SHAPES[clef] || CLEF_SHAPES.treble;
+            xml += `${indent}        <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" clef.shape="${clefInfo.shape}" clef.line="${clefInfo.line}" />\n`;
+        }
+    }
+    xml += `${indent}    </staffGrp>\n`;
+    xml += `${indent}</scoreDef>\n`;
+    return xml;
+};
+// Main encode function
+const encode = (doc, options = {}) => {
+    const indent = options.indent || "    ";
+    resetIdCounter();
+    if (!doc.measures || doc.measures.length === 0) {
+        return "";
+    }
+    // Analyze part structure to get staff offsets
+    const partInfos = analyzePartStructure(doc);
+    // Calculate total staff count
+    const totalStaves = partInfos.reduce((sum, info) => sum + info.maxStaff, 0);
+    // Collect initial key/time from first measure
+    let currentKey = 0;
+    let currentTimeNum = 4;
+    let currentTimeDen = 4;
+    const firstMeasure = doc.measures[0];
+    if (firstMeasure.key) {
+        currentKey = keyToFifths(firstMeasure.key);
+    }
+    if (firstMeasure.timeSig) {
+        currentTimeNum = firstMeasure.timeSig.numerator;
+        currentTimeDen = firstMeasure.timeSig.denominator;
+    }
+    const keySig = KEY_SIGS[currentKey] || "0";
+    // Build MEI document
+    const xmlDecl = options.xmlDeclaration !== false
+        ? '<?xml version="1.0" encoding="UTF-8"?>\n'
+        : "";
+    let mei = xmlDecl;
+    mei += '<mei xmlns="http://www.music-encoding.org/ns/mei" meiversion="5.0">\n';
+    mei += `${indent}<meiHead>\n`;
+    mei += `${indent}${indent}<fileDesc>\n`;
+    mei += `${indent}${indent}${indent}<titleStmt>\n`;
+    // Add title from metadata if available
+    if (doc.metadata?.title) {
+        mei += `${indent}${indent}${indent}${indent}<title>${escapeXml(doc.metadata.title)}</title>\n`;
+    }
+    // Add subtitle as second title (verovio reads subsequent titles as subtitle)
+    if (doc.metadata?.subtitle) {
+        mei += `${indent}${indent}${indent}${indent}<title>${escapeXml(doc.metadata.subtitle)}</title>\n`;
+    }
+    // Add composer (right-aligned in verovio)
+    if (doc.metadata?.composer) {
+        mei += `${indent}${indent}${indent}${indent}<composer>${escapeXml(doc.metadata.composer)}</composer>\n`;
+    }
+    // Add arranger (right-aligned in verovio)
+    if (doc.metadata?.arranger) {
+        mei += `${indent}${indent}${indent}${indent}<arranger>${escapeXml(doc.metadata.arranger)}</arranger>\n`;
+    }
+    // Add lyricist (left-aligned in verovio)
+    if (doc.metadata?.lyricist) {
+        mei += `${indent}${indent}${indent}${indent}<lyricist>${escapeXml(doc.metadata.lyricist)}</lyricist>\n`;
+    }
+    mei += `${indent}${indent}${indent}</titleStmt>\n`;
+    mei += `${indent}${indent}${indent}<pubStmt />\n`;
+    mei += `${indent}${indent}</fileDesc>\n`;
+    mei += `${indent}${indent}<encodingDesc>\n`;
+    mei += `${indent}${indent}${indent}<projectDesc>\n`;
+    mei += `${indent}${indent}${indent}${indent}<p>Encoded with Lilylet MEIEncoder</p>\n`;
+    mei += `${indent}${indent}${indent}</projectDesc>\n`;
+    mei += `${indent}${indent}</encodingDesc>\n`;
+    mei += `${indent}</meiHead>\n`;
+    mei += `${indent}<music>\n`;
+    mei += `${indent}${indent}<body>\n`;
+    mei += `${indent}${indent}${indent}<mdiv xml:id="${generateId("mdiv")}">\n`;
+    mei += `${indent}${indent}${indent}${indent}<score xml:id="${generateId("score")}">\n`;
+    mei += encodeScoreDef(keySig, currentTimeNum, currentTimeDen, partInfos, `${indent}${indent}${indent}${indent}${indent}`);
+    mei += `${indent}${indent}${indent}${indent}${indent}<section xml:id="${generateId("section")}">\n`;
+    // Track tie state across measures for cross-measure ties
+    const tieState = {};
+    // Track slur state across measures for cross-measure slurs
+    const slurState = {};
+    // Track hairpin state across measures for cross-measure hairpins
+    const hairpinState = {};
+    // Initialize clef state from partInfos (convert local staff to global staff)
+    const clefState = {};
+    for (let pi = 0; pi < partInfos.length; pi++) {
+        const partInfo = partInfos[pi];
+        for (const [localStaffStr, clef] of Object.entries(partInfo.clefs)) {
+            const globalStaff = partInfo.staffOffset + parseInt(localStaffStr);
+            clefState[globalStaff] = clef;
+        }
+    }
+    // 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 === '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) => {
+        // Update key signature if measure has one
+        if (measure.key) {
+            currentKey = keyToFifths(measure.key);
+        }
+        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, currentKey, partInfos, clefState);
+    });
+    mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
+    mei += `${indent}${indent}${indent}${indent}</score>\n`;
+    mei += `${indent}${indent}${indent}</mdiv>\n`;
+    mei += `${indent}${indent}</body>\n`;
+    mei += `${indent}</music>\n`;
+    mei += '</mei>\n';
+    return mei;
+};
+// Escape XML special characters
+const escapeXml = (text) => {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+};
+export { encode, resetIdCounter, };