@k-l-lambda/lilylet 0.1.52 → 0.1.53

package/lib/lilylet/meiEncoder.js

@@ -119,10 +119,12 @@ const getKeyAccidentals = (fifths) => {
     }
     return result;
 };
-// Convert Pitch to MEI attributes, checking against key signature
+// Convert Pitch to MEI attributes, checking against key signature and in-measure accidentals
 // 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) => {
+// measureAccidentals: tracks accidentals used earlier in the same measure (keyed by "pname-oct")
+//   - mutated to record new accidentals; used to add cancellation naturals
+const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
     // 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
@@ -133,19 +135,44 @@ const encodePitch = (pitch, keyFifths = 0, ottavaShift = 0) => {
     // Determine accid (written/displayed) and accid.ges (gestural/sounding)
     let accid;
     let accidGes;
+    const pitchKey = `${pitch.phonet}-${oct}`;
+    // Check what was previously established for this pitch in this measure
+    const prevMeasureAccid = measureAccidentals?.get(pitchKey);
     if (pitch.accidental) {
         const noteAccid = ACCIDENTALS[pitch.accidental];
-        if (noteAccid !== keyAccid) {
+        if (prevMeasureAccid !== undefined && noteAccid !== prevMeasureAccid) {
+            // Previous note in this measure had a different accidental - must re-assert
+            accid = noteAccid;
+        }
+        else if (noteAccid !== keyAccid) {
             // Accidental differs from key signature - display it
             accid = noteAccid;
         }
         // Always set gestural accidental for MIDI generation
         accidGes = noteAccid;
+        // Record this accidental for in-measure tracking
+        if (measureAccidentals)
+            measureAccidentals.set(pitchKey, noteAccid);
     }
     else if (keyAccid) {
         // Note has no accidental but key implies one - output natural
-        accid = 'n';
+        if (prevMeasureAccid === 'n') {
+            // Already cancelled earlier in this measure - no need to show again
+        }
+        else {
+            accid = 'n';
+        }
         accidGes = 'n';
+        if (measureAccidentals)
+            measureAccidentals.set(pitchKey, 'n');
+    }
+    else if (measureAccidentals) {
+        // No explicit accidental, no key accidental - check if earlier note in measure had one
+        if (prevMeasureAccid && prevMeasureAccid !== 'n') {
+            // Previous note had an accidental - add cancellation natural
+            accid = 'n';
+            measureAccidentals.set(pitchKey, 'n');
+        }
     }
     return { pname: pitch.phonet, oct, accid, accidGes };
 };
@@ -339,7 +366,7 @@ const extractMarkOptions = (marks) => {
     return result;
 };
 // Convert NoteEvent to MEI
-const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFifths = 0, ottavaShift = 0) => {
+const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
     const dur = DURATIONS[event.duration.division] || "4";
     const dots = event.duration.dots || 0;
     const markOptions = extractMarkOptions(event.marks);
@@ -373,7 +400,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
     };
     // Single note
     if (event.pitches.length === 1) {
-        const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift);
+        const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift, measureAccidentals);
         const noteId = generateId('note');
         return {
             xml: buildNoteElement(pitch, dur, dots, indent, false, noteOptions, noteId),
@@ -416,7 +443,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
     }
     let result = `${indent}<chord ${chordAttrs}>\n`;
     for (const p of event.pitches) {
-        const pitch = encodePitch(p, keyFifths, ottavaShift);
+        const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
         result += buildNoteElement(pitch, dur, dots, indent + '    ', true);
     }
     // Artics for chord - group by placement
@@ -456,7 +483,7 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
     };
 };
 // Convert RestEvent to MEI
-const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
+const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
     const dur = DURATIONS[event.duration.division] || "4";
     let attrs = `xml:id="${generateId('rest')}" dur="${dur}"`;
     if (event.duration.dots > 0)
@@ -493,7 +520,7 @@ const tupletHasInternalBeams = (event) => {
     return starts > 0 && starts === ends;
 };
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff, ottavaShift = 0, inParentBeam = false) => {
+const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff, ottavaShift = 0, inParentBeam = false, measureAccidentals) => {
     // 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
@@ -504,6 +531,7 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
     // Effective staff for cross-staff notation
     const effectiveStaff = currentStaff ?? layerStaff;
     // Collect control event info from notes inside tuplet
+    let firstNoteId = null;
     const slurStarts = [];
     const slurEnds = [];
     const dynamics = [];
@@ -529,8 +557,10 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
             const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
                 ? { ...noteEvent, staff: effectiveStaff }
                 : noteEvent;
-            const result = noteEventToMEI(effectiveNoteEvent, noteIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
+            const result = noteEventToMEI(effectiveNoteEvent, noteIndent, layerStaff, false, undefined, keyFifths, ottavaShift, measureAccidentals);
             xml += result.xml;
+            if (!firstNoteId)
+                firstNoteId = result.elementId;
             // Collect slur info
             if (result.slurStart)
                 slurStarts.push(result.elementId);
@@ -557,7 +587,7 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
         }
         else if (e.type === 'rest') {
             const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-            xml += restEventToMEI(e, restIndent, keyFifths, ottavaShift);
+            xml += restEventToMEI(e, restIndent, keyFifths, ottavaShift, measureAccidentals);
         }
     }
     // Close any unclosed beam
@@ -565,10 +595,10 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
         xml += `${baseIndent}</beam>\n`;
     }
     xml += `${indent}</tuplet>\n`;
-    return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+    return { xml, firstNoteId, 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 tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0, measureAccidentals) => {
     const ftremId = generateId('fTrem');
     // For \repeat tremolo 4 { c16 d16 }:
     // - count = 4 (repetitions)
@@ -587,7 +617,7 @@ const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
     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);
+        const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift, measureAccidentals);
         let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
         if (pitch.accid)
             attrs += ` accid="${pitch.accid}"`;
@@ -598,7 +628,7 @@ const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
     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);
+            const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
             let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
             if (pitch.accid)
                 attrs += ` accid="${pitch.accid}"`;
@@ -610,7 +640,7 @@ const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
     }
     // Second note (or chord)
     if (event.pitchB.length === 1) {
-        const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift);
+        const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift, measureAccidentals);
         let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
         if (pitch.accid)
             attrs += ` accid="${pitch.accid}"`;
@@ -621,7 +651,7 @@ const tremoloEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
     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);
+            const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
             let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
             if (pitch.accid)
                 attrs += ` accid="${pitch.accid}"`;
@@ -698,12 +728,22 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     const harmonies = [];
     const barlines = [];
     const markups = [];
+    const pendingMarkups = [];
     // Track current stem direction from context changes
     let currentStemDirection = undefined;
     // Track current staff for cross-staff notation
     let currentStaff = voice.staff || 1;
+    // Track in-measure accidentals for cancellation naturals
+    const measureAccidentals = new Map();
     // Track pending tie pitches (for tie="t" on next note) - initialized from previous measure
     let pendingTiePitches = [...initialTiePitches];
+    // Helper to flush pending markups onto a note ID
+    const flushPendingMarkups = (noteId) => {
+        for (const mkup of pendingMarkups) {
+            markups.push({ startid: noteId, content: mkup.content, placement: mkup.placement });
+        }
+        pendingMarkups.length = 0;
+    };
     // Helper to check if pitches match for tie continuation
     const pitchesMatch = (p1, p2) => {
         if (p1.length !== p2.length)
@@ -736,9 +776,11 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 const effectiveNoteEvent = currentStaff !== voice.staff
                     ? { ...noteEvent, staff: currentStaff }
                     : noteEvent;
-                const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift);
+                const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
                 xml += result.xml;
                 lastNoteId = result.elementId;
+                // Flush any pending markups onto this note
+                flushPendingMarkups(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;
@@ -838,13 +880,18 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 break;
             }
             case 'rest':
-                xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift);
+                xml += restEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
                 break;
             case 'tuplet': {
                 // 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
-                const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen);
+                const tupletResult = tupletEventToMEI(event, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
                 xml += tupletResult.xml;
+                // Flush any pending markups onto the first note of the tuplet
+                if (tupletResult.firstNoteId) {
+                    flushPendingMarkups(tupletResult.firstNoteId);
+                    lastNoteId = tupletResult.firstNoteId;
+                }
                 // Process slur ends first (to close any pending slurs from before this tuplet)
                 for (const endId of tupletResult.slurEnds) {
                     if (currentSlur) {
@@ -869,7 +916,7 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 break;
             }
             case 'tremolo':
-                xml += tremoloEventToMEI(event, currentIndent, keyFifths, currentOttavaShift);
+                xml += tremoloEventToMEI(event, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
                 break;
             case 'context': {
                 const ctx = event;
@@ -937,14 +984,20 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 }
                 break;
             case 'markup':
-                // Markup needs a note ID to attach to - use the last note if available
-                if (lastNoteId) {
+                {
+                    // Markup needs a note ID to attach to
                     const mkupEvent = event;
-                    markups.push({
-                        startid: lastNoteId,
-                        content: mkupEvent.content,
-                        placement: mkupEvent.placement,
-                    });
+                    if (lastNoteId) {
+                        markups.push({
+                            startid: lastNoteId,
+                            content: mkupEvent.content,
+                            placement: mkupEvent.placement,
+                        });
+                    }
+                    else {
+                        // No note yet - save as pending, will attach to next note
+                        pendingMarkups.push({ content: mkupEvent.content, placement: mkupEvent.placement });
+                    }
                 }
                 break;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",

package/source/lilylet/meiEncoder.ts

@@ -172,10 +172,12 @@ const getKeyAccidentals = (fifths: number): Record<string, string> => {
 	return result;
 };
 
-// Convert Pitch to MEI attributes, checking against key signature
+// Convert Pitch to MEI attributes, checking against key signature and in-measure accidentals
 // 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: Pitch, keyFifths: number = 0, ottavaShift: number = 0): { pname: string; oct: number; accid?: string; accidGes?: string } => {
+// measureAccidentals: tracks accidentals used earlier in the same measure (keyed by "pname-oct")
+//   - mutated to record new accidentals; used to add cancellation naturals
+const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): { pname: string; oct: number; accid?: string; accidGes?: string } => {
 	// 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
@@ -189,18 +191,40 @@ const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number =
 	let accid: string | undefined;
 	let accidGes: string | undefined;
 
+	const pitchKey = `${pitch.phonet}-${oct}`;
+
+	// Check what was previously established for this pitch in this measure
+	const prevMeasureAccid = measureAccidentals?.get(pitchKey);
+
 	if (pitch.accidental) {
 		const noteAccid = ACCIDENTALS[pitch.accidental];
-		if (noteAccid !== keyAccid) {
+		if (prevMeasureAccid !== undefined && noteAccid !== prevMeasureAccid) {
+			// Previous note in this measure had a different accidental - must re-assert
+			accid = noteAccid;
+		} else if (noteAccid !== keyAccid) {
 			// Accidental differs from key signature - display it
 			accid = noteAccid;
 		}
 		// Always set gestural accidental for MIDI generation
 		accidGes = noteAccid;
+		// Record this accidental for in-measure tracking
+		if (measureAccidentals) measureAccidentals.set(pitchKey, noteAccid);
 	} else if (keyAccid) {
 		// Note has no accidental but key implies one - output natural
-		accid = 'n';
+		if (prevMeasureAccid === 'n') {
+			// Already cancelled earlier in this measure - no need to show again
+		} else {
+			accid = 'n';
+		}
 		accidGes = 'n';
+		if (measureAccidentals) measureAccidentals.set(pitchKey, 'n');
+	} else if (measureAccidentals) {
+		// No explicit accidental, no key accidental - check if earlier note in measure had one
+		if (prevMeasureAccid && prevMeasureAccid !== 'n') {
+			// Previous note had an accidental - add cancellation natural
+			accid = 'n';
+			measureAccidentals.set(pitchKey, 'n');
+		}
 	}
 
 	return { pname: pitch.phonet, oct, accid, accidGes };
@@ -457,7 +481,8 @@ const noteEventToMEI = (
 	tieEnd?: boolean,
 	contextStemDir?: StemDirection,
 	keyFifths: number = 0,
-	ottavaShift: number = 0
+	ottavaShift: number = 0,
+	measureAccidentals?: Map<string, string>
 ): NoteEventResult => {
 	const dur = DURATIONS[event.duration.division] || "4";
 	const dots = event.duration.dots || 0;
@@ -492,7 +517,7 @@ const noteEventToMEI = (
 
 	// Single note
 	if (event.pitches.length === 1) {
-		const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitches[0], keyFifths, ottavaShift, measureAccidentals);
 		const noteId = generateId('note');
 		return {
 			xml: buildNoteElement(pitch, dur, dots, indent, false, noteOptions, noteId),
@@ -533,7 +558,7 @@ const noteEventToMEI = (
 	let result = `${indent}<chord ${chordAttrs}>\n`;
 
 	for (const p of event.pitches) {
-		const pitch = encodePitch(p, keyFifths, ottavaShift);
+		const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 		result += buildNoteElement(pitch, dur, dots, indent + '    ', true);
 	}
 
@@ -578,7 +603,7 @@ const noteEventToMEI = (
 
 
 // Convert RestEvent to MEI
-const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0): string => {
+const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): string => {
 	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}"`;
@@ -606,6 +631,7 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 // TupletEventResult - return type for tupletEventToMEI
 interface TupletEventResult {
 	xml: string;
+	firstNoteId: string | null;  // ID of first note in tuplet (for attaching pending markups)
 	slurStarts: string[];  // Note IDs that start slurs
 	slurEnds: string[];    // Note IDs that end slurs
 	dynamics: DynamRef[];
@@ -632,7 +658,7 @@ const tupletHasInternalBeams = (event: TupletEvent): boolean => {
 };
 
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false): TupletEventResult => {
+const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>): TupletEventResult => {
 	// 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
@@ -647,6 +673,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	const effectiveStaff = currentStaff ?? layerStaff;
 
 	// Collect control event info from notes inside tuplet
+	let firstNoteId: string | null = null;
 	const slurStarts: string[] = [];
 	const slurEnds: string[] = [];
 	const dynamics: DynamRef[] = [];
@@ -677,9 +704,11 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
 				? { ...noteEvent, staff: effectiveStaff }
 				: noteEvent;
-			const result = noteEventToMEI(effectiveNoteEvent, noteIndent, layerStaff, false, undefined, keyFifths, ottavaShift);
+			const result = noteEventToMEI(effectiveNoteEvent, noteIndent, layerStaff, false, undefined, keyFifths, ottavaShift, measureAccidentals);
 			xml += result.xml;
 
+			if (!firstNoteId) firstNoteId = result.elementId;
+
 			// Collect slur info
 			if (result.slurStart) slurStarts.push(result.elementId);
 			if (result.slurEnd) slurEnds.push(result.elementId);
@@ -699,7 +728,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			}
 		} else if (e.type === 'rest') {
 			const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift);
+			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals);
 		}
 	}
 
@@ -709,12 +738,12 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	}
 
 	xml += `${indent}</tuplet>\n`;
-	return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
 };
 
 
 // Convert TremoloEvent to MEI (fingered tremolo - alternating between two notes)
-const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0): string => {
+const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): string => {
 	const ftremId = generateId('fTrem');
 
 	// For \repeat tremolo 4 { c16 d16 }:
@@ -738,7 +767,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 
 	// First note (or chord)
 	if (event.pitchA.length === 1) {
-		const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -746,7 +775,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 	} 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);
+			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -757,7 +786,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 
 	// Second note (or chord)
 	if (event.pitchB.length === 1) {
-		const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift);
+		const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -765,7 +794,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 	} 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);
+			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
@@ -971,6 +1000,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	const harmonies: HarmonyRef[] = [];
 	const barlines: BarlineRef[] = [];
 	const markups: MarkupRef[] = [];
+	const pendingMarkups: { content: string; placement?: 'above' | 'below' }[] = [];
 
 	// Track current stem direction from context changes
 	let currentStemDirection: StemDirection | undefined = undefined;
@@ -978,9 +1008,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	// Track current staff for cross-staff notation
 	let currentStaff: number = voice.staff || 1;
 
+	// Track in-measure accidentals for cancellation naturals
+	const measureAccidentals = new Map<string, string>();
+
 	// Track pending tie pitches (for tie="t" on next note) - initialized from previous measure
 	let pendingTiePitches: Pitch[] = [...initialTiePitches];
 
+	// Helper to flush pending markups onto a note ID
+	const flushPendingMarkups = (noteId: string) => {
+		for (const mkup of pendingMarkups) {
+			markups.push({ startid: noteId, content: mkup.content, placement: mkup.placement });
+		}
+		pendingMarkups.length = 0;
+	};
+
 	// Helper to check if pitches match for tie continuation
 	const pitchesMatch = (p1: Pitch[], p2: Pitch[]): boolean => {
 		if (p1.length !== p2.length) return false;
@@ -1018,10 +1059,13 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					? { ...noteEvent, staff: currentStaff }
 					: noteEvent;
 
-				const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift);
+				const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
 				xml += result.xml;
 				lastNoteId = result.elementId;
 
+				// Flush any pending markups onto this note
+				flushPendingMarkups(result.elementId);
+
 				// If there's a pending ottava, start the span on this note
 				if (pendingOttava !== null && pendingOttava !== 0) {
 					const dis: 8 | 15 = Math.abs(pendingOttava) === 2 ? 15 : 8;
@@ -1124,14 +1168,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				break;
 			}
 			case 'rest':
-				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift);
+				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
 				break;
 			case 'tuplet': {
 				// 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
-				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen);
+				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
 				xml += tupletResult.xml;
 
+				// Flush any pending markups onto the first note of the tuplet
+				if (tupletResult.firstNoteId) {
+					flushPendingMarkups(tupletResult.firstNoteId);
+					lastNoteId = tupletResult.firstNoteId;
+				}
+
 				// Process slur ends first (to close any pending slurs from before this tuplet)
 				for (const endId of tupletResult.slurEnds) {
 					if (currentSlur) {
@@ -1159,7 +1209,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				break;
 			}
 			case 'tremolo':
-				xml += tremoloEventToMEI(event as TremoloEvent, currentIndent, keyFifths, currentOttavaShift);
+				xml += tremoloEventToMEI(event as TremoloEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals);
 				break;
 			case 'context': {
 				const ctx = event as ContextChange;
@@ -1224,16 +1274,20 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 					harmonies.push({ startid: lastNoteId, text: (event as HarmonyEvent).text });
 				}
 				break;
-			case 'markup':
-				// Markup needs a note ID to attach to - use the last note if available
+			case 'markup': {
+				// Markup needs a note ID to attach to
+				const mkupEvent = event as MarkupEvent;
 				if (lastNoteId) {
-					const mkupEvent = event as MarkupEvent;
 					markups.push({
 						startid: lastNoteId,
 						content: mkupEvent.content,
 						placement: mkupEvent.placement,
 					});
+				} else {
+					// No note yet - save as pending, will attach to next note
+					pendingMarkups.push({ content: mkupEvent.content, placement: mkupEvent.placement });
 				}
+			}
 				break;
 		}