@k-l-lambda/lilylet 0.1.63 → 0.1.65

package/lib/tests/mei.js

@@ -0,0 +1,278 @@
+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 initVerovio = async () => {
+    const VerovioModule = await createVerovioModule();
+    return new VerovioToolkit(VerovioModule);
+};
+// Count notes/rests in the source AST, recursing through tuplet/times wrappers.
+const countSourceNotes = (doc) => {
+    let count = 0;
+    const walk = (events) => {
+        for (const e of events) {
+            if (!e)
+                continue;
+            if (e.type === "note" || e.type === "rest")
+                count++;
+            else if (e.type === "tuplet" || e.type === "times")
+                walk(e.events || []);
+            else if (e.type === "tremolo")
+                count += 2;
+        }
+    };
+    for (const m of doc.measures || []) {
+        for (const part of m.parts || []) {
+            for (const voice of part.voices || [])
+                walk(voice.events || []);
+        }
+    }
+    return count;
+};
+// Count <note>/<rest>/<chord>/<mRest>/<mSpace> elements in MEI output (rough but
+// sufficient for detecting silently-dropped event types that produce empty sections).
+const countMeiNotes = (mei) => {
+    const matches = mei.match(/<(note|rest|chord|mRest|mSpace)\b/g);
+    return matches ? matches.length : 0;
+};
+const testFile = async (vrvToolkit, filePath) => {
+    const file = filePath.split("/").pop();
+    try {
+        // Step 1: Parse .lyl file
+        const code = fs.readFileSync(filePath, { encoding: "utf-8" });
+        const doc = lilylet.parseCode(code);
+        // Step 2: Encode to MEI
+        const mei = lilylet.meiEncoder.encode(doc);
+        // Step 2.5: Sanity check — count source notes/rests vs MEI output.
+        // Catches silent drops where an event type is unhandled and MEI ends up empty.
+        const expected = countSourceNotes(doc);
+        const actual = countMeiNotes(mei);
+        if (expected > 0 && actual === 0) {
+            return {
+                file,
+                success: false,
+                error: `MEI output has 0 notes/rests but source has ${expected} (likely an event type is silently dropped)`,
+                mei,
+            };
+        }
+        // Step 3: Calculate pageHeight based on measure count and staff count
+        const measureCount = doc.measures?.length || 1;
+        // Calculate total staff count
+        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 basePageHeight = 2000;
+        const measuresPerPage = 20;
+        const pageHeight = Math.max(basePageHeight, Math.ceil(measureCount / measuresPerPage) * basePageHeight) * 2 * staffCount;
+        // Step 4: Set Verovio options for single-page rendering
+        vrvToolkit.setOptions({
+            scale: 40,
+            adjustPageHeight: true,
+            pageHeight,
+            pageWidth: 2100,
+        });
+        // Step 5: Validate MEI with verovio
+        const success = vrvToolkit.loadData(mei);
+        if (!success) {
+            return {
+                file,
+                success: false,
+                error: "Verovio failed to load MEI data",
+                mei,
+            };
+        }
+        // Step 6: Try to render SVG (further validation)
+        const svg = vrvToolkit.renderToSVG(1);
+        if (!svg || svg.length === 0) {
+            return {
+                file,
+                success: false,
+                error: "Verovio failed to render SVG",
+                mei,
+            };
+        }
+        return {
+            file,
+            success: true,
+            mei,
+            svg,
+        };
+    }
+    catch (err) {
+        return {
+            file,
+            success: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+};
+// Generate index.html gallery
+const generateIndexHtml = (files, outputDir, lylDir) => {
+    // Group files by category (prefix before first dash or hyphen pattern)
+    const getCategory = (file) => {
+        const name = file.replace('.lyl', '');
+        const parts = name.split('-');
+        // Find category: usually first 1-2 parts
+        if (parts.length >= 2) {
+            // Check common patterns
+            if (parts[0] === 'time' && parts[1] === 'signatures')
+                return 'time-signatures';
+            if (parts[0] === 'key' && parts[1] === 'signatures')
+                return 'key-signatures';
+            if (parts[0] === 'basic' && parts[1] === 'notes')
+                return 'basic-notes';
+            if (parts[0] === 'ties' && parts[1] === 'and')
+                return 'ties-and-slurs';
+            if (parts[0] === 'grace' && parts[1] === 'notes')
+                return 'grace-notes';
+            if (parts[0] === 'stem' && parts[1] === 'direction')
+                return 'stem-direction';
+            if (parts[0] === 'multiple' && parts[1] === 'staves')
+                return 'multiple-staves';
+            if (parts[0] === 'multiple' && parts[1] === 'voices')
+                return 'multiple-voices';
+            if (parts[0] === 'multiple' && parts[1] === 'measures')
+                return 'multiple-measures';
+            if (parts[0] === 'multiple' && parts[1] === 'parts')
+                return 'multiple-parts';
+            return parts[0];
+        }
+        return parts[0];
+    };
+    // Escape HTML entities
+    const escHtml = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const categories = [...new Set(files.map(getCategory))].sort();
+    const cards = files.map(file => {
+        const name = file.replace('.lyl', '');
+        const category = getCategory(file);
+        const source = fs.readFileSync(`${lylDir}/${file}`, 'utf-8').trim();
+        return `        <div class="card" data-category="${category}">
+            <div class="card-header">${name} <span class="category">${category}</span></div>
+            <div class="card-source"><code>${escHtml(source)}</code></div>
+            <div class="card-body"><img src="${name}.svg" alt="${name}"></div>
+            <div class="card-footer"><a href="${name}.mei">MEI</a><a href="${name}.svg" target="_blank">SVG</a></div>
+        </div>`;
+    }).join('\n');
+    const filterButtons = categories.map(cat => `<a href="#${cat}" class="filter-btn" data-filter="${cat}">${cat.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}</a>`).join('\n                ');
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Lilylet MEI Test Results</title>
+    <style>
+        * { box-sizing: border-box; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+        h1 { text-align: center; color: #333; margin-bottom: 10px; }
+        .stats { text-align: center; color: #666; margin-bottom: 30px; }
+        .filter-bar { display: flex; justify-content: center; gap: 10px; margin-bottom: 20px; flex-wrap: wrap; }
+        .filter-btn { padding: 8px 16px; border: 1px solid #ddd; background: white; border-radius: 20px; cursor: pointer; font-size: 14px; transition: all 0.2s; text-decoration: none; color: #333; }
+        .filter-btn:hover { background: #e0e0e0; }
+        .filter-btn.active { background: #4a90d9; color: white; border-color: #4a90d9; }
+        .gallery { display: grid; grid-template-columns: repeat(auto-fill, minmax(500px, 1fr)); gap: 20px; }
+        .card { background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); overflow: hidden; }
+        .card.hidden { display: none; }
+        .card-header { padding: 12px 16px; background: #f8f9fa; border-bottom: 1px solid #eee; font-weight: 500; font-size: 14px; }
+        .card-header .category { float: right; font-size: 12px; color: #888; font-weight: normal; }
+        .card-source { padding: 10px 16px; background: #1e1e1e; border-bottom: 1px solid #eee; }
+        .card-source code { font-family: 'SF Mono', 'Fira Code', 'Cascadia Code', Consolas, monospace; font-size: 13px; color: #d4d4d4; white-space: pre-wrap; word-break: break-all; }
+        .card-body { padding: 16px; text-align: center; min-height: 100px; display: flex; align-items: center; justify-content: center; }
+        .card-body img { max-width: 100%; height: auto; }
+        .card-footer { padding: 12px 16px; background: #f8f9fa; border-top: 1px solid #eee; display: flex; gap: 10px; }
+        .card-footer a { color: #4a90d9; text-decoration: none; font-size: 14px; }
+        .card-footer a:hover { text-decoration: underline; }
+    </style>
+</head>
+<body>
+    <h1>Lilylet MEI Test Results</h1>
+    <div class="stats">${files.length} test cases</div>
+    <div class="filter-bar">
+        <a href="#" class="filter-btn active" data-filter="all">All</a>
+                ${filterButtons}
+    </div>
+    <div class="gallery">
+${cards}
+    </div>
+    <script>
+        function applyFilter(filter) {
+            document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));
+            const activeBtn = document.querySelector('.filter-btn[data-filter="' + filter + '"]');
+            if (activeBtn) activeBtn.classList.add('active');
+            document.querySelectorAll('.card').forEach(card => {
+                if (filter === 'all' || card.dataset.category === filter) {
+                    card.classList.remove('hidden');
+                } else {
+                    card.classList.add('hidden');
+                }
+            });
+        }
+        function handleHash() {
+            const hash = window.location.hash.slice(1);
+            applyFilter(hash || 'all');
+        }
+        window.addEventListener('hashchange', handleHash);
+        handleHash();
+    </script>
+</body>
+</html>`;
+    fs.writeFileSync(`${outputDir}/index.html`, html);
+};
+const main = async () => {
+    const lylDir = "./tests/assets/unit-cases";
+    const outputDir = "./tests/output/unit-cases";
+    // Create output directory if not exists
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Initialize verovio
+    console.log("Initializing Verovio...");
+    const vrvToolkit = await initVerovio();
+    console.log("Verovio initialized.\n");
+    // Get all .lyl files
+    const files = fs.readdirSync(lylDir).filter(f => f.endsWith(".lyl"));
+    let passed = 0;
+    let failed = 0;
+    const failures = [];
+    for (const file of files) {
+        const result = await testFile(vrvToolkit, `${lylDir}/${file}`);
+        if (result.success) {
+            console.log(`✓ ${file}`);
+            passed++;
+            // Optionally save MEI and SVG output
+            if (result.mei) {
+                fs.writeFileSync(`${outputDir}/${file.replace(".lyl", ".mei")}`, result.mei);
+            }
+            if (result.svg) {
+                fs.writeFileSync(`${outputDir}/${file.replace(".lyl", ".svg")}`, result.svg);
+            }
+        }
+        else {
+            console.log(`✗ ${file}: ${result.error}`);
+            failed++;
+            failures.push(result);
+            // Save failed MEI for debugging
+            if (result.mei) {
+                fs.writeFileSync(`${outputDir}/${file.replace(".lyl", ".mei.failed")}`, result.mei);
+            }
+        }
+    }
+    console.log(`\n========================================`);
+    console.log(`Total: ${files.length}, Passed: ${passed}, Failed: ${failed}`);
+    if (failures.length > 0) {
+        console.log(`\nFailed tests:`);
+        for (const f of failures) {
+            console.log(`  - ${f.file}: ${f.error}`);
+        }
+        process.exit(1);
+    }
+    // Generate index.html gallery
+    generateIndexHtml(files, outputDir, lylDir);
+};
+main();

package/lib/tests/musicxml-decoder.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Test MusicXML Decoder
+ */
+export {};

package/lib/tests/musicxml-decoder.js

@@ -0,0 +1,61 @@
+/**
+ * Test MusicXML Decoder
+ */
+import { musicXmlDecoder, meiEncoder } from '../source/lilylet/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+const simpleFile = path.join(import.meta.dirname, 'assets/unit-cases/simple.musicxml');
+const complexFile = path.join(import.meta.dirname, 'assets/unit-cases/complex.musicxml');
+async function testFile(filePath, name) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`Testing: ${name}`);
+    console.log('='.repeat(60));
+    const xml = fs.readFileSync(filePath, 'utf-8');
+    const doc = musicXmlDecoder.decode(xml);
+    console.log('\n=== Metadata ===');
+    console.log(doc.metadata);
+    console.log('\n=== Number of measures ===');
+    console.log(doc.measures.length);
+    console.log('\n=== First measure ===');
+    const firstMeasure = doc.measures[0];
+    console.log('Key:', firstMeasure.key);
+    console.log('Time:', firstMeasure.timeSig);
+    const firstVoice = firstMeasure.parts[0]?.voices[0];
+    if (firstVoice) {
+        console.log('Events:', firstVoice.events.length);
+        for (const event of firstVoice.events) {
+            if (event.type === 'note') {
+                const pitches = event.pitches.map(p => `${p.phonet}${p.accidental ? '#' : ''}${p.octave}`).join(',');
+                const marks = event.marks?.map(m => m.markType).join(', ') || 'none';
+                console.log(`  Note: ${pitches}, dur=${event.duration.division}, marks=[${marks}]`);
+            }
+            else if (event.type === 'rest') {
+                console.log(`  Rest: dur=${event.duration.division}`);
+            }
+            else if (event.type === 'context') {
+                console.log(`  Context: clef=${event.clef}`);
+            }
+            else if (event.type === 'barline') {
+                console.log(`  Barline: ${event.style}`);
+            }
+        }
+    }
+    // Encode to MEI
+    const mei = meiEncoder.encode(doc);
+    console.log('\n=== MEI Output (truncated) ===');
+    console.log(mei.split('\n').slice(0, 30).join('\n') + '\n...');
+    return doc;
+}
+async function main() {
+    console.log('Testing MusicXML Decoder...');
+    try {
+        await testFile(simpleFile, 'Simple Test');
+        await testFile(complexFile, 'Complex Test (slurs, dynamics, articulations)');
+        console.log('\n✅ All MusicXML Decoder tests passed!');
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        process.exit(1);
+    }
+}
+main();

package/lib/tests/musicxml-detail.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Detailed examination of MusicXML decoder output
+ */
+export {};

package/lib/tests/musicxml-detail.js

@@ -0,0 +1,85 @@
+/**
+ * Detailed examination of MusicXML decoder output
+ */
+import { musicXmlDecoder, meiEncoder } 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');
+// Test file argument
+const testFile = process.argv[2] || 'complex-02-chopin-etude.xml';
+const filepath = path.join(MUSICXML_DIR, testFile);
+console.log(`Examining: ${testFile}\n`);
+const xml = fs.readFileSync(filepath, 'utf-8');
+const doc = musicXmlDecoder.decode(xml);
+console.log('=== Document Structure ===');
+console.log('Metadata:', doc.metadata);
+console.log('Total measures:', doc.measures.length);
+// First measure
+const m1 = doc.measures[0];
+console.log('\n=== First Measure ===');
+console.log('Key:', m1.key);
+console.log('Time:', m1.timeSig);
+console.log('Parts:', m1.parts.length);
+console.log('Voices:', m1.parts[0].voices.length);
+const v1 = m1.parts[0].voices[0];
+console.log('\nFirst voice events (first 10):');
+for (let i = 0; i < Math.min(10, v1.events.length); i++) {
+    const e = v1.events[i];
+    if (e.type === 'note') {
+        const pitches = e.pitches.map(p => `${p.phonet}${p.accidental || ''}${p.octave}`).join('+');
+        const marks = e.marks?.map(m => m.markType).join(',') || '-';
+        console.log(`  [${i}] Note: ${pitches.padEnd(15)} dur=${e.duration.division.toString().padStart(2)} marks=${marks}`);
+    }
+    else if (e.type === 'rest') {
+        console.log(`  [${i}] Rest: dur=${e.duration.division}`);
+    }
+    else if (e.type === 'context') {
+        const ctx = [];
+        if (e.clef)
+            ctx.push(`clef=${e.clef}`);
+        if (e.stemDirection)
+            ctx.push(`stem=${e.stemDirection}`);
+        if (e.ottava !== undefined)
+            ctx.push(`ottava=${e.ottava}`);
+        console.log(`  [${i}] Context: ${ctx.join(', ')}`);
+    }
+}
+// Count statistics
+let totalNotes = 0;
+let totalRests = 0;
+let totalChords = 0;
+const markCounts = {};
+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') {
+                    totalNotes++;
+                    if (event.pitches.length > 1)
+                        totalChords++;
+                    if (event.marks) {
+                        for (const mark of event.marks) {
+                            markCounts[mark.markType] = (markCounts[mark.markType] || 0) + 1;
+                        }
+                    }
+                }
+                else if (event.type === 'rest') {
+                    totalRests++;
+                }
+            }
+        }
+    }
+}
+console.log('\n=== Statistics ===');
+console.log(`Notes: ${totalNotes}`);
+console.log(`Chords: ${totalChords}`);
+console.log(`Rests: ${totalRests}`);
+console.log('\nMark counts:');
+for (const [mark, count] of Object.entries(markCounts).sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${mark}: ${count}`);
+}
+// Encode to MEI and show snippet
+console.log('\n=== MEI Output (first 40 lines) ===');
+const mei = meiEncoder.encode(doc);
+console.log(mei.split('\n').slice(0, 40).join('\n'));
+console.log('...');

package/lib/tests/musicxml-fprod.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MusicXML Decoder Unit Tests - Real-world fprod files
+ *
+ * Tests the decoder against 10 files from fprod:
+ * - 5 simple (Thompson beginner pieces)
+ * - 3 medium (Thompson intermediate)
+ * - 2 complex (Bach Invention, Chopin Etude)
+ */
+export {};

package/lib/tests/musicxml-fprod.js

@@ -0,0 +1,153 @@
+/**
+ * MusicXML Decoder Unit Tests - Real-world fprod files
+ *
+ * Tests the decoder against 10 files from fprod:
+ * - 5 simple (Thompson beginner pieces)
+ * - 3 medium (Thompson intermediate)
+ * - 2 complex (Bach Invention, Chopin Etude)
+ */
+import { musicXmlDecoder, meiEncoder } 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');
+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;
+}
+function getCategory(filename) {
+    if (filename.startsWith('simple-'))
+        return 'simple';
+    if (filename.startsWith('medium-'))
+        return 'medium';
+    return 'complex';
+}
+async function testFile(filename) {
+    const filepath = path.join(MUSICXML_DIR, filename);
+    const category = getCategory(filename);
+    const warnings = [];
+    // Capture console warnings
+    const originalWarn = console.warn;
+    console.warn = (...args) => {
+        warnings.push(args.join(' '));
+    };
+    try {
+        const xml = fs.readFileSync(filepath, 'utf-8');
+        const doc = musicXmlDecoder.decode(xml);
+        // Validate basic structure
+        if (!doc.measures || doc.measures.length === 0) {
+            throw new Error('No measures found in decoded document');
+        }
+        const notes = countNotes(doc);
+        if (notes === 0) {
+            throw new Error('No notes found in decoded document');
+        }
+        // Try encoding to MEI
+        const mei = meiEncoder.encode(doc);
+        if (!mei.includes('<mei')) {
+            throw new Error('MEI encoding failed - no mei tag found');
+        }
+        console.warn = originalWarn;
+        return {
+            name: filename,
+            category,
+            success: true,
+            measures: doc.measures.length,
+            notes,
+            warnings,
+        };
+    }
+    catch (error) {
+        console.warn = originalWarn;
+        return {
+            name: filename,
+            category,
+            success: false,
+            measures: 0,
+            notes: 0,
+            error: error.message,
+            warnings,
+        };
+    }
+}
+async function main() {
+    console.log('MusicXML Decoder Unit Tests - fprod files\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 testFile(file);
+        results.push(result);
+        const status = result.success ? '✅' : '❌';
+        const stats = result.success
+            ? `measures=${result.measures}, notes=${result.notes}`
+            : `error: ${result.error}`;
+        console.log(`${status} [${result.category.padEnd(7)}] ${result.name}`);
+        console.log(`   ${stats}`);
+        if (result.warnings.length > 0) {
+            console.log(`   ⚠️  ${result.warnings.length} warnings`);
+        }
+        if (result.success) {
+            passed++;
+        }
+        else {
+            failed++;
+        }
+    }
+    console.log('\n' + '='.repeat(80));
+    console.log('Summary:');
+    console.log(`  Total:  ${files.length}`);
+    console.log(`  Passed: ${passed} ✅`);
+    console.log(`  Failed: ${failed} ❌`);
+    // Group by category
+    const byCategory = {
+        simple: results.filter(r => r.category === 'simple'),
+        medium: results.filter(r => r.category === 'medium'),
+        complex: results.filter(r => r.category === 'complex'),
+    };
+    console.log('\nBy Category:');
+    for (const [cat, catResults] of Object.entries(byCategory)) {
+        const catPassed = catResults.filter(r => r.success).length;
+        console.log(`  ${cat}: ${catPassed}/${catResults.length}`);
+    }
+    // Show failed tests
+    const failedTests = results.filter(r => !r.success);
+    if (failedTests.length > 0) {
+        console.log('\nFailed Tests:');
+        for (const test of failedTests) {
+            console.log(`  ❌ ${test.name}: ${test.error}`);
+        }
+    }
+    // Statistics for successful tests
+    const successfulTests = results.filter(r => r.success);
+    if (successfulTests.length > 0) {
+        const totalMeasures = successfulTests.reduce((sum, r) => sum + r.measures, 0);
+        const totalNotes = successfulTests.reduce((sum, r) => sum + r.notes, 0);
+        console.log('\nStatistics (successful tests):');
+        console.log(`  Total measures: ${totalMeasures}`);
+        console.log(`  Total notes: ${totalNotes}`);
+        console.log(`  Avg measures/file: ${(totalMeasures / successfulTests.length).toFixed(1)}`);
+        console.log(`  Avg notes/file: ${(totalNotes / successfulTests.length).toFixed(1)}`);
+    }
+    console.log('\n' + '='.repeat(80));
+    if (failed > 0) {
+        console.log(`\n❌ ${failed} test(s) failed`);
+        process.exit(1);
+    }
+    else {
+        console.log('\n✅ All tests passed!');
+    }
+}
+main();

package/lib/tests/musicxml-roundtrip.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MusicXML Roundtrip Test
+ *
+ * Tests the lilylet -> musicxml -> lilylet conversion cycle.
+ * Compares the output of two conversions to verify consistency.
+ */
+export {};