@k-l-lambda/lilylet 0.1.39 → 0.1.44

package/lib/index.js

@@ -6,3 +6,5 @@ import * as musicXmlDecoder from "./musicXmlDecoder.js";
 import * as lilypondEncoder from "./lilypondEncoder.js";
 import * as musicXmlEncoder from "./musicXmlEncoder.js";
 export { meiEncoder, musicXmlDecoder, lilypondEncoder, musicXmlEncoder, };
+// Note: lilypondDecoder is optional and requires @k-l-lambda/lotus
+// Import it directly from '@k-l-lambda/lilylet/lib/lilypondDecoder.js' if needed

package/lib/lilypondEncoder.d.ts

@@ -16,6 +16,11 @@ interface RenderOptions {
 }
 /**
  * Encode a complete LilyletDoc to LilyPond format
+ *
+ * Structure:
+ * - Multiple parts → outer <<>>
+ * - Part with multiple staves → GrandStaff
+ * - Part with single staff → standalone Staff
  */
 export declare const encode: (doc: LilyletDoc, options?: RenderOptions) => string;
 /**

package/lib/lilypondEncoder.js

@@ -102,6 +102,19 @@ const BARLINE_MAP = {
     ":..:": ":..:",
     ":..:|": ":..:|",
 };
+// === Helper Functions ===
+/**
+ * Generate a spacer rest that fills a measure based on time signature.
+ * Uses multiplication syntax: s{denominator}*{numerator}
+ * @param timeSig - Time signature { numerator, denominator }
+ * @returns LilyPond spacer rest string (e.g., "s4*3" for 3/4, "s8*6" for 6/8)
+ */
+const getSpacerRest = (timeSig) => {
+    if (!timeSig)
+        return 's1';
+    const { numerator, denominator } = timeSig;
+    return `s${denominator}*${numerator}`;
+};
 /**
  * Calculate the octave markers needed to serialize a pitch in relative mode.
  */
@@ -448,9 +461,10 @@ const encodeBarlineEvent = (event) => {
 };
 /**
  * Encode a harmony event (chord symbol)
+ * Uses the lilylet extension: \chords "text" (parsed by modified lotus grammar)
  */
 const encodeHarmonyEvent = (event) => {
-    return `^\\markup { ${event.text} }`;
+    return `\\chords "${event.text}"`;
 };
 /**
  * Encode a markup event
@@ -552,29 +566,63 @@ const encodeMetadata = (metadata) => {
 };
 /**
  * Encode a complete LilyletDoc to LilyPond format
+ *
+ * Structure:
+ * - Multiple parts → outer <<>>
+ * - Part with multiple staves → GrandStaff
+ * - Part with single staff → standalone Staff
  */
 export const encode = (doc, options = {}) => {
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    // Collect all voices across measures, grouped by staff
-    const staffVoices = new Map(); // staff -> measure -> voice content
+    // Filter out trailing empty measures (measures with no musical content)
+    const hasMusicContent = (measure) => {
+        for (const part of measure.parts) {
+            for (const voice of part.voices) {
+                for (const event of voice.events) {
+                    if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'tremolo') {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    // Trim trailing empty measures
+    let measureCount = doc.measures.length;
+    while (measureCount > 0 && !hasMusicContent(doc.measures[measureCount - 1])) {
+        measureCount--;
+    }
+    const measures = doc.measures.slice(0, measureCount);
+    // Determine number of parts from the document
+    const partCount = Math.max(...measures.map(m => m.parts.length), 1);
+    const partVoices = [];
+    for (let pi = 0; pi < partCount; pi++) {
+        partVoices.push(new Map());
+    }
+    // Track time signature for each measure (for spacer rests)
+    const measureTimeSigs = [];
     let currentKey;
     let currentTimeSig;
-    for (let mi = 0; mi < doc.measures.length; mi++) {
-        const measure = doc.measures[mi];
+    for (let mi = 0; mi < measures.length; mi++) {
+        const measure = measures[mi];
         // Update context from measure
         if (measure.key)
             currentKey = measure.key;
         if (measure.timeSig)
             currentTimeSig = measure.timeSig;
+        // Store time signature for this measure
+        measureTimeSigs[mi] = currentTimeSig;
         // Process each part
-        for (const part of measure.parts) {
+        for (let pi = 0; pi < measure.parts.length; pi++) {
+            const part = measure.parts[pi];
+            const staffMap = partVoices[pi];
             for (let vi = 0; vi < part.voices.length; vi++) {
                 const voice = part.voices[vi];
                 const staff = voice.staff || 1;
-                if (!staffVoices.has(staff)) {
-                    staffVoices.set(staff, []);
+                if (!staffMap.has(staff)) {
+                    staffMap.set(staff, []);
                 }
-                const staffMeasures = staffVoices.get(staff);
+                const staffMeasures = staffMap.get(staff);
                 // Ensure we have enough measure slots
                 while (staffMeasures.length <= mi) {
                     staffMeasures.push([]);
@@ -589,31 +637,75 @@ export const encode = (doc, options = {}) => {
             }
         }
     }
-    // Build music content
-    const staffCount = Math.max(...Array.from(staffVoices.keys()));
-    const staffStrings = [];
-    for (let si = 1; si <= staffCount; si++) {
-        const measures = staffVoices.get(si) || [];
+    // Build a staff string (used for both GrandStaff children and standalone Staff)
+    // Staff ID format: "partIndex_staffIndex" (e.g., "1_1", "1_2", "2_1") for multi-part decoding
+    const buildStaffString = (measures, staffId, indent) => {
         // Find max voices per measure for this staff
         const maxVoices = Math.max(...measures.map(m => m.length), 1);
         // Build voice lines
         const voiceLines = [];
         for (let vi = 0; vi < maxVoices; vi++) {
             const measureContents = measures.map((m, mi) => {
-                const content = m[vi] || 's1'; // Space rest if no content
-                return `        ${content} |  % ${mi + 1}`;
+                // Use correct spacer rest based on time signature
+                const spacer = getSpacerRest(measureTimeSigs[mi]);
+                const content = m[vi] || spacer;
+                // Wrap each measure in its own \relative c' to reset pitch context
+                return `${indent}    \\relative c' { ${content} } |  % ${mi + 1}`;
             });
-            voiceLines.push(`      \\new Voice \\relative c' {\n${measureContents.join('\n')}\n      }`);
+            voiceLines.push(`${indent}  \\new Voice {\n${measureContents.join('\n')}\n${indent}  }`);
+        }
+        return `${indent}\\new Staff = "${staffId}" <<\n${voiceLines.join('\n')}\n${indent}>>`;
+    };
+    // Build music content for each part
+    const partStrings = [];
+    for (let pi = 0; pi < partCount; pi++) {
+        const staffMap = partVoices[pi];
+        const staffNums = Array.from(staffMap.keys()).sort((a, b) => a - b);
+        if (staffNums.length === 0) {
+            // Empty part, skip
+            continue;
         }
-        staffStrings.push(`    \\new Staff = "${si}" <<\n${voiceLines.join('\n')}\n    >>`);
+        const partIndex = pi + 1; // 1-based part index
+        if (staffNums.length === 1) {
+            // Single staff part → standalone Staff
+            const staffNum = staffNums[0];
+            const measures = staffMap.get(staffNum);
+            const staffId = `${partIndex}_${staffNum}`;
+            const staffStr = buildStaffString(measures, staffId, '    ');
+            partStrings.push(staffStr);
+        }
+        else {
+            // Multiple staves → GrandStaff
+            const staffStrings = [];
+            for (const staffNum of staffNums) {
+                const measures = staffMap.get(staffNum);
+                const staffId = `${partIndex}_${staffNum}`;
+                const staffStr = buildStaffString(measures, staffId, '      ');
+                staffStrings.push(staffStr);
+            }
+            partStrings.push(`    \\new GrandStaff <<\n${staffStrings.join('\n')}\n    >>`);
+        }
+    }
+    const musicContent = partStrings.join('\n');
+    // Determine outer wrapper
+    // - Single part with single staff → just Staff (no outer <<>>)
+    // - Single part with multiple staves → GrandStaff (no extra outer <<>>)
+    // - Multiple parts → outer <<>>
+    let scoreContent;
+    if (partCount === 1 && partStrings.length === 1) {
+        // Single part - use as-is (already has Staff or GrandStaff)
+        scoreContent = musicContent;
+    }
+    else {
+        // Multiple parts - wrap in <<>>
+        scoreContent = `  <<\n${musicContent}\n  >>`;
     }
-    const musicContent = staffStrings.join('\n');
     // Build header
     const headerContent = doc.metadata ? encodeMetadata(doc.metadata) : '  tagline = ##f';
     // Build document
     const paperWidth = typeof opts.paper?.width === 'number' ? `${opts.paper.width}\\mm` : opts.paper?.width || '210\\mm';
     const paperHeight = typeof opts.paper?.height === 'number' ? `${opts.paper.height}\\mm` : opts.paper?.height || '297\\mm';
-    const lyDoc = `\\version "2.24.0"
+    const lyDoc = `\\version "2.22.0"
 
 \\language "english"
 
@@ -638,9 +730,7 @@ ${headerContent}
 }
 
 \\score {
-  \\new GrandStaff <<
-${musicContent}
-  >>
+${scoreContent}
 
   \\layout { }${opts.withMIDI ? '\n  \\midi { }' : ''}
 }

package/lib/meiEncoder.js

@@ -32,7 +32,8 @@ const keyToFifths = (key) => {
         fifths -= 7;
     if (key.mode === 'minor')
         fifths -= 3;
-    return fifths;
+    // Clamp to valid range [-7, 7] since standard notation doesn't support more than 7 sharps/flats
+    return Math.max(-7, Math.min(7, fifths));
 };
 const CLEF_SHAPES = {
     treble: { shape: "G", line: 2 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.39",
+  "version": "0.1.44",
   "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",
@@ -37,7 +37,7 @@
   "license": "ISC",
   "homepage": "https://github.com/k-l-lambda/lilylet#readme",
   "optionalDependencies": {
-    "@k-l-lambda/lotus": "^1.0.3"
+    "@k-l-lambda/lotus": "^1.0.5"
   },
   "devDependencies": {
     "@types/node": "^20.11.20",

package/source/lilylet/index.ts

@@ -14,3 +14,6 @@ export {
 	lilypondEncoder,
 	musicXmlEncoder,
 };
+
+// Note: lilypondDecoder is optional and requires @k-l-lambda/lotus
+// Import it directly from '@k-l-lambda/lilylet/lib/lilypondDecoder.js' if needed