@k-l-lambda/lilylet 0.1.51 → 0.1.53

package/lib/lilylet/meiEncoder.js

@@ -85,6 +85,7 @@ const DYNAMIC_MAP = {
     fff: "fff",
     sfz: "sfz",
     rfz: "rfz",
+    fp: "fp",
 };
 // ID generation state - uses session prefix to prevent collisions in concurrent encoding
 let idCounter = 0;
@@ -118,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
@@ -132,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 };
 };
@@ -338,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);
@@ -372,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),
@@ -415,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
@@ -455,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)
@@ -475,8 +503,24 @@ const restEventToMEI = (event, indent, keyFifths = 0, ottavaShift = 0) => {
     }
     return `${indent}<rest ${attrs} />\n`;
 };
+// 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
+const tupletHasInternalBeams = (event) => {
+    let starts = 0;
+    let ends = 0;
+    for (const e of event.events) {
+        if (e.type === 'note') {
+            const markOptions = extractMarkOptions(e.marks);
+            if (markOptions.beamStart)
+                starts++;
+            if (markOptions.beamEnd)
+                ends++;
+        }
+    }
+    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
@@ -487,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 = [];
@@ -495,18 +540,27 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
     const mordents = [];
     const turns = [];
     const arpeggios = [];
-    // If we're inside a parent beam, don't create internal beams - notes go directly into tuplet
-    // MEI allows: <beam><tuplet><note/>...</tuplet><tuplet><note/>...</tuplet></beam>
-    // Beam state is managed by encodeLayer, not here.
+    // Handle internal beam groups: if notes have manual beam marks, respect them
+    const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
+    let beamOpen = false;
     for (const e of event.events) {
         if (e.type === 'note') {
-            // For cross-staff notation: set note's staff if different from layerStaff
             const noteEvent = e;
+            const markOptions = extractMarkOptions(noteEvent.marks);
+            // Open beam if this note starts a beam group
+            if (hasInternalBeams && markOptions.beamStart && !beamOpen) {
+                xml += `${baseIndent}<beam xml:id="${generateId('beam')}">\n`;
+                beamOpen = true;
+            }
+            const noteIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+            // For cross-staff notation: set note's staff if different from layerStaff
             const effectiveNoteEvent = effectiveStaff && layerStaff && effectiveStaff !== layerStaff
                 ? { ...noteEvent, staff: effectiveStaff }
                 : noteEvent;
-            const result = noteEventToMEI(effectiveNoteEvent, baseIndent, 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);
@@ -525,16 +579,26 @@ const tupletEventToMEI = (event, indent, layerStaff, keyFifths = 0, currentStaff
                 turns.push({ startid: result.elementId });
             if (result.arpeggio)
                 arpeggios.push({ plist: result.elementId });
+            // Close beam if this note ends a beam group
+            if (hasInternalBeams && markOptions.beamEnd && beamOpen) {
+                xml += `${baseIndent}</beam>\n`;
+                beamOpen = false;
+            }
         }
         else if (e.type === 'rest') {
-            xml += restEventToMEI(e, baseIndent, keyFifths, ottavaShift);
+            const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
+            xml += restEventToMEI(e, restIndent, keyFifths, ottavaShift, measureAccidentals);
         }
     }
+    // Close any unclosed beam
+    if (beamOpen) {
+        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)
@@ -553,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}"`;
@@ -564,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}"`;
@@ -576,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}"`;
@@ -587,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}"`;
@@ -608,6 +672,11 @@ const getEventBeamMarks = (event) => {
     }
     if (event.type === 'tuplet') {
         const tuplet = event;
+        // If the tuplet has internal beam groups, don't report beam marks to the parent
+        // so the parent won't wrap the tuplet in an external <beam>
+        if (tupletHasInternalBeams(tuplet)) {
+            return { beamStart: false, beamEnd: false };
+        }
         let beamStart = false;
         let beamEnd = false;
         for (const e of tuplet.events) {
@@ -659,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)
@@ -697,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;
@@ -799,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) {
@@ -830,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;
@@ -898,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/lib/lilylet/serializer.js

@@ -89,6 +89,7 @@ const DYNAMIC_MAP = {
     fff: '\\fff',
     sfz: '\\sfz',
     rfz: '\\rfz',
+    fp: '\\fp',
 };
 // Hairpin to Lilylet notation
 const HAIRPIN_MAP = {

package/lib/lilylet/types.d.ts

@@ -51,7 +51,8 @@ export declare enum DynamicType {
     ff = "ff",
     fff = "fff",
     sfz = "sfz",
-    rfz = "rfz"
+    rfz = "rfz",
+    fp = "fp"
 }
 export declare enum HairpinType {
     crescendoStart = "crescendoStart",

package/lib/lilylet/types.js

@@ -60,6 +60,7 @@ export var DynamicType;
     DynamicType["fff"] = "fff";
     DynamicType["sfz"] = "sfz";
     DynamicType["rfz"] = "rfz";
+    DynamicType["fp"] = "fp";
 })(DynamicType || (DynamicType = {}));
 export var HairpinType;
 (function (HairpinType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.51",
+  "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",