@k-l-lambda/lilylet 0.1.71 → 0.1.73

package/lib/tests/auto-beam.js

@@ -1,151 +0,0 @@
-/**
- * Test: Auto-beam on/off/auto modes
- *
- * Verifies that the autoBeam metadata option controls beam generation:
- * - 'off': never auto-beam, even without manual beams
- * - 'on': always auto-beam, even when manual beams exist
- * - 'auto' / undefined: auto-beam only if no manual beam marks in source
- */
-import { parseCode, meiEncoder } from "../source/lilylet/index.js";
-let passed = 0;
-let failed = 0;
-const assert = (condition, label, detail) => {
-    if (condition) {
-        console.log(`✅ ${label}`);
-        passed++;
-    }
-    else {
-        console.log(`❌ ${label}`);
-        if (detail)
-            console.log(`   ${detail}`);
-        failed++;
-    }
-};
-const countBeams = (mei) => (mei.match(/<beam /g) || []).length;
-console.log("Auto-Beam Mode Tests\n");
-console.log("=".repeat(80));
-// --- Test source without manual beams ---
-console.log("\n--- Source without manual beams: c8 d e f g a b c ---\n");
-{
-    // undefined (default) → should auto-beam
-    const doc = parseCode("\\clef \"treble\" c8 d e f g a b c'");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams > 0, "autoBeam=undefined, no manual beams → auto-beam applied", `beam count: ${beams}`);
-}
-{
-    // 'auto' → should auto-beam (same as undefined)
-    const doc = parseCode("\\clef \"treble\" c8 d e f g a b c'");
-    doc.metadata = { autoBeam: 'auto' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams > 0, "autoBeam='auto', no manual beams → auto-beam applied", `beam count: ${beams}`);
-}
-{
-    // 'on' → should auto-beam
-    const doc = parseCode("\\clef \"treble\" c8 d e f g a b c'");
-    doc.metadata = { autoBeam: 'on' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams > 0, "autoBeam='on', no manual beams → auto-beam applied", `beam count: ${beams}`);
-}
-{
-    // 'off' → should NOT auto-beam
-    const doc = parseCode("\\clef \"treble\" c8 d e f g a b c'");
-    doc.metadata = { autoBeam: 'off' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 0, "autoBeam='off', no manual beams → no beams", `beam count: ${beams}`);
-}
-// --- Test source WITH manual beams ---
-console.log("\n--- Source with manual beams: c8[ d e f] g a b c ---\n");
-{
-    // undefined → should NOT auto-beam (manual beams detected)
-    const doc = parseCode("\\clef \"treble\" c8[ d e f] g a b c'");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 1, "autoBeam=undefined, has manual beams → only manual beams (1)", `beam count: ${beams}`);
-}
-{
-    // 'auto' → should NOT auto-beam (manual beams detected)
-    const doc = parseCode("\\clef \"treble\" c8[ d e f] g a b c'");
-    doc.metadata = { autoBeam: 'auto' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 1, "autoBeam='auto', has manual beams → only manual beams (1)", `beam count: ${beams}`);
-}
-{
-    // 'on' → should auto-beam even though manual beams exist
-    const doc = parseCode("\\clef \"treble\" c8[ d e f] g a b c'");
-    doc.metadata = { autoBeam: 'on' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams > 1, "autoBeam='on', has manual beams → auto-beam adds more beams", `beam count: ${beams}`);
-}
-{
-    // 'off' → should NOT auto-beam, but manual beams kept
-    const doc = parseCode("\\clef \"treble\" c8[ d e f] g a b c'");
-    doc.metadata = { autoBeam: 'off' };
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 1, "autoBeam='off', has manual beams → only manual beams (1)", `beam count: ${beams}`);
-}
-// --- Time signature specific tests ---
-console.log("\n--- Time signature grouping ---\n");
-{
-    // 6/8: groups of 3 eighths
-    const doc = parseCode("\\time 6/8 \\clef \"treble\" c8 d e f g a");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 2, "6/8: 6 eighths → 2 beam groups (3+3)", `beam count: ${beams}`);
-}
-{
-    // 3/4: groups of 3 eighths
-    const doc = parseCode("\\time 3/4 \\clef \"treble\" c8 d e f g a");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 2, "3/4: 6 eighths → 2 beam groups (3+3)", `beam count: ${beams}`);
-}
-{
-    // 2/4: groups of 2 eighths
-    const doc = parseCode("\\time 2/4 \\clef \"treble\" c8 d e f");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 2, "2/4: 4 eighths → 2 beam groups (2+2)", `beam count: ${beams}`);
-}
-{
-    // Rest breaks beam
-    const doc = parseCode("\\clef \"treble\" c8 d r e f g r a");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 2, "4/4: rests break beams → 2 beam groups", `beam count: ${beams}`);
-}
-{
-    // Single beamable note should NOT create beam
-    const doc = parseCode("\\clef \"treble\" c4 d8 e4 f4");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams === 0, "Lone eighth among quarters → no beam", `beam count: ${beams}`);
-}
-{
-    // Tuplet auto-beam
-    const doc = parseCode("\\clef \"treble\" \\times 2/3 { c8 d e } \\times 2/3 { f8 g a } c4 c4");
-    const mei = meiEncoder.encode(doc);
-    const beams = countBeams(mei);
-    assert(beams >= 1, "Tuplet eighths → at least 1 beam group", `beam count: ${beams}`);
-}
-// --- Idempotency: auto-beam should not double-beam ---
-console.log("\n--- Idempotency ---\n");
-{
-    const doc = parseCode("\\clef \"treble\" c8 d e f g a b c'");
-    const mei1 = meiEncoder.encode(doc);
-    const mei2 = meiEncoder.encode(doc);
-    // Note: encode adds beam marks in-place, so second call should still work
-    // The beam count may differ because marks accumulate, but MEI output structure should be valid
-    const beams1 = countBeams(mei1);
-    const beams2 = countBeams(mei2);
-    assert(beams1 === beams2, "Double-encode produces same beam count", `first: ${beams1}, second: ${beams2}`);
-}
-console.log("\n" + "=".repeat(80));
-console.log(`\nResults: ${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);

package/lib/tests/computeMeiHashes.d.ts

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

package/lib/tests/computeMeiHashes.js

@@ -1,87 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import * as crypto from "crypto";
-import * as lilylet from "../source/lilylet/index.js";
-const UNIT_CASES_DIR = path.join(import.meta.dirname, "assets/unit-cases");
-const OUTPUT_FILE = path.join(import.meta.dirname, "assets/mei-hashes.yaml");
-const updateMode = process.argv.includes("--update");
-// Parse existing yaml as a flat key:value map (no nesting, comments-aware).
-const loadExisting = (file) => {
-    const map = new Map();
-    if (!fs.existsSync(file))
-        return map;
-    const text = fs.readFileSync(file, "utf-8");
-    for (const raw of text.split("\n")) {
-        const line = raw.trim();
-        if (!line || line.startsWith("#"))
-            continue;
-        const m = line.match(/^([^:]+):\s*(.+)$/);
-        if (m)
-            map.set(m[1].trim(), m[2].trim());
-    }
-    return map;
-};
-const previous = loadExisting(OUTPUT_FILE);
-const files = fs.readdirSync(UNIT_CASES_DIR).filter(f => f.endsWith(".lyl")).sort();
-const lines = [
-    "# MD5 hashes of MEI output for each .lyl unit case.",
-    "# Generated by tests/computeMeiHashes.ts — regenerate with `--update` after intentional encoder changes.",
-    "",
-];
-const mismatches = [];
-const added = [];
-for (const file of files) {
-    const lyl = fs.readFileSync(path.join(UNIT_CASES_DIR, file), "utf-8");
-    const doc = lilylet.parseCode(lyl);
-    const mei = lilylet.meiEncoder.encode(doc);
-    // Strip xml:id attributes and ID references (#note-..., #chord-...) — these
-    // embed Math.random()-derived sessionPrefix and change between runs.
-    const normalized = mei
-        .replace(/\s+xml:id="[^"]*"/g, "")
-        .replace(/="#[^"]*"/g, '="#"');
-    const hash = crypto.createHash("md5").update(normalized).digest("hex");
-    lines.push(`${file}: ${hash}`);
-    const prev = previous.get(file);
-    if (prev === undefined) {
-        added.push(file);
-    }
-    else if (prev !== hash) {
-        mismatches.push({ file, expected: prev, actual: hash });
-    }
-}
-const removed = [];
-for (const key of previous.keys()) {
-    if (!files.includes(key))
-        removed.push(key);
-}
-if (updateMode) {
-    fs.writeFileSync(OUTPUT_FILE, lines.join("\n") + "\n");
-    console.log(`Wrote ${files.length} hashes to ${OUTPUT_FILE}`);
-    if (mismatches.length)
-        console.log(`(${mismatches.length} hash(es) changed, ${added.length} added, ${removed.length} removed)`);
-    process.exit(0);
-}
-if (mismatches.length === 0 && added.length === 0 && removed.length === 0) {
-    console.log(`OK: ${files.length} MEI hashes match the recorded values.`);
-    process.exit(0);
-}
-if (mismatches.length > 0) {
-    console.error(`MEI hash mismatch in ${mismatches.length} file(s):`);
-    for (const m of mismatches) {
-        console.error(`  - ${m.file}`);
-        console.error(`      expected: ${m.expected}`);
-        console.error(`      actual:   ${m.actual}`);
-    }
-}
-if (added.length > 0) {
-    console.error(`New file(s) without recorded hash (${added.length}):`);
-    for (const f of added)
-        console.error(`  - ${f}`);
-}
-if (removed.length > 0) {
-    console.error(`Recorded hash for missing file(s) (${removed.length}):`);
-    for (const f of removed)
-        console.error(`  - ${f}`);
-}
-console.error(`\nIf the change is intentional, run: npx tsx tests/computeMeiHashes.ts --update`);
-process.exit(1);

package/lib/tests/encoder-mutation.d.ts

@@ -1,9 +0,0 @@
-/**
- * Test: Encoder should not mutate input AST
- *
- * GPT-5.2 flagged that the encoder temporarily mutates subEvent.duration.tuplet
- * during tuplet encoding. This test verifies:
- * 1. Encoding a doc twice produces identical output
- * 2. The doc's tuplet events are unchanged after encoding
- */
-export {};

package/lib/tests/encoder-mutation.js

@@ -1,110 +0,0 @@
-/**
- * Test: Encoder should not mutate input AST
- *
- * GPT-5.2 flagged that the encoder temporarily mutates subEvent.duration.tuplet
- * during tuplet encoding. This test verifies:
- * 1. Encoding a doc twice produces identical output
- * 2. The doc's tuplet events are unchanged after encoding
- */
-import * as fs from "fs";
-import * as path from "path";
-import { parseCode, musicXmlEncoder } from "../source/lilylet/index.js";
-const UNIT_CASES_DIR = path.join(import.meta.dirname, "assets/unit-cases");
-// Collect all .lyl files that contain tuplets
-const files = fs.readdirSync(UNIT_CASES_DIR)
-    .filter(f => f.endsWith(".lyl"))
-    .sort();
-let passed = 0;
-let failed = 0;
-console.log("Encoder Mutation Test\n");
-console.log("=".repeat(80));
-for (const filename of files) {
-    const filepath = path.join(UNIT_CASES_DIR, filename);
-    const lyl = fs.readFileSync(filepath, "utf-8");
-    const doc = parseCode(lyl);
-    if (!doc || doc.measures.length === 0)
-        continue;
-    // Check if doc has tuplets
-    let hasTuplets = false;
-    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 === 'tuplet')
-                        hasTuplets = true;
-                }
-            }
-        }
-    }
-    if (!hasTuplets)
-        continue;
-    // Snapshot tuplet sub-event durations before encoding
-    const snapshotBefore = [];
-    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 === 'tuplet') {
-                        for (const sub of e.events) {
-                            snapshotBefore.push(JSON.stringify(sub.duration));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Encode first time
-    const xml1 = musicXmlEncoder.encode(doc);
-    // Snapshot after first encode
-    const snapshotAfter = [];
-    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 === 'tuplet') {
-                        for (const sub of e.events) {
-                            snapshotAfter.push(JSON.stringify(sub.duration));
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Encode second time
-    const xml2 = musicXmlEncoder.encode(doc);
-    // Check 1: Duration snapshots unchanged
-    let durationMutated = false;
-    if (snapshotBefore.length !== snapshotAfter.length) {
-        durationMutated = true;
-    }
-    else {
-        for (let i = 0; i < snapshotBefore.length; i++) {
-            if (snapshotBefore[i] !== snapshotAfter[i]) {
-                durationMutated = true;
-                console.log(`  Duration mutated at index ${i}:`);
-                console.log(`    Before: ${snapshotBefore[i]}`);
-                console.log(`    After:  ${snapshotAfter[i]}`);
-                break;
-            }
-        }
-    }
-    // Check 2: Identical output
-    const identicalOutput = xml1 === xml2;
-    if (!durationMutated && identicalOutput) {
-        console.log(`✅ ${filename}`);
-        passed++;
-    }
-    else {
-        console.log(`❌ ${filename}`);
-        if (durationMutated) {
-            console.log(`   AST mutation detected: tuplet sub-event duration changed after encode`);
-        }
-        if (!identicalOutput) {
-            console.log(`   Non-idempotent: second encode produced different output`);
-        }
-        failed++;
-    }
-}
-console.log("\n" + "=".repeat(80));
-console.log(`\nResults: ${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);

package/lib/tests/gpt-review-issues.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for specific issues raised by GPT-5.2 code review.
- * Tests edge cases that the roundtrip test may not cover.
- */
-export {};

package/lib/tests/gpt-review-issues.js

@@ -1,255 +0,0 @@
-/**
- * Tests for specific issues raised by GPT-5.2 code review.
- * Tests edge cases that the roundtrip test may not cover.
- */
-import { parseCode, musicXmlEncoder, musicXmlDecoder } from "../source/lilylet/index.js";
-let passed = 0;
-let failed = 0;
-const assert = (condition, name, detail) => {
-    if (condition) {
-        console.log(`✅ ${name}`);
-        passed++;
-    }
-    else {
-        console.log(`❌ ${name}`);
-        if (detail)
-            console.log(`   ${detail}`);
-        failed++;
-    }
-};
-console.log("GPT-5.2 Review Issues Test\n");
-console.log("=".repeat(80));
-// ============================================================
-// Issue 1: Tuplet ratio direction consistency
-// GPT says decoder swaps numerator/denominator and default {2,3} may be wrong
-// ============================================================
-console.log("\n--- Tuplet Ratio Direction ---\n");
-{
-    // A triplet in Lilylet: \times 2/3 {c8 d e} means 3 notes in the time of 2
-    // Lilylet TupletEvent.ratio should be {numerator:2, denominator:3}
-    const lyl = `\\time 2/4 \\clef "treble" \\times 2/3 {c8[ d e]}`;
-    const doc = parseCode(lyl);
-    const tuplet = doc.measures[0].parts[0].voices[0].events.find(e => e.type === 'tuplet');
-    assert(tuplet.ratio.numerator === 2 && tuplet.ratio.denominator === 3, "Parser: triplet ratio is 2/3", `Got ${tuplet.ratio.numerator}/${tuplet.ratio.denominator}`);
-    // Encode to MusicXML - check time-modification
-    const xml = musicXmlEncoder.encode(doc);
-    // MusicXML: actual-notes=3 (notes played), normal-notes=2 (normal count)
-    const hasActual3 = xml.includes('<actual-notes>3</actual-notes>');
-    const hasNormal2 = xml.includes('<normal-notes>2</normal-notes>');
-    assert(hasActual3 && hasNormal2, "Encoder: triplet time-modification is actual=3, normal=2", `actual-3=${hasActual3}, normal-2=${hasNormal2}`);
-    // Decode back - check ratio is preserved
-    const doc2 = musicXmlDecoder.decode(xml);
-    const tuplet2 = doc2.measures[0].parts[0].voices[0].events.find(e => e.type === 'tuplet');
-    assert(tuplet2 !== undefined, "Decoder: triplet event exists after roundtrip");
-    if (tuplet2) {
-        assert(tuplet2.ratio.numerator === 2 && tuplet2.ratio.denominator === 3, "Decoder: triplet ratio preserved as 2/3", `Got ${tuplet2.ratio.numerator}/${tuplet2.ratio.denominator}`);
-    }
-}
-// Quadruplet: \times 3/4 {c8 d e f}
-{
-    const lyl = `\\time 3/8 \\clef "treble" \\times 3/4 {c8[ d e f]}`;
-    const doc = parseCode(lyl);
-    const tuplet = doc.measures[0].parts[0].voices[0].events.find(e => e.type === 'tuplet');
-    assert(tuplet.ratio.numerator === 3 && tuplet.ratio.denominator === 4, "Parser: quadruplet ratio is 3/4", `Got ${tuplet.ratio.numerator}/${tuplet.ratio.denominator}`);
-    const xml = musicXmlEncoder.encode(doc);
-    // MusicXML: actual-notes=4 (notes played), normal-notes=3 (normal count)
-    const hasActual4 = xml.includes('<actual-notes>4</actual-notes>');
-    const hasNormal3 = xml.includes('<normal-notes>3</normal-notes>');
-    assert(hasActual4 && hasNormal3, "Encoder: quadruplet time-modification is actual=4, normal=3", `actual-4=${hasActual4}, normal-3=${hasNormal3}`);
-    const doc2 = musicXmlDecoder.decode(xml);
-    const tuplet2 = doc2.measures[0].parts[0].voices[0].events.find(e => e.type === 'tuplet');
-    if (tuplet2) {
-        assert(tuplet2.ratio.numerator === 3 && tuplet2.ratio.denominator === 4, "Decoder: quadruplet ratio preserved as 3/4", `Got ${tuplet2.ratio.numerator}/${tuplet2.ratio.denominator}`);
-    }
-}
-// ============================================================
-// Issue 2: DIVISION_TO_TYPE float key 0.5 (breve)
-// GPT says float keys may cause lookup failures
-// ============================================================
-console.log("\n--- Float Key Lookup (Breve) ---\n");
-{
-    // The parser doesn't support \breve syntax (treats it as multiple tokens).
-    // Test the DIVISION_TO_TYPE lookup directly instead.
-    const DIVISION_TO_TYPE = {
-        0.5: 'breve', 1: 'whole', 2: 'half', 4: 'quarter', 8: 'eighth',
-    };
-    assert(DIVISION_TO_TYPE[0.5] === 'breve', "Float key: DIVISION_TO_TYPE[0.5] works directly", `Got: ${DIVISION_TO_TYPE[0.5]}`);
-    // Test with computed float value: 4/8 = 0.5 which maps to 'breve'
-    const computed = 4 / 8; // = 0.5 exactly (power of 2)
-    assert(DIVISION_TO_TYPE[computed] === 'breve', "Float key: DIVISION_TO_TYPE[4/8=0.5] resolves correctly", `Got: ${DIVISION_TO_TYPE[computed]}`);
-    console.log("  (Note: breve/\\breve is a parser limitation, not an encoder issue)");
-}
-// ============================================================
-// Issue 3: Cross-staff tuplet in decoder
-// GPT says when MusicXML tuplet notes span different staves,
-// the decoder loses the staff change information.
-// We craft MusicXML directly to test this.
-// ============================================================
-console.log("\n--- Cross-Staff Tuplet (Decoder) ---\n");
-{
-    // Craft MusicXML with a tuplet where notes are on different staves
-    // Note 1,2 on staff 2, note 3 on staff 1 (all voice 1)
-    const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">
-<score-partwise version="4.0">
-  <part-list>
-    <score-part id="P1"><part-name>Piano</part-name></score-part>
-  </part-list>
-  <part id="P1">
-    <measure number="1">
-      <attributes>
-        <divisions>4</divisions>
-        <key><fifths>0</fifths><mode>major</mode></key>
-        <time><beats>4</beats><beat-type>4</beat-type></time>
-        <staves>2</staves>
-        <clef><sign>G</sign><line>2</line></clef>
-      </attributes>
-      <note>
-        <pitch><step>C</step><octave>3</octave></pitch>
-        <duration>3</duration>
-        <type>eighth</type>
-        <time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>
-        <voice>1</voice>
-        <staff>2</staff>
-        <beam number="1">begin</beam>
-        <notations><tuplet type="start"/></notations>
-      </note>
-      <note>
-        <pitch><step>E</step><octave>3</octave></pitch>
-        <duration>3</duration>
-        <type>eighth</type>
-        <time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>
-        <voice>1</voice>
-        <staff>2</staff>
-      </note>
-      <note>
-        <pitch><step>G</step><octave>4</octave></pitch>
-        <duration>3</duration>
-        <type>eighth</type>
-        <time-modification><actual-notes>3</actual-notes><normal-notes>2</normal-notes></time-modification>
-        <voice>1</voice>
-        <staff>1</staff>
-        <beam number="1">end</beam>
-        <notations><tuplet type="stop"/></notations>
-      </note>
-      <note>
-        <pitch><step>D</step><octave>4</octave></pitch>
-        <duration>4</duration>
-        <type>quarter</type>
-        <voice>1</voice>
-        <staff>1</staff>
-      </note>
-      <note>
-        <pitch><step>E</step><octave>4</octave></pitch>
-        <duration>4</duration>
-        <type>quarter</type>
-        <voice>1</voice>
-        <staff>1</staff>
-      </note>
-      <note>
-        <rest measure="yes"/>
-        <duration>16</duration>
-        <voice>1</voice>
-        <staff>1</staff>
-      </note>
-    </measure>
-  </part>
-</score-partwise>`;
-    try {
-        const doc = musicXmlDecoder.decode(xml);
-        const voice = doc.measures[0].parts[0].voices[0];
-        const events = voice.events;
-        // The voice starts on staff 2 (first tuplet note), so voice.staff should initially be 2
-        // After the tuplet, notes are on staff 1, so there should be a ContextChange(staff=1) somewhere
-        console.log(`  Voice staff=${voice.staff}, events:`);
-        for (const e of events) {
-            if (e.type === 'context')
-                console.log(`    context staff=${e.staff}`);
-            else if (e.type === 'tuplet') {
-                const t = e;
-                console.log(`    tuplet ${t.events.length} events, ratio=${t.ratio.numerator}/${t.ratio.denominator}`);
-            }
-            else if (e.type === 'note')
-                console.log(`    note ${e.pitches[0].phonet}${e.pitches[0].octave}`);
-            else if (e.type === 'rest')
-                console.log(`    rest`);
-        }
-        // The tuplet stop note is on staff 1, so voiceTracker.addEvent gets staff=1
-        // This should insert a ContextChange(staff=1) before the tuplet event
-        const hasStaffChange = events.some(e => e.type === 'context' && e.staff === 1);
-        assert(hasStaffChange, "Decoder: cross-staff tuplet triggers ContextChange(staff=1)", `Has staff=1 context: ${hasStaffChange}`);
-        // Check the tuplet itself exists
-        const tuplet = events.find(e => e.type === 'tuplet');
-        assert(tuplet !== undefined && tuplet.events.length === 3, "Decoder: cross-staff tuplet has 3 sub-events", tuplet ? `events: ${tuplet.events.length}` : 'no tuplet found');
-        // The REAL issue: within the tuplet, the first 2 notes are on staff 2
-        // and the 3rd note is on staff 1. This staff change is LOST inside the tuplet.
-        // TupletEvent.events is (NoteEvent|RestEvent)[] - no ContextChange possible.
-        // This is a known architectural limitation.
-        console.log("\n  NOTE: Staff changes WITHIN a tuplet are lost (TupletEvent only allows NoteEvent|RestEvent).");
-        console.log("  This is an architectural limitation - the type system doesn't support ContextChange inside tuplets.");
-    }
-    catch (e) {
-        assert(false, "Decoder: cross-staff tuplet parsing", `Error: ${e}`);
-    }
-}
-// ============================================================
-// Issue 4: Encoder encodes twice - verify idempotency with tuplets
-// (More targeted than the general encoder-mutation test)
-// ============================================================
-console.log("\n--- Encoder Idempotency ---\n");
-{
-    const lyl = `\\staff "2" \\key cf \\minor \\time 4/4 \\clef "treble" \\times 2/3 {c8[ ( e a]} \\staff "1" \\times 2/3 {c[ e f]} \\times 2/3 {g[ d b]} \\staff "2" \\times 2/3 {g[ d b] )} |`;
-    const doc = parseCode(lyl);
-    const xml1 = musicXmlEncoder.encode(doc);
-    const xml2 = musicXmlEncoder.encode(doc);
-    assert(xml1 === xml2, "Encoder: double-encode produces identical output (cross-staff tuplets)");
-    // Also check that the AST tuplet durations aren't mutated
-    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 === 'tuplet') {
-                        for (const sub of e.events) {
-                            if (sub.duration.tuplet !== undefined) {
-                                assert(false, "Encoder: tuplet sub-event duration.tuplet not restored", `Found lingering tuplet: ${JSON.stringify(sub.duration.tuplet)}`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    assert(true, "Encoder: no lingering duration.tuplet on sub-events after encode");
-}
-// ============================================================
-// Issue 5: Duration calculation accuracy (Math.round)
-// Test that a full measure of tuplets adds up correctly
-// ============================================================
-console.log("\n--- Duration Accuracy ---\n");
-{
-    // 4/4 time, four triplets = 4 beats
-    const lyl = `\\time 4/4 \\clef "treble" \\times 2/3 {c8[ d e]} \\times 2/3 {f[ g a]} \\times 2/3 {b[ c' d']} \\times 2/3 {e'[ f' g']}`;
-    const doc = parseCode(lyl);
-    const xml = musicXmlEncoder.encode(doc);
-    // With DIVISIONS=4, triplet 8th = round(4 * 0.5 * 2/3) = round(1.33) = 1
-    // 12 notes × 1 = 12. Ideal would be 16 (4 beats × 4 divisions).
-    // This rounding is a known limitation of DIVISIONS=4 for tuplets.
-    // Test that each triplet group sums consistently (all notes same duration)
-    const durationMatches = xml.match(/<duration>(\d+)<\/duration>/g);
-    if (durationMatches) {
-        const durations = durationMatches.map(m => parseInt(m.replace(/<\/?duration>/g, '')));
-        const allSame = durations.every(d => d === durations[0]);
-        assert(allSame && durations[0] === 1, "Duration: triplet 8th notes each round to 1 division (DIVISIONS=4 limitation)", `individual: [${durations.join(', ')}]`);
-        // Note: ideal total would be 16, actual is 12 due to rounding with small DIVISIONS
-        console.log(`  (Total: ${durations.reduce((a, b) => a + b, 0)}, ideal: 16 — rounding artifact with DIVISIONS=4)`);
-    }
-    else {
-        assert(false, "Duration: no duration elements found");
-    }
-}
-// ============================================================
-// Summary
-// ============================================================
-console.log("\n" + "=".repeat(80));
-console.log(`\nResults: ${passed} passed, ${failed} failed`);
-process.exit(failed > 0 ? 1 : 0);

package/lib/tests/json-to-lyl.d.ts

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

package/lib/tests/json-to-lyl.js

@@ -1,18 +0,0 @@
-import { serializeLilyletDoc } from '../source/lilylet/index.js';
-import * as fs from 'fs';
-const files = [
-    'rest-full-42',
-    'rest-full-44',
-    'chords-simple-triad-chord-c-e-g',
-    'multiple-staves-3voices',
-    'multiple-voices-two-voices-with-vb-separator',
-];
-for (const name of files) {
-    const doc = JSON.parse(fs.readFileSync(`tests/output/lilypond-roundtrip/${name}.json`, 'utf-8'));
-    console.log(`\n=== ${name} ===`);
-    console.log(serializeLilyletDoc(doc));
-}
-// cross-staves2
-const doc2 = JSON.parse(fs.readFileSync('tests/output/lilypond-roundtrip/multiple-staves-cross-staves2.json', 'utf-8'));
-console.log('\n=== multiple-staves-cross-staves2 ===');
-console.log(serializeLilyletDoc(doc2));

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

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