@k-l-lambda/lilylet 0.1.50 → 0.1.52

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;
@@ -408,6 +409,11 @@ const noteEventToMEI = (event, indent, layerStaff, tieEnd, contextStemDir, keyFi
     if (layerStaff && noteOptions.staff && noteOptions.staff !== layerStaff) {
         chordAttrs += ` staff="${noteOptions.staff}"`;
     }
+    if (noteOptions.tremolo) {
+        const stemMod = tremoloToStemMod(noteOptions.tremolo);
+        if (stemMod)
+            chordAttrs += ` stem.mod="${stemMod}"`;
+    }
     let result = `${indent}<chord ${chordAttrs}>\n`;
     for (const p of event.pitches) {
         const pitch = encodePitch(p, keyFifths, ottavaShift);
@@ -470,6 +476,22 @@ 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) => {
     // LilyPond \times 2/3 means "multiply duration by 2/3"
@@ -490,17 +512,24 @@ 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);
             xml += result.xml;
             // Collect slur info
             if (result.slurStart)
@@ -520,11 +549,21 @@ 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);
         }
     }
+    // Close any unclosed beam
+    if (beamOpen) {
+        xml += `${baseIndent}</beam>\n`;
+    }
     xml += `${indent}</tuplet>\n`;
     return { xml, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
 };
@@ -603,6 +642,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) {

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 = {
@@ -190,6 +191,9 @@ const serializeMarks = (marks) => {
                     parts.push(pedalStr);
                 break;
             }
+            case 'fingering':
+                parts.push('-' + mark.finger);
+                break;
         }
     }
     return parts.join('');
@@ -449,8 +453,9 @@ const findVoiceClef = (voice) => {
 // Takes currentStaff (what parser thinks staff is) and returns { str, newStaff }
 // If isGrandStaff is true, always output \staff command for clarity
 // measureContext provides key/time for first voice
-// staffClef is the clef for this voice's staff (tracked across measures)
-const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContext, isFirstVoice = false, staffClef) => {
+// allStaffClefs is the clef map for all staves (tracked across measures)
+// emittedClefs tracks which clefs have already been output (avoids duplicates)
+const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContext, isFirstVoice = false, allStaffClefs, emittedClefs) => {
     const parts = [];
     let prevDuration;
     // Each voice starts fresh from middle C (step=0, octave=0)
@@ -480,22 +485,61 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
             parts.push('\\time ' + numerator + '/' + denominator);
         }
     }
-    // Output clef for every voice (use staff clef tracked across measures, or find from voice events)
-    const voiceClef = staffClef || findVoiceClef(voice);
-    if (voiceClef) {
+    // Output clef only if not yet emitted or changed for this staff
+    const voiceClef = allStaffClefs?.[voice.staff] || findVoiceClef(voice);
+    const clefAlreadyEmitted = voiceClef && emittedClefs?.[voice.staff] === voiceClef;
+    if (voiceClef && !clefAlreadyEmitted) {
         parts.push('\\clef "' + CLEF_MAP[voiceClef] + '"');
+        if (emittedClefs)
+            emittedClefs[voice.staff] = voiceClef;
     }
-    // Track if we've already output the clef to avoid duplication
-    let clefOutputted = !!voiceClef;
+    // Skip redundant clef context events if this staff's clef is already established
+    const clefOutputted = !!voiceClef && !!emittedClefs?.[voice.staff];
+    let activeStaff = voice.staff;
+    let activeStemDir;
     for (const event of voice.events) {
-        // Skip clef context events if we've already output the clef at the beginning
-        if (clefOutputted && event.type === 'context') {
+        if (event.type === 'context') {
             const ctx = event;
-            if (ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo && !ctx.staff) {
-                // This is a clef-only context event, skip it
+            // Skip context events that belong to a different staff (cross-staff clef/ottava)
+            if (ctx.staff && ctx.staff !== voice.staff) {
+                continue;
+            }
+            // Skip clef-only context events if clef already established for this staff
+            if (clefOutputted && ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo) {
                 continue;
             }
         }
+        if (event.type === 'note') {
+            const noteEvt = event;
+            // Cross-staff: emit \staff when note's effective staff differs from active
+            const effectiveStaff = noteEvt.staff || voice.staff;
+            if (effectiveStaff !== activeStaff) {
+                activeStaff = effectiveStaff;
+                parts.push('\\staff "' + activeStaff + '"');
+                // Emit the target staff's clef if it differs from what was last emitted for this staff
+                const targetClef = allStaffClefs?.[activeStaff];
+                if (targetClef && emittedClefs?.[activeStaff] !== targetClef) {
+                    parts.push('\\clef "' + CLEF_MAP[targetClef] + '"');
+                    if (emittedClefs)
+                        emittedClefs[activeStaff] = targetClef;
+                }
+            }
+            // Stem direction: emit \stemUp/\stemDown/\stemNeutral on change
+            const stemDir = noteEvt.stemDirection;
+            if (stemDir !== activeStemDir) {
+                if (stemDir === StemDirection.up) {
+                    parts.push('\\stemUp');
+                }
+                else if (stemDir === StemDirection.down) {
+                    parts.push('\\stemDown');
+                }
+                else if (activeStemDir) {
+                    // Was set, now undefined → reset to neutral
+                    parts.push('\\stemNeutral');
+                }
+                activeStemDir = stemDir;
+            }
+        }
         const { str: eventStr, newEnv } = serializeEvent(event, pitchEnv, prevDuration);
         pitchEnv = newEnv;
         if (eventStr) {
@@ -508,12 +552,16 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
         else if (event.type === 'rest') {
             prevDuration = event.duration;
         }
+        else if (event.type === 'context' && event.clef && emittedClefs) {
+            const ctx = event;
+            emittedClefs[ctx.staff || activeStaff] = ctx.clef;
+        }
     }
     return { str: parts.join(' '), newStaff: voice.staff };
 };
 // Serialize a part, tracking staff state across voices
 // measureContext is passed to all voices (for clef), but key/time only to first voice
-const serializePart = (part, currentStaff, isGrandStaff = false, measureContext, isFirstPart = false, clefsByStaff) => {
+const serializePart = (part, currentStaff, isGrandStaff = false, measureContext, isFirstPart = false, clefsByStaff, emittedClefs) => {
     if (part.voices.length === 0) {
         return { str: '', newStaff: currentStaff };
     }
@@ -522,10 +570,8 @@ const serializePart = (part, currentStaff, isGrandStaff = false, measureContext,
     for (let i = 0; i < part.voices.length; i++) {
         const voice = part.voices[i];
         // Pass measureContext to all voices, isFirstVoice for key/time
-        // Pass staff clef from clefsByStaff map
         const isFirstVoice = isFirstPart && i === 0;
-        const staffClef = clefsByStaff?.[voice.staff];
-        const { str, newStaff } = serializeVoice(voice, staff, isGrandStaff, measureContext, isFirstVoice, staffClef);
+        const { str, newStaff } = serializeVoice(voice, staff, isGrandStaff, measureContext, isFirstVoice, clefsByStaff, emittedClefs);
         voiceStrs.push(str);
         staff = newStaff;
     }
@@ -534,7 +580,7 @@ const serializePart = (part, currentStaff, isGrandStaff = false, measureContext,
 };
 // Serialize a measure, tracking staff state across parts
 // Always output key/time at start of each measure
-const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false, currentKey, currentTime, staffClefs) => {
+const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false, currentKey, currentTime, staffClefs, emittedClefs) => {
     const parts = [];
     // Build measure context for all voices (key/time)
     // Key and time are written to first voice, clef to all voices based on staff
@@ -548,7 +594,7 @@ const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false,
     // Parts
     let staff = currentStaff;
     if (measure.parts.length === 1) {
-        const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsByStaff);
+        const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsByStaff, emittedClefs);
         if (partStr) {
             parts.push(partStr);
         }
@@ -560,7 +606,7 @@ const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false,
         for (let i = 0; i < measure.parts.length; i++) {
             const part = measure.parts[i];
             // Pass measureContext to all parts, isFirstPart to first part only
-            const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsByStaff);
+            const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsByStaff, emittedClefs);
             if (str) {
                 partStrs.push(str);
             }
@@ -620,6 +666,7 @@ export const serializeLilyletDoc = (doc) => {
     let currentKey;
     let currentTime;
     const staffClefs = {}; // Track clef per staff
+    const emittedClefs = {}; // Track which clefs have been output
     for (let i = 0; i < doc.measures.length; i++) {
         const measure = doc.measures[i];
         // Update current key/time if measure has them
@@ -634,12 +681,15 @@ export const serializeLilyletDoc = (doc) => {
             for (const voice of part.voices) {
                 for (const event of voice.events) {
                     if (event.type === 'context' && event.clef) {
-                        staffClefs[voice.staff] = event.clef;
+                        const ctx = event;
+                        // Use the event's staff if specified (cross-staff), otherwise the voice's staff
+                        const clefStaff = ctx.staff || voice.staff;
+                        staffClefs[clefStaff] = ctx.clef;
                     }
                 }
             }
         }
-        const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, staffClefs);
+        const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, staffClefs, emittedClefs);
         // Always include measure, even if empty (use space rest for empty measures)
         measureStrs.push(measureStr || 's1');
         currentStaff = newStaff;

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.50",
+  "version": "0.1.52",
   "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",