@k-l-lambda/lilylet 0.1.62 → 0.1.64

package/lib/tests/musicxml-roundtrip.js

@@ -0,0 +1,296 @@
+/**
+ * MusicXML Roundtrip Test
+ *
+ * Tests the lilylet -> musicxml -> lilylet conversion cycle.
+ * Compares the output of two conversions to verify consistency.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { parseCode, serializeLilyletDoc, musicXmlEncoder, musicXmlDecoder } from "../source/lilylet/index.js";
+const UNIT_CASES_DIR = path.join(import.meta.dirname, "assets/unit-cases");
+const OUTPUT_DIR = path.join(import.meta.dirname, "output/musicxml-roundtrip");
+// Known limitations - skip these tests
+const SKIP_FILES = new Set([]);
+// Ensure output directory exists
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+/**
+ * Flatten tuplet events - extract inner events from TupletEvent
+ */
+const flattenEvents = (events) => {
+    const result = [];
+    for (const e of events) {
+        if (e.type === 'tuplet') {
+            result.push(...e.events);
+        }
+        else {
+            result.push(e);
+        }
+    }
+    return result;
+};
+/**
+ * Filter to only note and rest events (core musical content).
+ * Context events (key, time, clef, ottava, stemDirection, tempo) are handled
+ * at the measure/attribute level in MusicXML and may not survive as voice events.
+ * Other event types (tremolo, harmony, barline, markup) may also be lost or
+ * repositioned during roundtrip.
+ */
+const filterToNoteRest = (events) => events.filter(e => e.type === 'note' || e.type === 'rest');
+/**
+ * Compare two LilyletDoc structures with robust comparison.
+ *
+ * Strategy:
+ * - Flatten tuplets, filter artifacts, dedupe context events
+ * - Compare by staff (not voice index) across all measures
+ * - Verify pitch/duration content of note events
+ */
+const compareDocuments = (doc1, doc2) => {
+    // Collect all note/rest events from all measures for a specific staff within a part
+    const collectEventsByStaff = (measures, partIndex, staff) => {
+        const allEvents = [];
+        for (const m of measures) {
+            const part = m.parts[partIndex];
+            if (part) {
+                for (const voice of part.voices) {
+                    if ((voice.staff || 1) === staff) {
+                        allEvents.push(...filterToNoteRest(flattenEvents(voice.events)));
+                    }
+                }
+            }
+        }
+        return allEvents;
+    };
+    // Get all unique staves used in a part across all measures
+    const getStaves = (measures, partIndex) => {
+        const staves = new Set();
+        for (const m of measures) {
+            const part = m.parts[partIndex];
+            if (part) {
+                for (const voice of part.voices) {
+                    staves.add(voice.staff || 1);
+                }
+            }
+        }
+        return Array.from(staves).sort((a, b) => a - b);
+    };
+    // Get max parts count
+    const maxParts1 = Math.max(...doc1.measures.map(m => m.parts.length), 0);
+    const maxParts2 = Math.max(...doc2.measures.map(m => m.parts.length), 0);
+    if (maxParts1 !== maxParts2) {
+        return {
+            equal: false,
+            diff: `Part count differs: ${maxParts1} vs ${maxParts2}`
+        };
+    }
+    // Compare each part by staff
+    for (let pi = 0; pi < maxParts1; pi++) {
+        const staves1 = getStaves(doc1.measures, pi);
+        const staves2 = getStaves(doc2.measures, pi);
+        if (staves1.length !== staves2.length) {
+            return {
+                equal: false,
+                diff: `Part ${pi + 1}: Staff count differs: ${staves1.length} vs ${staves2.length}`
+            };
+        }
+        // Compare events for each staff
+        for (const staff of staves1) {
+            const events1 = collectEventsByStaff(doc1.measures, pi, staff);
+            const events2 = collectEventsByStaff(doc2.measures, pi, staff);
+            if (events1.length !== events2.length) {
+                return {
+                    equal: false,
+                    diff: `Part ${pi + 1}, Staff ${staff}: Total event count differs: ${events1.length} vs ${events2.length}`
+                };
+            }
+            // Content verification: compare note/rest pitch and duration values
+            for (let i = 0; i < events1.length; i++) {
+                const e1 = events1[i];
+                const e2 = events2[i];
+                if (e1.type !== e2.type) {
+                    return {
+                        equal: false,
+                        diff: `Part ${pi + 1}, Staff ${staff}, Event ${i + 1}: Type differs: ${e1.type} vs ${e2.type}`
+                    };
+                }
+                if (e1.type === 'note' && e2.type === 'note') {
+                    // Compare pitch count
+                    if (e1.pitches.length !== e2.pitches.length) {
+                        return {
+                            equal: false,
+                            diff: `Part ${pi + 1}, Staff ${staff}, Event ${i + 1}: Pitch count differs: ${e1.pitches.length} vs ${e2.pitches.length}`
+                        };
+                    }
+                    // Compare each pitch (phonet + octave)
+                    for (let j = 0; j < e1.pitches.length; j++) {
+                        const p1 = e1.pitches[j];
+                        const p2 = e2.pitches[j];
+                        if (p1.phonet !== p2.phonet || p1.octave !== p2.octave) {
+                            return {
+                                equal: false,
+                                diff: `Part ${pi + 1}, Staff ${staff}, Event ${i + 1}: Pitch ${j + 1} differs: ${p1.phonet}${p1.octave} vs ${p2.phonet}${p2.octave}`
+                            };
+                        }
+                    }
+                    // Compare duration (division + dots)
+                    if (e1.duration.division !== e2.duration.division || e1.duration.dots !== e2.duration.dots) {
+                        return {
+                            equal: false,
+                            diff: `Part ${pi + 1}, Staff ${staff}, Event ${i + 1}: Duration differs: div=${e1.duration.division} dots=${e1.duration.dots} vs div=${e2.duration.division} dots=${e2.duration.dots}`
+                        };
+                    }
+                }
+                if (e1.type === 'rest' && e2.type === 'rest') {
+                    if (e1.duration.division !== e2.duration.division || e1.duration.dots !== e2.duration.dots) {
+                        return {
+                            equal: false,
+                            diff: `Part ${pi + 1}, Staff ${staff}, Event ${i + 1}: Rest duration differs: div=${e1.duration.division} dots=${e1.duration.dots} vs div=${e2.duration.division} dots=${e2.duration.dots}`
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return { equal: true };
+};
+/**
+ * Run full roundtrip test
+ */
+const testRoundtrip = (filename) => {
+    const filepath = path.join(UNIT_CASES_DIR, filename);
+    try {
+        // Step 1: Read and parse original lilylet
+        const originalLyl = fs.readFileSync(filepath, "utf-8");
+        const doc1 = parseCode(originalLyl);
+        if (!doc1 || doc1.measures.length === 0) {
+            return {
+                filename,
+                status: "error",
+                error: "Failed to parse original lilylet file"
+            };
+        }
+        // Step 2: Encode to MusicXML
+        const generatedXml = musicXmlEncoder.encode(doc1);
+        // Save MusicXML for inspection
+        const baseName = path.basename(filename, ".lyl");
+        fs.writeFileSync(path.join(OUTPUT_DIR, `${baseName}.musicxml`), generatedXml);
+        // Step 3: Decode MusicXML back to LilyletDoc
+        let doc2;
+        try {
+            doc2 = musicXmlDecoder.decode(generatedXml);
+        }
+        catch (e) {
+            return {
+                filename,
+                status: "error",
+                error: `MusicXML decode error: ${e instanceof Error ? e.message : String(e)}`,
+                originalLyl,
+                generatedXml
+            };
+        }
+        if (!doc2 || doc2.measures.length === 0) {
+            return {
+                filename,
+                status: "error",
+                error: "Failed to decode MusicXML output",
+                originalLyl,
+                generatedXml
+            };
+        }
+        // Step 4: Serialize back to lilylet
+        const roundtripLyl = serializeLilyletDoc(doc2);
+        fs.writeFileSync(path.join(OUTPUT_DIR, `${baseName}.roundtrip.lyl`), roundtripLyl);
+        // Step 5: Compare structures
+        const comparison = compareDocuments(doc1, doc2);
+        if (comparison.equal) {
+            return {
+                filename,
+                status: "pass",
+                originalLyl,
+                generatedXml,
+                roundtripLyl
+            };
+        }
+        else {
+            return {
+                filename,
+                status: "fail",
+                error: comparison.diff,
+                originalLyl,
+                generatedXml,
+                roundtripLyl
+            };
+        }
+    }
+    catch (e) {
+        return {
+            filename,
+            status: "error",
+            error: e instanceof Error ? e.message : String(e)
+        };
+    }
+};
+/**
+ * Main test runner
+ */
+const main = async () => {
+    console.log("MusicXML Roundtrip Test\n");
+    console.log("=".repeat(80));
+    // Get all .lyl files in unit-cases
+    const files = fs.readdirSync(UNIT_CASES_DIR)
+        .filter(f => f.endsWith(".lyl"))
+        .sort();
+    console.log(`\nFound ${files.length} test files\n`);
+    const results = [];
+    let passed = 0;
+    let failed = 0;
+    let errors = 0;
+    let skipped = 0;
+    for (const filename of files) {
+        // Check skip list
+        if (SKIP_FILES.has(filename)) {
+            results.push({ filename, status: "skip" });
+            skipped++;
+            console.log(`⏭️  ${filename} (skipped - known limitation)`);
+            continue;
+        }
+        // Run full roundtrip test
+        const result = testRoundtrip(filename);
+        results.push(result);
+        const statusIcon = result.status === "pass" ? "✅" :
+            result.status === "fail" ? "❌" : "⚠️";
+        console.log(`${statusIcon} ${filename}`);
+        if (result.status === "pass") {
+            passed++;
+        }
+        else if (result.status === "fail") {
+            failed++;
+            console.log(`   Diff: ${result.error}`);
+        }
+        else {
+            errors++;
+            console.log(`   Error: ${result.error}`);
+        }
+    }
+    console.log("\n" + "=".repeat(80));
+    console.log(`\nResults: ${passed} passed, ${failed} failed, ${errors} errors, ${skipped} skipped`);
+    console.log(`Output files saved to: ${OUTPUT_DIR}\n`);
+    // Save summary
+    const summary = {
+        total: files.length,
+        passed,
+        failed,
+        errors,
+        skipped,
+        results: results.map(r => ({
+            filename: r.filename,
+            status: r.status,
+            error: r.error
+        }))
+    };
+    fs.writeFileSync(path.join(OUTPUT_DIR, "_summary.json"), JSON.stringify(summary, null, 2));
+    // Exit with error code if any tests failed
+    process.exit(failed + errors > 0 ? 1 : 0);
+};
+main().catch(console.error);

package/lib/tests/musicxml-to-mei.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MusicXML to MEI Conversion - Output to tests/output/from-xml
+ *
+ * Converts all MusicXML test files to MEI and saves to output directory.
+ */
+export {};

package/lib/tests/musicxml-to-mei.js

@@ -0,0 +1,115 @@
+/**
+ * MusicXML to MEI Conversion - Output to tests/output/from-xml
+ *
+ * Converts all MusicXML test files to MEI and saves to output directory.
+ */
+import { musicXmlDecoder, meiEncoder, serializeLilyletDoc } from '../source/lilylet/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+const MUSICXML_DIR = path.join(import.meta.dirname, 'assets/musicxml');
+const OUTPUT_DIR = path.join(import.meta.dirname, 'output/from-xml');
+// Ensure output directory exists
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+function countNotes(doc) {
+    let count = 0;
+    for (const measure of doc.measures) {
+        for (const part of measure.parts) {
+            for (const voice of part.voices) {
+                for (const event of voice.events) {
+                    if (event.type === 'note') {
+                        count += event.pitches.length;
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
+async function convertFile(filename) {
+    const filepath = path.join(MUSICXML_DIR, filename);
+    const baseName = filename.replace('.xml', '');
+    try {
+        // Read and decode MusicXML
+        const xml = fs.readFileSync(filepath, 'utf-8');
+        const doc = musicXmlDecoder.decode(xml);
+        const measures = doc.measures.length;
+        const notes = countNotes(doc);
+        // Save JSON
+        const jsonFile = path.join(OUTPUT_DIR, `${baseName}.json`);
+        fs.writeFileSync(jsonFile, JSON.stringify(doc, null, 2));
+        // Encode to MEI and save
+        const mei = meiEncoder.encode(doc);
+        const meiFile = path.join(OUTPUT_DIR, `${baseName}.mei`);
+        fs.writeFileSync(meiFile, mei);
+        // Serialize to Lilylet (.lyl) and save
+        const lyl = serializeLilyletDoc(doc);
+        const lylFile = path.join(OUTPUT_DIR, `${baseName}.lyl`);
+        fs.writeFileSync(lylFile, lyl);
+        return {
+            name: filename,
+            success: true,
+            measures,
+            notes,
+            meiFile: `${baseName}.mei`,
+            lylFile: `${baseName}.lyl`,
+            jsonFile: `${baseName}.json`,
+        };
+    }
+    catch (error) {
+        return {
+            name: filename,
+            success: false,
+            error: error.message,
+        };
+    }
+}
+async function main() {
+    console.log('MusicXML to MEI Conversion\n');
+    console.log(`Input:  ${MUSICXML_DIR}`);
+    console.log(`Output: ${OUTPUT_DIR}\n`);
+    console.log('='.repeat(80));
+    const files = fs.readdirSync(MUSICXML_DIR).filter(f => f.endsWith('.xml')).sort();
+    const results = [];
+    let passed = 0;
+    let failed = 0;
+    for (const file of files) {
+        const result = await convertFile(file);
+        results.push(result);
+        const status = result.success ? '✅' : '❌';
+        if (result.success) {
+            console.log(`${status} ${file}`);
+            console.log(`   → ${result.meiFile}, ${result.lylFile} (${result.measures} measures, ${result.notes} notes)`);
+            passed++;
+        }
+        else {
+            console.log(`${status} ${file}`);
+            console.log(`   Error: ${result.error}`);
+            failed++;
+        }
+    }
+    console.log('\n' + '='.repeat(80));
+    console.log(`\nConversion complete: ${passed} succeeded, ${failed} failed`);
+    console.log(`Output files in: ${OUTPUT_DIR}`);
+    // Write summary JSON
+    const summaryFile = path.join(OUTPUT_DIR, '_summary.json');
+    fs.writeFileSync(summaryFile, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        inputDir: MUSICXML_DIR,
+        outputDir: OUTPUT_DIR,
+        total: files.length,
+        passed,
+        failed,
+        results,
+    }, null, 2));
+    console.log(`Summary: ${summaryFile}`);
+    // List output files
+    console.log('\nGenerated files:');
+    const outputFiles = fs.readdirSync(OUTPUT_DIR).sort();
+    for (const f of outputFiles) {
+        const stat = fs.statSync(path.join(OUTPUT_DIR, f));
+        console.log(`  ${f} (${(stat.size / 1024).toFixed(1)} KB)`);
+    }
+}
+main();

package/lib/tests/parser.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/parser.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+import * as lilylet from "../source/lilylet.js";
+const parse = (lyl_dir) => {
+    const files = fs.readdirSync(lyl_dir);
+    for (const file of files) {
+        const filePath = `${lyl_dir}/${file}`;
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory())
+            continue;
+        if (!file.endsWith('.lyl'))
+            continue;
+        const code = fs.readFileSync(filePath, { encoding: "utf-8" });
+        lilylet.parseCode(code);
+        console.log(file, "parsing passed.");
+    }
+};
+parse("./tests/assets/unit-cases");

package/lib/tests/render-k283.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/render-k283.js

@@ -0,0 +1,33 @@
+import fs from "fs";
+// @ts-ignore
+import createVerovioModule from "verovio/wasm";
+// @ts-ignore
+import { VerovioToolkit } from "verovio/esm";
+import * as lilylet from "../source/lilylet.js";
+const code = fs.readFileSync("/home/camus/work/openmusictheory-lilylet/Graphics/lilylet/k283.lyl", "utf-8");
+const doc = lilylet.parseCode(code);
+const mei = lilylet.meiEncoder.encode(doc);
+// Save MEI for debugging
+fs.writeFileSync("/home/camus/work/openmusictheory-lilylet/Graphics/lilylet/k283.mei", mei);
+const measureCount = doc.measures?.length || 1;
+let staffCount = 1;
+if (doc.measures.length > 0) {
+    const firstMeasure = doc.measures[0];
+    staffCount = firstMeasure.parts.reduce((total, part) => {
+        const maxStaff = part.voices.reduce((max, voice) => Math.max(max, voice.staff || 1), 1);
+        return total + maxStaff;
+    }, 0) || 1;
+}
+const pageHeight = Math.max(2000, Math.ceil(measureCount / 20) * 2000) * 2 * staffCount;
+console.log(`Measures: ${measureCount}, Staves: ${staffCount}, PageHeight: ${pageHeight}`);
+const VerovioModule = await createVerovioModule();
+const vrvToolkit = new VerovioToolkit(VerovioModule);
+vrvToolkit.setOptions({ scale: 40, adjustPageHeight: true, pageHeight, pageWidth: 2100 });
+const success = vrvToolkit.loadData(mei);
+if (success === false) {
+    console.error("Failed:", vrvToolkit.getLog());
+    process.exit(1);
+}
+const svg = vrvToolkit.renderToSVG(1);
+fs.writeFileSync("/home/camus/work/openmusictheory-lilylet/Graphics/lilylet/k283.svg", svg);
+console.log(`Rendered: ${svg.length} bytes → k283.svg`);

package/lib/tests/render-lyl.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/tests/render-lyl.js

@@ -0,0 +1,35 @@
+import fs from "fs";
+// @ts-ignore
+import createVerovioModule from "verovio/wasm";
+// @ts-ignore
+import { VerovioToolkit } from "verovio/esm";
+import * as lilylet from "../source/lilylet.js";
+const lylPath = process.argv[2];
+if (!lylPath) {
+    console.error("Usage: tsx tests/render-lyl.ts <file.lyl> [output.svg]");
+    process.exit(1);
+}
+const svgPath = process.argv[3] || lylPath.replace(/\.lyl$/, ".svg");
+const code = fs.readFileSync(lylPath, "utf-8");
+const doc = lilylet.parseCode(code);
+const mei = lilylet.meiEncoder.encode(doc);
+const measureCount = doc.measures?.length || 1;
+let staffCount = 1;
+if (doc.measures.length > 0) {
+    const fm = doc.measures[0];
+    staffCount = fm.parts.reduce((t, p) => {
+        const ms = p.voices.reduce((m, v) => Math.max(m, v.staff || 1), 1);
+        return t + ms;
+    }, 0) || 1;
+}
+const pageHeight = Math.max(2000, Math.ceil(measureCount / 20) * 2000) * 2 * staffCount;
+const VM = await createVerovioModule();
+const vt = new VerovioToolkit(VM);
+vt.setOptions({ scale: 40, adjustPageHeight: true, pageHeight, pageWidth: 2100 });
+if (vt.loadData(mei) === false) {
+    console.error("Verovio failed:", vt.getLog());
+    process.exit(1);
+}
+const svg = vt.renderToSVG(1);
+fs.writeFileSync(svgPath, svg);
+console.log("Rendered:", svgPath);

package/lib/tests/unit/afterGraceInsideTuplet.test.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Unit test: \afterGrace / \acciaccatura inside \times 2/3 must NOT leak
+ * notes outside the tuplet wrapper.
+ *
+ * Bug: chopin-25-2.ly measure 68 (voice 1) has the pattern:
+ *
+ *   \times 2/3 { bf8 [ c8 \afterGrace { \acciaccatura { ef8 } df8 ) ] } { c8 } }
+ *
+ * The decoder collects notes backwards when the Tuplet term fires.
+ * The \afterGrace / \acciaccatura emit their notes through a different
+ * listener path that bypasses the flat note stream, so bf8 and c8 remain
+ * in voice.events outside the tuplet while only df8 ends up wrapped.
+ *
+ * Expected (measure 68 has 4 × \times 2/3 { 3 eighth notes }, 2/2 time):
+ *   total duration = 4 × 480 = 1920 ticks  (exactly 2/2)
+ *
+ * Actual (bugged):
+ *   3 correct tuplets (1440) + bf8(240) + c8(240) + \times 2/3{df8}(160)
+ *   = 2080 ticks  →  exceeds 1920 capacity
+ *
+ * Usage: npx tsx tests/unit/afterGraceInsideTuplet.test.ts
+ */
+export {};