@k-l-lambda/lilylet 0.1.71 → 0.1.72

package/lib/tests/unit/partialWarning.test.js

@@ -1,65 +0,0 @@
-/**
- * Unit tests for \partial syntax — duration check and warning emission.
- */
-import { parseCode, getParseWarnings } from '../../source/lilylet/index.js';
-let passed = 0;
-let failed = 0;
-const test = (name, fn) => {
-    try {
-        fn();
-        console.log(`  ✓ ${name}`);
-        passed++;
-    }
-    catch (e) {
-        console.log(`  ✗ ${name}: ${e}`);
-        failed++;
-    }
-};
-const assert = (cond, msg) => {
-    if (!cond)
-        throw new Error(msg);
-};
-console.log('\n\\partial warning tests\n' + '─'.repeat(40));
-// ── 1. Correct usage: \partial 8 with one eighth note ─────────────────────
-parseCode('\\staff "1" \\time 2/4 \\partial 8 b8 | %1\n\\staff "1" \\time 2/4 c4 c | %2');
-test('no warning when partial matches voice duration (eighth)', () => {
-    const w = getParseWarnings();
-    assert(w.length === 0, `expected 0 warnings, got ${w.length}: ${JSON.stringify(w)}`);
-});
-// ── 2. Mismatch: \partial 8 but voice has a quarter note (480 ≠ 240) ──────
-parseCode('\\staff "1" \\time 2/4 \\partial 8 c4 | %1\n\\staff "1" \\time 2/4 c4 c | %2');
-test('warning when partial declares 8 but voice has quarter note', () => {
-    const w = getParseWarnings();
-    assert(w.length === 1, `expected 1 warning, got ${w.length}`);
-    assert(w[0].type === 'partial-mismatch', 'wrong type');
-    assert(w[0].declared === 240, `declared=${w[0].declared}`);
-    assert(w[0].actual === 480, `actual=${w[0].actual}`);
-});
-// ── 3. Dotted partial: \partial 4. with c4 c8 (720 ticks each) ───────────
-parseCode('\\staff "1" \\time 3/4 \\partial 4. c4 c8 | %1\n\\staff "1" \\time 3/4 c4 c c | %2');
-test('no warning for dotted \partial 4. with matching 720-tick voice', () => {
-    const w = getParseWarnings();
-    assert(w.length === 0, `expected 0 warnings, got ${w.length}`);
-});
-// ── 4. Partial stored as context event and measure.partial set ────────────
-const doc = parseCode('\\staff "1" \\time 2/4 \\partial 8 b8 | %1\n\\staff "1" \\time 2/4 c4 c | %2');
-test('\\partial creates context event with partial duration', () => {
-    const voice = doc.measures[0].parts[0].voices[0];
-    const partialCtx = voice.events.find(e => e.type === 'context' && e.partial);
-    assert(!!partialCtx, 'no partial context event found');
-    assert(partialCtx.partial.division === 8, 'wrong division');
-    assert((partialCtx.partial.dots || 0) === 0, 'wrong dots');
-});
-test('measure.partial is true when \\partial is declared', () => {
-    assert(doc.measures[0].partial === true, 'measure.partial not true');
-    assert(!doc.measures[1].partial, 'second measure should not be partial');
-});
-// ── 5. No warning for spacer-only voice ───────────────────────────────────
-parseCode('\\staff "1" \\time 2/4 \\partial 8 b8 \\\\\n\\staff "1" s8 | %1\n\\staff "1" \\time 2/4 c4 c | %2');
-test('no warning for spacer-only voice even if it has different ticks', () => {
-    const w = getParseWarnings();
-    assert(w.length === 0, `expected 0 warnings, got ${w.length}`);
-});
-console.log('\n' + '─'.repeat(40));
-console.log(`Results: ${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);

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

@@ -1,8 +0,0 @@
-/**
- * Round-trip test for Lilylet serializer
- *
- * Loads LilyletDoc JSON -> serializes to .lyl -> parses back -> compares
- *
- * Usage: npx ts-node tests/unit/serializerRoundTrip.test.ts [json-dir] [max-files]
- */
-export {};

package/lib/tests/unit/serializerRoundTrip.test.js

@@ -1,263 +0,0 @@
-/**
- * Round-trip test for Lilylet serializer
- *
- * Loads LilyletDoc JSON -> serializes to .lyl -> parses back -> compares
- *
- * Usage: npx ts-node tests/unit/serializerRoundTrip.test.ts [json-dir] [max-files]
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseCode } from "../../source/lilylet/parser.js";
-import { serializeLilyletDoc } from "../../source/lilylet/serializer.js";
-// Get args
-const args = process.argv.slice(2);
-const JSON_DIR = args[0] || './tests/output/from-ly';
-const MAX_FILES = parseInt(args[1] || '0', 10); // 0 = all files
-/**
- * Check if a context change event is effectively empty
- * (created by \staff command which doesn't set any context properties)
- */
-const isEmptyContextChange = (event) => {
-    if (event.type !== 'context')
-        return false;
-    const ctx = event;
-    return !ctx.clef && !ctx.key && !ctx.time && !ctx.tempo &&
-        ctx.ottava === undefined && !ctx.stemDirection;
-};
-/**
- * Check if a context change only has key or time (from measure-level serialization)
- */
-const isKeyOrTimeOnlyContext = (event) => {
-    if (event.type !== 'context')
-        return false;
-    const ctx = event;
-    // Only has key or time, nothing else
-    const hasKey = !!ctx.key;
-    const hasTime = !!ctx.time;
-    const hasOther = !!ctx.clef || !!ctx.tempo || ctx.ottava !== undefined || !!ctx.stemDirection;
-    return (hasKey || hasTime) && !hasOther;
-};
-/**
- * Check if an event is a space rest (invisible rest, used for empty measures)
- */
-const isSpaceRest = (event) => {
-    if (event.type !== 'rest')
-        return false;
-    const rest = event;
-    return !!rest.invisible;
-};
-/**
- * Filter out empty context changes and key/time-only context changes from events array
- * Key/time context changes may come from measure-level properties during serialization
- * Also filters space rests that were added to preserve empty measures
- */
-const filterEvents = (events, isFirstMeasure = false, filterSpaceRests = false) => {
-    return events.filter(e => {
-        if (isEmptyContextChange(e))
-            return false;
-        // In first measure, key/time context events may come from measure properties
-        if (isFirstMeasure && isKeyOrTimeOnlyContext(e))
-            return false;
-        // Filter space rests if requested (for comparing with originally empty voices)
-        if (filterSpaceRests && isSpaceRest(e))
-            return false;
-        return true;
-    });
-};
-/**
- * Deep comparison of two LilyletDoc objects
- * Returns list of differences found
- */
-const compareDocs = (original, roundTrip) => {
-    const diffs = [];
-    // Compare measure count
-    if (original.measures.length !== roundTrip.measures.length) {
-        diffs.push(`Measure count: ${original.measures.length} vs ${roundTrip.measures.length}`);
-        return diffs; // Can't compare further if measure counts differ
-    }
-    // Compare each measure
-    for (let m = 0; m < original.measures.length; m++) {
-        const origMeasure = original.measures[m];
-        const rtMeasure = roundTrip.measures[m];
-        // Compare parts count
-        if (origMeasure.parts.length !== rtMeasure.parts.length) {
-            diffs.push(`Measure ${m + 1}: part count ${origMeasure.parts.length} vs ${rtMeasure.parts.length}`);
-            continue;
-        }
-        // Compare each part
-        for (let p = 0; p < origMeasure.parts.length; p++) {
-            const origPart = origMeasure.parts[p];
-            const rtPart = rtMeasure.parts[p];
-            // Compare voice count
-            if (origPart.voices.length !== rtPart.voices.length) {
-                diffs.push(`Measure ${m + 1}, Part ${p + 1}: voice count ${origPart.voices.length} vs ${rtPart.voices.length}`);
-                continue;
-            }
-            // Compare each voice
-            for (let v = 0; v < origPart.voices.length; v++) {
-                const origVoice = origPart.voices[v];
-                const rtVoice = rtPart.voices[v];
-                // Filter out empty context changes (created by \staff command)
-                // Also filter key/time context in first measure (from measure properties)
-                const isFirstMeasure = m === 0;
-                // If original voice was empty, filter space rests from round-trip
-                // (they were added to preserve empty measures)
-                const origWasEmpty = origVoice.events.length === 0;
-                const origEvents = filterEvents(origVoice.events, isFirstMeasure, false);
-                const rtEvents = filterEvents(rtVoice.events, isFirstMeasure, origWasEmpty);
-                // Compare staff (skip for empty voices - staff number is semantically irrelevant)
-                const voiceIsEmpty = origEvents.length === 0 && rtEvents.length === 0;
-                if (origVoice.staff !== rtVoice.staff && !voiceIsEmpty) {
-                    diffs.push(`Measure ${m + 1}, Part ${p + 1}, Voice ${v + 1}: staff ${origVoice.staff} vs ${rtVoice.staff}`);
-                }
-                // Compare event count
-                if (origEvents.length !== rtEvents.length) {
-                    diffs.push(`Measure ${m + 1}, Part ${p + 1}, Voice ${v + 1}: event count ${origEvents.length} vs ${rtEvents.length}`);
-                    continue;
-                }
-                // Compare each event
-                for (let e = 0; e < origEvents.length; e++) {
-                    const origEvent = origEvents[e];
-                    const rtEvent = rtEvents[e];
-                    const eventDiffs = compareEvents(origEvent, rtEvent, `M${m + 1}P${p + 1}V${v + 1}E${e + 1}`);
-                    diffs.push(...eventDiffs);
-                }
-            }
-        }
-    }
-    return diffs;
-};
-/**
- * Compare two events
- */
-const compareEvents = (orig, rt, location) => {
-    const diffs = [];
-    // Compare type
-    if (orig.type !== rt.type) {
-        diffs.push(`${location}: type ${orig.type} vs ${rt.type}`);
-        return diffs;
-    }
-    if (orig.type === 'note' && rt.type === 'note') {
-        const origNote = orig;
-        const rtNote = rt;
-        // Compare pitch count
-        if (origNote.pitches.length !== rtNote.pitches.length) {
-            diffs.push(`${location}: pitch count ${origNote.pitches.length} vs ${rtNote.pitches.length}`);
-        }
-        else {
-            // Compare each pitch
-            for (let i = 0; i < origNote.pitches.length; i++) {
-                const origPitch = origNote.pitches[i];
-                const rtPitch = rtNote.pitches[i];
-                if (origPitch.phonet !== rtPitch.phonet) {
-                    diffs.push(`${location}: pitch[${i}] phonet ${origPitch.phonet} vs ${rtPitch.phonet}`);
-                }
-                if (origPitch.octave !== rtPitch.octave) {
-                    diffs.push(`${location}: pitch[${i}] octave ${origPitch.octave} vs ${rtPitch.octave}`);
-                }
-                // Compare accidentals (normalize undefined to no accidental)
-                const origAcc = origPitch.accidental || null;
-                const rtAcc = rtPitch.accidental || null;
-                if (origAcc !== rtAcc) {
-                    diffs.push(`${location}: pitch[${i}] accidental ${origAcc} vs ${rtAcc}`);
-                }
-            }
-        }
-        // Compare duration
-        if (origNote.duration.division !== rtNote.duration.division) {
-            diffs.push(`${location}: duration division ${origNote.duration.division} vs ${rtNote.duration.division}`);
-        }
-        if (origNote.duration.dots !== rtNote.duration.dots) {
-            diffs.push(`${location}: duration dots ${origNote.duration.dots} vs ${rtNote.duration.dots}`);
-        }
-    }
-    if (orig.type === 'rest' && rt.type === 'rest') {
-        const origRest = orig;
-        const rtRest = rt;
-        // Compare duration
-        if (origRest.duration.division !== rtRest.duration.division) {
-            diffs.push(`${location}: duration division ${origRest.duration.division} vs ${rtRest.duration.division}`);
-        }
-        if (origRest.duration.dots !== rtRest.duration.dots) {
-            diffs.push(`${location}: duration dots ${origRest.duration.dots} vs ${rtRest.duration.dots}`);
-        }
-        // Compare rest type flags
-        if (!!origRest.invisible !== !!rtRest.invisible) {
-            diffs.push(`${location}: invisible ${origRest.invisible} vs ${rtRest.invisible}`);
-        }
-        if (!!origRest.fullMeasure !== !!rtRest.fullMeasure) {
-            diffs.push(`${location}: fullMeasure ${origRest.fullMeasure} vs ${rtRest.fullMeasure}`);
-        }
-    }
-    return diffs;
-};
-/**
- * Run round-trip test on a single JSON file
- */
-const testRoundTrip = (jsonPath) => {
-    // Load original JSON
-    const jsonContent = fs.readFileSync(jsonPath, 'utf-8');
-    const original = JSON.parse(jsonContent);
-    // Serialize to .lyl
-    const lylContent = serializeLilyletDoc(original);
-    // Parse back to LilyletDoc
-    const roundTrip = parseCode(lylContent);
-    // Compare
-    const diffs = compareDocs(original, roundTrip);
-    return {
-        success: diffs.length === 0,
-        diffs,
-        lylLength: lylContent.length,
-    };
-};
-const main = async () => {
-    console.log(`Round-trip test: JSON -> .lyl -> JSON`);
-    console.log(`JSON directory: ${JSON_DIR}\n`);
-    // Find JSON files (exclude _summary.json)
-    let jsonFiles = fs.readdirSync(JSON_DIR)
-        .filter(f => f.endsWith('.json') && !f.startsWith('_'))
-        .map(f => path.join(JSON_DIR, f));
-    if (MAX_FILES > 0) {
-        jsonFiles = jsonFiles.slice(0, MAX_FILES);
-    }
-    console.log(`Found ${jsonFiles.length} JSON files to test\n`);
-    let passed = 0;
-    let failed = 0;
-    const failures = [];
-    for (let i = 0; i < jsonFiles.length; i++) {
-        const jsonPath = jsonFiles[i];
-        const filename = path.basename(jsonPath);
-        try {
-            const result = testRoundTrip(jsonPath);
-            if (result.success) {
-                console.log(`[${i + 1}/${jsonFiles.length}] ✓ ${filename} (${result.lylLength} chars)`);
-                passed++;
-            }
-            else {
-                console.log(`[${i + 1}/${jsonFiles.length}] ✗ ${filename} (${result.diffs.length} diffs)`);
-                failed++;
-                failures.push({ file: filename, diffs: result.diffs.slice(0, 5) }); // Keep first 5 diffs
-            }
-        }
-        catch (e) {
-            console.log(`[${i + 1}/${jsonFiles.length}] ✗ ${filename}: ${e.message.slice(0, 80)}`);
-            failed++;
-            failures.push({ file: filename, diffs: [e.message.slice(0, 200)] });
-        }
-    }
-    console.log('\n========================================');
-    console.log(`Total: ${jsonFiles.length}, Passed: ${passed}, Failed: ${failed}`);
-    // Show failure details
-    if (failures.length > 0) {
-        console.log('\n--- Failure Details (first 10) ---');
-        for (const f of failures.slice(0, 10)) {
-            console.log(`\n${f.file}:`);
-            for (const diff of f.diffs) {
-                console.log(`  - ${diff}`);
-            }
-        }
-    }
-    // Exit with error code if there are failures
-    process.exit(failed > 0 ? 1 : 0);
-};
-main().catch(console.error);

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

@@ -1,25 +0,0 @@
-/**
- * Unit test: \staff "N" inside \tuplet / \times blocks is preserved in the AST.
- *
- * Regression guard for the bug in grammar.jison.js where tuplet/times event
- * construction filters events to only 'note' | 'rest', silently dropping any
- * 'context' events (including \staff "N") that appear inside the block.
- *
- * Real-world case: Chopin Op.28 No.1 (chopin--chopin-28-1.lyl) — the bass voice
- * uses cross-staff beaming where melody notes are physically in the treble range.
- * Placing \staff "1" inside a \tuplet block to switch staff mid-tuplet has no
- * effect because the parser drops the context event before expandVoice ever sees
- * it.  intelli-piano/spartitoMeasure.ts expandVoice already contains correct
- * handling for context events inside tuplets, but it is unreachable due to this
- * parser bug.
- *
- * Bug location: source/lilylet/grammar.jison.js lines ~344-347
- *   timesEvent:  $$[$0-1].filter(e => e.type === 'note' || e.type === 'rest')
- *   tupletEvent: $$[$0-1].filter(e => e.type === 'note' || e.type === 'rest')
- *
- * Fix: extend the filter to also keep 'context' events:
- *   .filter(e => e.type === 'note' || e.type === 'rest' || e.type === 'context')
- *
- * Usage: npx tsx tests/unit/staffInsideTuplet.test.ts
- */
-export {};

package/lib/tests/unit/staffInsideTuplet.test.js

@@ -1,133 +0,0 @@
-/**
- * Unit test: \staff "N" inside \tuplet / \times blocks is preserved in the AST.
- *
- * Regression guard for the bug in grammar.jison.js where tuplet/times event
- * construction filters events to only 'note' | 'rest', silently dropping any
- * 'context' events (including \staff "N") that appear inside the block.
- *
- * Real-world case: Chopin Op.28 No.1 (chopin--chopin-28-1.lyl) — the bass voice
- * uses cross-staff beaming where melody notes are physically in the treble range.
- * Placing \staff "1" inside a \tuplet block to switch staff mid-tuplet has no
- * effect because the parser drops the context event before expandVoice ever sees
- * it.  intelli-piano/spartitoMeasure.ts expandVoice already contains correct
- * handling for context events inside tuplets, but it is unreachable due to this
- * parser bug.
- *
- * Bug location: source/lilylet/grammar.jison.js lines ~344-347
- *   timesEvent:  $$[$0-1].filter(e => e.type === 'note' || e.type === 'rest')
- *   tupletEvent: $$[$0-1].filter(e => e.type === 'note' || e.type === 'rest')
- *
- * Fix: extend the filter to also keep 'context' events:
- *   .filter(e => e.type === 'note' || e.type === 'rest' || e.type === 'context')
- *
- * Usage: npx tsx tests/unit/staffInsideTuplet.test.ts
- */
-import { parseCode } from "../../source/lilylet/parser.js";
-// ─── helpers ────────────────────────────────────────────────────────────────
-let passed = 0;
-let failed = 0;
-function assert(condition, message) {
-    if (condition) {
-        console.log(`  ✓ ${message}`);
-        passed++;
-    }
-    else {
-        console.error(`  ✗ FAIL: ${message}`);
-        failed++;
-    }
-}
-/**
- * Walk voice events (including inside tuplets), tracking activeStaff from
- * context { staff } events.  Returns [{phonet, staff}] for each note.
- */
-function getNoteStaffs(voice) {
-    let activeStaff = voice.staff;
-    const result = [];
-    function walkEvents(events) {
-        for (const e of events) {
-            if (e.type === 'context' && e.staff)
-                activeStaff = e.staff;
-            else if (e.type === 'note')
-                result.push({ phonet: e.pitches[0].phonet, staff: activeStaff });
-            else if (e.type === 'tuplet' || e.type === 'times')
-                walkEvents(e.events || []);
-        }
-    }
-    walkEvents(voice.events);
-    return result;
-}
-/**
- * Find a tuplet/times event in a voice and return its events array.
- */
-function getTupletEvents(voice) {
-    for (const e of voice.events) {
-        if (e.type === 'tuplet' || e.type === 'times')
-            return e.events || [];
-    }
-    return null;
-}
-// ─── test 1: \staff "N" inside \tuplet ──────────────────────────────────────
-console.log('\nTest 1: \\staff "N" inside \\tuplet 3/2');
-console.log('─'.repeat(50));
-// A single voice: starts on staff 2, then \staff "1" inside the tuplet
-// switches to staff 1 for notes g and c.
-//   a (staff=2), g (staff=1), c (staff=1)
-const LYL_TUPLET = `
-\\staff "2" \\tuplet 3/2 { a16 \\staff "1" g c } |
-`;
-{
-    const doc = parseCode(LYL_TUPLET);
-    const voice = doc.measures[0]?.parts[0]?.voices[0];
-    assert(!!voice, 'measure 0 voice 0 exists');
-    const tupletEvents = getTupletEvents(voice);
-    assert(tupletEvents !== null, 'voice contains a tuplet event');
-    // The bug: context event is filtered out — tupletEvents has no 'context'
-    const hasContextEvent = tupletEvents?.some(e => e.type === 'context' && e.staff === 1) ?? false;
-    assert(hasContextEvent, 'tuplet events array contains context { staff: 1 }');
-    const noteStaffs = getNoteStaffs(voice);
-    assert(noteStaffs.length === 3, `3 notes found (got ${noteStaffs.length})`);
-    assert(noteStaffs[0]?.phonet === 'a' && noteStaffs[0]?.staff === 2, `note "a" on staff 2 (got staff=${noteStaffs[0]?.staff})`);
-    assert(noteStaffs[1]?.phonet === 'g' && noteStaffs[1]?.staff === 1, `note "g" on staff 1 after \\staff "1" (got staff=${noteStaffs[1]?.staff})`);
-    assert(noteStaffs[2]?.phonet === 'c' && noteStaffs[2]?.staff === 1, `note "c" on staff 1 (got staff=${noteStaffs[2]?.staff})`);
-}
-// ─── test 2: \staff "N" inside \times ───────────────────────────────────────
-console.log('\nTest 2: \\staff "N" inside \\times 2/3');
-console.log('─'.repeat(50));
-const LYL_TIMES = `
-\\staff "2" \\times 2/3 { a16 \\staff "1" g c } |
-`;
-{
-    const doc = parseCode(LYL_TIMES);
-    const voice = doc.measures[0]?.parts[0]?.voices[0];
-    assert(!!voice, 'measure 0 voice 0 exists');
-    const tupletEvents = getTupletEvents(voice);
-    assert(tupletEvents !== null, 'voice contains a times event');
-    const hasContextEvent = tupletEvents?.some(e => e.type === 'context' && e.staff === 1) ?? false;
-    assert(hasContextEvent, 'times events array contains context { staff: 1 }');
-    const noteStaffs = getNoteStaffs(voice);
-    assert(noteStaffs.length === 3, `3 notes found (got ${noteStaffs.length})`);
-    assert(noteStaffs[1]?.phonet === 'g' && noteStaffs[1]?.staff === 1, `note "g" on staff 1 after \\staff "1" (got staff=${noteStaffs[1]?.staff})`);
-}
-// ─── test 3: \staff "N" at voice level before tuplet (should already work) ──
-console.log('\nTest 3: \\staff "N" at voice level before \\tuplet (baseline)');
-console.log('─'.repeat(50));
-// \staff "1" at voice level — should already work
-const LYL_VOICE_LEVEL = `
-\\staff "2" \\staff "1" \\tuplet 3/2 { a16 g c } |
-`;
-{
-    const doc = parseCode(LYL_VOICE_LEVEL);
-    const voice = doc.measures[0]?.parts[0]?.voices[0];
-    assert(!!voice, 'measure 0 voice 0 exists');
-    // Voice-level context events are NOT inside the tuplet
-    const hasVoiceLevelContext = voice.events.some(e => e.type === 'context' && e.staff === 1);
-    assert(hasVoiceLevelContext, 'voice has a context { staff: 1 } event at voice level');
-    const noteStaffs = getNoteStaffs(voice);
-    assert(noteStaffs.length === 3, `3 notes found`);
-    assert(noteStaffs[0]?.staff === 1, `all notes on staff 1 (got ${noteStaffs[0]?.staff})`);
-}
-// ─── summary ────────────────────────────────────────────────────────────────
-console.log('');
-console.log(`Results: ${passed} passed, ${failed} failed`);
-if (failed > 0)
-    process.exit(1);

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

@@ -1,16 +0,0 @@
-/**
- * Regression test: first note of a \times tuplet must NOT escape outside the
- * tuplet block when there are context events (e.g. \tempo, dynamics) between
- * the first and second note.
- *
- * Bug: serializer emitted the first note before the \times 4/6 { } wrapper when
- * that note was followed by a \tempo or dynamic context change inside the tuplet.
- *
- * Minimal reproduction from chopin--chopin-25-11.ly measure 5:
- *   \times 4/6 { f'''16 _\f \tempo ... c16 e a, ds c }
- * incorrectly serialized as:
- *   f'''16(\f[ \tempo ... \times 4/6 { c16 e a, ds c }   ← only 5 notes!
- *
- * Usage: npx tsx tests/unit/timesFirstNoteEscape.test.ts
- */
-export {};

package/lib/tests/unit/timesFirstNoteEscape.test.js

@@ -1,152 +0,0 @@
-/**
- * Regression test: first note of a \times tuplet must NOT escape outside the
- * tuplet block when there are context events (e.g. \tempo, dynamics) between
- * the first and second note.
- *
- * Bug: serializer emitted the first note before the \times 4/6 { } wrapper when
- * that note was followed by a \tempo or dynamic context change inside the tuplet.
- *
- * Minimal reproduction from chopin--chopin-25-11.ly measure 5:
- *   \times 4/6 { f'''16 _\f \tempo ... c16 e a, ds c }
- * incorrectly serialized as:
- *   f'''16(\f[ \tempo ... \times 4/6 { c16 e a, ds c }   ← only 5 notes!
- *
- * Usage: npx tsx tests/unit/timesFirstNoteEscape.test.ts
- */
-import { decode } from "../../source/lilylet/lilypondDecoder.js";
-import { serializeLilyletDoc } from "../../source/lilylet/serializer.js";
-import { parseCode } from "../../source/lilylet/parser.js";
-// ─── helpers ────────────────────────────────────────────────────────────────
-let passed = 0;
-let failed = 0;
-function assert(condition, message) {
-    if (condition) {
-        console.log(`  ✓ ${message}`);
-        passed++;
-    }
-    else {
-        console.error(`  ✗ FAIL: ${message}`);
-        failed++;
-    }
-}
-function countNotesInTuplets(lyl) {
-    // Count notes that appear inside \times N/M { } blocks
-    // A note outside would appear before \times
-    const doc = parseCode(lyl);
-    let count = 0;
-    for (const m of doc.measures) {
-        for (const p of m.parts) {
-            for (const v of p.voices) {
-                for (const e of v.events) {
-                    if (e.type === 'times' || e.type === 'tuplet') {
-                        count += (e.events ?? []).filter((te) => te.type === 'note').length;
-                    }
-                }
-            }
-        }
-    }
-    return count;
-}
-const LY_BOILERPLATE = `
-\\version "2.22.0"
-\\language "english"
-\\header { tagline = ##f }
-#(set-global-staff-size 20)
-\\paper { paper-width = 210\\mm paper-height = 297\\mm ragged-last = ##t }
-\\layout { \\context { \\Score autoBeaming = ##f } }
-`;
-// Warm-up
-{
-    const w = console.warn, a = console.assert;
-    console.warn = () => { };
-    console.assert = () => { };
-    try {
-        await decode('{ c }');
-    }
-    catch { }
-    console.warn = w;
-    console.assert = a;
-}
-// ─── Test 1: \tempo inside tuplet — first note must stay inside ─────────────
-console.log('\nTest 1: \\tempo inside \\times tuplet — all 6 notes must be in tuplet');
-const LY_TEMPO_IN_TUPLET = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c'' {
-        \\time 4/4 \\clef treble
-        \\once \\omit TupletNumber \\times 4/6 {
-          f'''16 \\tempo "Allegro" 2=69 c16 e16 a,16 ds16 c16
-        }
-        r2. |  % 1
-      }
-    }
-  >>
-  \\layout { }
-}
-`;
-await (async () => {
-    const doc = await decode(LY_TEMPO_IN_TUPLET);
-    const lyl = serializeLilyletDoc(doc);
-    // Count notes inside tuplets in serialized lyl
-    const notesInTuplet = countNotesInTuplets(lyl);
-    assert(notesInTuplet === 6, `All 6 notes inside tuplet (got ${notesInTuplet}) — first note must not escape before \\times`);
-    // Also verify no note appears before \times in lyl text
-    // The lyl should not start a measure with a note before \times
-    const firstMeasureLine = lyl.split('\n').find(l => l.includes('f\'\'\''));
-    if (firstMeasureLine) {
-        const timesIdx = firstMeasureLine.indexOf('\\times');
-        const fIdx = firstMeasureLine.indexOf("f'''");
-        assert(timesIdx < fIdx || timesIdx === -1, `\\times appears before f''' in serialized line (timesIdx=${timesIdx} fIdx=${fIdx})`);
-    }
-    console.log(`  lyl: ${lyl.split('\n').find(l => l.includes("f'''") || l.includes('\\times')) ?? '(not found)'}`);
-})();
-// ─── Test 2: dynamic (_\f) inside tuplet — first note must stay inside ──────
-console.log('\nTest 2: dynamic \\f inside \\times tuplet — all 4 notes must be in tuplet');
-const LY_DYN_IN_TUPLET = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' {
-        \\time 4/4 \\clef treble
-        \\times 2/3 { c8\\f d e } \\times 2/3 { f8 g a } r2 |  % 1
-      }
-    }
-  >>
-  \\layout { }
-}
-`;
-await (async () => {
-    const doc = await decode(LY_DYN_IN_TUPLET);
-    const lyl = serializeLilyletDoc(doc);
-    const notesInTuplet = countNotesInTuplets(lyl);
-    assert(notesInTuplet === 6, `All 6 notes (3+3) inside tuplets (got ${notesInTuplet})`);
-})();
-// ─── Test 3: round-trip — tuplet note count preserved ────────────────────────
-console.log('\nTest 3: round-trip note count inside \\times preserved');
-await (async () => {
-    const doc = await decode(LY_TEMPO_IN_TUPLET);
-    const lyl = serializeLilyletDoc(doc);
-    const docRT = parseCode(lyl);
-    let totalNotes = 0;
-    for (const m of docRT.measures) {
-        for (const p of m.parts) {
-            for (const v of p.voices) {
-                for (const e of v.events) {
-                    if (e.type === 'times' || e.type === 'tuplet') {
-                        totalNotes += (e.events ?? []).filter((te) => te.type === 'note').length;
-                    }
-                    if (e.type === 'note')
-                        totalNotes++; // notes outside tuplets
-                }
-            }
-        }
-    }
-    assert(totalNotes >= 6, `Round-trip: at least 6 notes present (got ${totalNotes})`);
-})();
-// ─── Summary ─────────────────────────────────────────────────────────────────
-console.log(`\n${'═'.repeat(40)}`);
-if (failed > 0)
-    console.log(`⚠️  ${failed} FAILED — first note of \\times tuplet escaping outside`);
-console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
-process.exit(failed > 0 ? 1 : 0);