@k-l-lambda/lilylet 0.1.70 → 0.1.72

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

@@ -1,154 +0,0 @@
-/**
- * Unit test: full-measure rest (R1) detection in the LilyPond decoder.
- *
- * Regression guard for:
- *   - lilypondDecoder: R must decode with fullMeasure=true; r must not
- *   - serializeLilyletDoc: fullMeasure rest must serialize as uppercase R
- *   - parseCode round-trip: R in .lyl must parse back with fullMeasure=true
- *
- * Usage: npx tsx tests/unit/fullMeasureRest.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 findRests(doc) {
-    const rests = [];
-    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 === 'rest')
-                        rests.push(event);
-                }
-            }
-        }
-    }
-    return rests;
-}
-// ─── Warm-up parser (required before first decode call) ─────────────────────
-{
-    const warn = console.warn, assert2 = console.assert;
-    console.warn = () => { };
-    console.assert = () => { };
-    try {
-        await decode('{ c }');
-    }
-    catch { /* ignore */ }
-    console.warn = warn;
-    console.assert = assert2;
-}
-// ─── Test 1: LilyPond decoder — R1 produces fullMeasure=true ────────────────
-console.log('\nTest 1: lilypondDecoder R1 → fullMeasure=true');
-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 } }
-`;
-const LY_WITH_R1 = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\time 4/4 \\clef treble c4 d e f } |  % 1
-    }
-    \\new Voice {
-      \\relative c' { \\time 4/4 R1 } |  % 1
-    }
-  >>
-  \\layout { }
-}
-`;
-const LY_WITH_LOWERCASE_R = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\time 4/4 \\clef treble r1 } |  % 1
-    }
-  >>
-  \\layout { }
-}
-`;
-await (async () => {
-    const docR = await decode(LY_WITH_R1);
-    const restsR = findRests(docR);
-    const fullMeasureRests = restsR.filter(r => r.fullMeasure);
-    assert(fullMeasureRests.length === 1, `R1 decoded: found ${fullMeasureRests.length} fullMeasure rest (expected 1)`);
-    if (fullMeasureRests.length > 0) {
-        assert(fullMeasureRests[0].duration.division === 1, `R1 duration.division === 1 (whole note)`);
-        assert(!fullMeasureRests[0].invisible, `R1 is not invisible`);
-    }
-    const docR_lc = await decode(LY_WITH_LOWERCASE_R);
-    const restsLc = findRests(docR_lc);
-    assert(restsLc.length === 1, `r1 decoded: found ${restsLc.length} rest (expected 1)`);
-    if (restsLc.length > 0) {
-        assert(!restsLc[0].fullMeasure, `r1 does NOT have fullMeasure flag`);
-    }
-})();
-// ─── Test 2: serializer — fullMeasure rest serializes as uppercase R ─────────
-console.log('\nTest 2: serializer fullMeasure=true → uppercase R in .lyl');
-await (async () => {
-    const doc = await decode(LY_WITH_R1);
-    const lyl = serializeLilyletDoc(doc);
-    // Should contain uppercase R1 (whole full-measure rest)
-    assert(/\bR1\b/.test(lyl), `lyl contains R1: ${lyl.includes('R1') ? 'yes' : 'NO — got: ' + lyl.slice(0, 200)}`);
-    // Should NOT contain standalone r1 (lowercase, a regular rest)
-    // Note: "r1" can appear as a sub-string of identifiers, so we check for word-boundary r1
-    const hasLowercaseR1 = /\br1\b/.test(lyl);
-    assert(!hasLowercaseR1, `lyl does not contain lowercase r1 where R1 is expected`);
-})();
-// ─── Test 3: round-trip R1 through .lyl parser ───────────────────────────────
-console.log('\nTest 3: R1 .lyl round-trip — fullMeasure survives parseCode');
-await (async () => {
-    const doc = await decode(LY_WITH_R1);
-    const lyl = serializeLilyletDoc(doc);
-    const docRT = parseCode(lyl);
-    const rests = findRests(docRT);
-    const fullMeasureRests = rests.filter(r => r.fullMeasure);
-    assert(fullMeasureRests.length >= 1, `Round-trip: found ${fullMeasureRests.length} fullMeasure rest (expected ≥1)`);
-})();
-// ─── Test 4: dotted variants (R2., R4.) also get fullMeasure=true ────────────
-console.log('\nTest 4: dotted variants R2. R4. also get fullMeasure=true');
-const LY_DOTTED = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\time 3/4 \\clef treble c4 d e } |  % 1
-    }
-    \\new Voice {
-      \\relative c' { \\time 3/4 R2. } |  % 1
-    }
-  >>
-  \\layout { }
-}
-`;
-await (async () => {
-    const doc = await decode(LY_DOTTED);
-    const rests = findRests(doc);
-    const fullMeasureRests = rests.filter(r => r.fullMeasure);
-    assert(fullMeasureRests.length === 1, `R2. decoded: found ${fullMeasureRests.length} fullMeasure rest (expected 1)`);
-    if (fullMeasureRests.length > 0) {
-        assert(fullMeasureRests[0].duration.division === 2, `R2. duration.division === 2`);
-        assert(fullMeasureRests[0].duration.dots === 1, `R2. duration.dots === 1`);
-    }
-    const lyl = serializeLilyletDoc(doc);
-    assert(/\bR2\.\s*\|/.test(lyl) || /\bR2\.\s*\\\\/.test(lyl), `lyl contains R2.: ${lyl.includes('R2.') ? 'yes' : 'NO'}`);
-})();
-// ─── Summary ─────────────────────────────────────────────────────────────────
-console.log(`\n${'═'.repeat(40)}`);
-console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
-process.exit(failed > 0 ? 1 : 0);

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

@@ -1,8 +0,0 @@
-/**
- * Unit tests targeting issues raised in GPT code review of commits:
- *   - fix: serializer cross-staff context handling
- *   - fix: LilyPond decoder \change Staff support
- *
- * Usage: npx tsx tests/unit/gptReviewIssues.test.ts
- */
-export {};

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

@@ -1,240 +0,0 @@
-/**
- * Unit tests targeting issues raised in GPT code review of commits:
- *   - fix: serializer cross-staff context handling
- *   - fix: LilyPond decoder \change Staff support
- *
- * Usage: npx tsx tests/unit/gptReviewIssues.test.ts
- */
-import { decode } from '../../source/lilylet/lilypondDecoder.js';
-import { serializeLilyletDoc } from '../../source/lilylet/serializer.js';
-// ─── helpers ────────────────────────────────────────────────────────────────
-let passed = 0;
-let failed = 0;
-function assert(condition, message) {
-    if (condition) {
-        console.log(`  ✓ ${message}`);
-        passed++;
-    }
-    else {
-        console.error(`  ✗ FAIL: ${message}`);
-        failed++;
-    }
-}
-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 parser
-{
-    const warn = console.warn, a2 = console.assert;
-    console.warn = () => { };
-    console.assert = () => { };
-    try {
-        await decode('{ c }');
-    }
-    catch { /* ignore */ }
-    console.warn = warn;
-    console.assert = a2;
-}
-function getVoiceEvents(doc) {
-    return doc.measures.flatMap(m => m.parts.flatMap(p => p.voices));
-}
-/** Assert that string A appears before string B in str. */
-function assertOrder(str, a, b, label) {
-    const ia = str.indexOf(a);
-    const ib = str.indexOf(b);
-    assert(ia !== -1 && ib !== -1 && ia < ib, `${label}: "${a}" (pos ${ia}) appears before "${b}" (pos ${ib})`);
-}
-// ─── Issue 1a: Compound { staff, clef } on DIFFERENT staff ───────────────────
-// Bug: serializer emits \staff "N" then `continue`, dropping the clef.
-// Repro: build a LilyletDoc directly with a compound context event.
-console.log('\nIssue 1a: Compound context { staff:2, clef:"bass" } — serializer must emit both');
-{
-    const doc = {
-        measures: [{
-                parts: [{
-                        voices: [{
-                                staff: 1,
-                                events: [
-                                    { type: 'context', staff: 2, clef: 'bass' },
-                                    { type: 'note', pitches: [{ phonet: 'g', octave: -1 }], duration: { division: 4, dots: 0 } },
-                                ]
-                            }]
-                    }]
-            }]
-    };
-    const lyl = serializeLilyletDoc(doc);
-    assert(lyl.includes('\\staff "2"'), `Compound event: emits \\staff "2" — got: ${lyl}`);
-    assert(lyl.includes('\\clef "bass"'), `Compound event: emits \\clef "bass" — got: ${lyl}`);
-    assertOrder(lyl, '\\staff "2"', '\\clef "bass"', 'Compound diff-staff');
-}
-// ─── Issue 1b: Compound { staff, clef } on SAME staff ────────────────────────
-// Bug: `if (ctx.staff) continue` drops clef when staff unchanged.
-console.log('\nIssue 1b: Compound context { staff:1, clef:"bass" } same staff — clef must not be dropped');
-{
-    const doc = {
-        measures: [{
-                parts: [{
-                        voices: [{
-                                staff: 1,
-                                events: [
-                                    { type: 'context', staff: 1, clef: 'bass' },
-                                    { type: 'note', pitches: [{ phonet: 'c', octave: 0 }], duration: { division: 4, dots: 0 } },
-                                ]
-                            }]
-                    }]
-            }]
-    };
-    const lyl = serializeLilyletDoc(doc);
-    // staff:1 is same as voice.staff so no \staff switch needed, but clef MUST appear
-    assert(lyl.includes('\\clef "bass"'), `Same-staff compound event: emits \\clef "bass" — got: ${lyl}`);
-}
-// ─── Issue 2: Rest ordering — \staff "2" must come BEFORE rest in output ─────
-console.log('\nIssue 2: \\staff "2" appears before rest, \\staff "1" before return rest (ordering)');
-await (async () => {
-    const LY = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\change Staff = "2" r2 \\change Staff = "1" r2 }
-    }
-  >>
-  \\layout { }
-}
-`;
-    const doc = await decode(LY);
-    const lyl = serializeLilyletDoc(doc);
-    // Match the full pattern: \staff "2" r... \staff "1" r...
-    // (duration may be elided on second rest)
-    assert(/\\staff "2"\s+r\d*/.test(lyl), `\\staff "2" immediately before first rest`);
-    assert(/\\staff "1"\s+r\d*/.test(lyl), `\\staff "1" immediately before second rest`);
-})();
-// ─── Issue 3: Non-numeric \change Staff = "RH" — notes still decode correctly ─
-console.log('\nIssue 3: \\change Staff = "RH" — notes after ignored change still decode');
-await (async () => {
-    const LY = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\change Staff = "RH" g2 g2 }
-    }
-  >>
-  \\layout { }
-}
-`;
-    const doc = await decode(LY);
-    const voices = getVoiceEvents(doc);
-    const notes = voices.flatMap(v => v.events.filter(e => e.type === 'note'));
-    assert(notes.length === 2, `Notes after ignored \\change Staff still decode — got ${notes.length}`);
-    const staffCtx = voices.flatMap(v => v.events.filter(e => e.type === 'context' && e.staff != null));
-    assert(staffCtx.length === 0, `Non-numeric name produces 0 staff context events (got ${staffCtx.length})`);
-})();
-// ─── Issue 4: Adversarial digit-stripping — "1_2", "foo2bar", "1 2" ──────────
-console.log('\nIssue 4: Adversarial staff names via digit-stripping regex');
-await (async () => {
-    // "1_2" is a realistic case (GrandStaff-style staff names in generated .ly files)
-    const LY_1_2 = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' { \\change Staff = "1_2" g2 g2 }
-    }
-  >>
-  \\layout { }
-}
-`;
-    const doc = await decode(LY_1_2);
-    const voices = getVoiceEvents(doc);
-    const staffCtx = voices.flatMap(v => v.events.filter(e => e.type === 'context' && e.staff != null));
-    const staffNums = staffCtx.map((e) => e.staff);
-    // "1_2".replace(/[^0-9]/g) → "12" → parseInt → 12
-    // This is the digit-stripping coercion bug.
-    // Document actual behavior: if 12 appears, that is the bug.
-    if (staffNums.includes(12)) {
-        assert(false, `BUG: "1_2" was coerced to staff 12 by digit-stripping (got ${staffNums})`);
-    }
-    else if (staffNums.length === 0) {
-        // Acceptable if treated as unparseable and dropped
-        assert(true, `"1_2" treated as non-numeric, silently dropped (staff events: 0)`);
-    }
-    else {
-        // Any other result should be explicit
-        assert(false, `Unexpected staff numbers from "1_2": ${staffNums}`);
-    }
-})();
-// ─── Issue 5: Multiple successive switches — exact sequence ──────────────────
-console.log('\nIssue 5: Multiple successive staff switches — exact event sequence');
-await (async () => {
-    const LY = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' {
-        \\change Staff = "2" g4
-        \\change Staff = "1" c4
-        \\change Staff = "2" g4
-        \\change Staff = "1" c4
-      }
-    }
-  >>
-  \\layout { }
-}
-`;
-    const doc = await decode(LY);
-    // Verify exact decoded event sequence
-    const voices = getVoiceEvents(doc);
-    const seq = [];
-    for (const v of voices) {
-        let activeStaff = v.staff;
-        for (const e of v.events) {
-            if (e.type === 'context' && e.staff != null) {
-                activeStaff = e.staff;
-                seq.push(`staff:${activeStaff}`);
-            }
-            if (e.type === 'note')
-                seq.push(`note`);
-        }
-    }
-    const expected = ['staff:2', 'note', 'staff:1', 'note', 'staff:2', 'note', 'staff:1', 'note'];
-    assert(JSON.stringify(seq) === JSON.stringify(expected), `Exact sequence: [${seq.join(',')}] === [${expected.join(',')}]`);
-    // Verify serialized output has correct ordering
-    const lyl = serializeLilyletDoc(doc);
-    // Remove whitespace/newlines for easier regex
-    const flat = lyl.replace(/\s+/g, ' ');
-    // Should see: staff "2" ... g4 ... staff "1" ... c4 ... staff "2" ... g4 ... staff "1" ... c4
-    // Match patterns: \staff "2" g... and \staff "1" c... (duration may be elided)
-    assert(/\\staff "2"\s+g\d*/.test(flat), `\\staff "2" immediately before g note`);
-    assert(/\\staff "1"\s+c\d*/.test(flat), `\\staff "1" immediately before c note`);
-})();
-// ─── Issue 5b: Same-staff switch twice in a row ───────────────────────────────
-console.log('\nIssue 5b: Same-staff switch twice in a row — no duplicate \\staff emission');
-await (async () => {
-    const LY = LY_BOILERPLATE + `
-\\score {
-  \\new Staff = "1_1" <<
-    \\new Voice {
-      \\relative c' {
-        \\change Staff = "2" g4
-        \\change Staff = "2" g4
-      }
-    }
-  >>
-  \\layout { }
-}
-`;
-    const doc = await decode(LY);
-    const lyl = serializeLilyletDoc(doc);
-    const count = (lyl.match(/\\staff "2"/g) || []).length;
-    // Ideally emitted only once (serializer dedupes same-staff switch)
-    assert(count >= 1, `At least one \\staff "2" emitted (got ${count})`);
-    // Document: currently emits it twice (one per context event) or once (deduplicated)
-    console.log(`  (info) \\staff "2" count: ${count} — serializer ${count === 1 ? 'deduplicates' : 'does NOT deduplicate'} same-staff repeat`);
-})();
-// ─── Summary ─────────────────────────────────────────────────────────────────
-console.log(`\n${'═'.repeat(50)}`);
-console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
-process.exit(failed > 0 ? 1 : 0);

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

@@ -1,13 +0,0 @@
-/**
- * Unit test: \parallelMusic decoding in the LilyPond decoder.
- *
- * \parallelMusic distributes measures round-robin across named variables:
- *   \parallelMusic #'(voiceA voiceB) { m1a | m1b | m2a | m2b | }
- * → voiceA = [m1a, m2a], voiceB = [m1b, m2b]
- * Variables are then referenced in a \score block.
- *
- * Reference: https://lilypond.org/doc/v2.23/Documentation/notation/multiple-voices#writing-music-in-parallel
- *
- * Usage: npx tsx tests/unit/parallelMusicDecoder.test.ts
- */
-export {};

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

@@ -1,261 +0,0 @@
-/**
- * Unit test: \parallelMusic decoding in the LilyPond decoder.
- *
- * \parallelMusic distributes measures round-robin across named variables:
- *   \parallelMusic #'(voiceA voiceB) { m1a | m1b | m2a | m2b | }
- * → voiceA = [m1a, m2a], voiceB = [m1b, m2b]
- * Variables are then referenced in a \score block.
- *
- * Reference: https://lilypond.org/doc/v2.23/Documentation/notation/multiple-voices#writing-music-in-parallel
- *
- * Usage: npx tsx tests/unit/parallelMusicDecoder.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++;
-    }
-}
-// Warm-up parser
-{
-    const w = console.warn, a = console.assert;
-    console.warn = () => { };
-    console.assert = () => { };
-    try {
-        await decode('{ c }');
-    }
-    catch { }
-    console.warn = w;
-    console.assert = a;
-}
-function getNotes(doc) {
-    return doc.measures.flatMap(m => m.parts.flatMap(p => p.voices.flatMap(v => v.events
-        .filter(e => e.type === 'note')
-        .map(e => e.pitches[0].phonet))));
-}
-function getMeasureCount(doc) {
-    return doc.measures.length;
-}
-// ─── Test input ───────────────────────────────────────────────────────────────
-//
-// Original \parallelMusic syntax with octave marks, as used in real scores.
-// Expected absolute pitches verified by running through the lotus decoder:
-//
-//   voiceA  \relative c'':
-//     m1: c'4 d e f  → c(2) d(2) e(2) f(2)   (C6=oct2, since c' in \relative c'')
-//     m2: a'4 b c d  → a(3) b(3) c(4) d(4)   (continues from f(2), a'→oct3, wraps)
-//
-//   voiceB  \relative c':
-//     m1: g,2 g      → g(-2) g(-2)            (G, relative c' with , → very low)
-//     m2: e,2 e      → e(-3) e(-3)            (continues from g(-2))
-//
-// \parallelMusic interleaves: voiceA-m1 | voiceB-m1 | voiceA-m2 | voiceB-m2
-const LY_PARALLEL = `
-\\version "2.22.0"
-\\language "english"
-\\header { tagline = ##f }
-
-\\parallelMusic #'(voiceA voiceB)
-{
-  c'4 d e f |
-  g,2 g     |
-  a'4 b c d |
-  e,2 e     |
-}
-
-\\score {
-  \\new StaffGroup <<
-    \\new Staff {
-      \\new Voice = "va" {
-        \\relative c'' \\voiceA
-      }
-    }
-    \\new Staff {
-      \\clef "bass"
-      \\new Voice = "vb" {
-        \\relative c' \\voiceB
-      }
-    }
-  >>
-  \\layout {}
-}
-`;
-// ─── Test 1: decoder produces the correct number of measures ─────────────────
-console.log('\nTest 1: \\parallelMusic — correct measure count decoded');
-await (async () => {
-    let doc;
-    let threw = false;
-    try {
-        doc = await decode(LY_PARALLEL);
-    }
-    catch (e) {
-        threw = true;
-        console.log(`  ! Decoder threw: ${e.message}`);
-    }
-    assert(!threw, 'Decoder does not throw on \\parallelMusic input');
-    if (!doc)
-        return;
-    const measures = getMeasureCount(doc);
-    assert(measures === 2, `Decoded 2 measures (got ${measures})`);
-})();
-// ─── Test 2: voiceA notes are present (c d e f / a b c d) ────────────────────
-console.log('\nTest 2: voiceA notes decoded correctly');
-await (async () => {
-    const doc = await decode(LY_PARALLEL);
-    const allNotes = getNotes(doc);
-    // voiceA should contain: c d e f (m1) and a b c d (m2)
-    assert(allNotes.includes('c'), `Note 'c' present`);
-    assert(allNotes.includes('d'), `Note 'd' present`);
-    assert(allNotes.includes('e'), `Note 'e' present`);
-    assert(allNotes.includes('f'), `Note 'f' present`);
-    // voiceB should contain: g (m1) and e (m2)
-    assert(allNotes.includes('g'), `Note 'g' present (voiceB)`);
-    const totalNotes = allNotes.length;
-    assert(totalNotes >= 10, `Total note count ≥ 10 (got ${totalNotes})`);
-})();
-// ─── Test 3: voiceA and voiceB land on separate staves/voices ────────────────
-console.log('\nTest 3: voiceA and voiceB produce distinct voice entries');
-await (async () => {
-    const doc = await decode(LY_PARALLEL);
-    // Count total voice entries across all measures
-    const voiceEntries = doc.measures.flatMap(m => m.parts.flatMap(p => p.voices));
-    assert(voiceEntries.length >= 2, `At least 2 voice entries across all measures (got ${voiceEntries.length})`);
-    // Each measure should have at least one voice with notes
-    for (let mi = 0; mi < doc.measures.length; mi++) {
-        const notes = doc.measures[mi].parts.flatMap(p => p.voices.flatMap(v => v.events.filter(e => e.type === 'note')));
-        assert(notes.length > 0, `Measure ${mi + 1} has note events (got ${notes.length})`);
-    }
-})();
-// ─── Test 4: absolute pitch correctness — decoded octaves match LilyPond ──────
-//
-// Each pitch is represented as {phonet, octave} absolute values computed by lotus.
-// Expected values were verified by running the decoder (not manually guessed):
-//   voiceA m1: c(2) d(2) e(2) f(2)   — c' in \relative c'' = C6
-//   voiceA m2: a(3) b(3) c(4) d(4)   — continues from f(2), a' pushes to oct3+
-//   voiceB m1: g(-2) g(-2)            — g, in \relative c' = very low G
-//   voiceB m2: e(-3) e(-3)            — continues from g(-2)
-console.log('\nTest 4: absolute pitch correctness (phonet + octave match LilyPond semantics)');
-await (async () => {
-    const doc = await decode(LY_PARALLEL);
-    // Collect all note pitches grouped by measure and voice order
-    const byMeasure = [];
-    for (let mi = 0; mi < doc.measures.length; mi++) {
-        byMeasure[mi] = doc.measures[mi].parts
-            .flatMap(p => p.voices)
-            .map(v => v.events
-            .filter(e => e.type === 'note')
-            .map(e => ({ phonet: e.pitches[0].phonet, octave: e.pitches[0].octave })))
-            .filter(a => a.length > 0);
-    }
-    const fmt = (ps) => ps.map(p => `${p.phonet}(${p.octave})`).join(' ');
-    // voiceA m1: c(2) d(2) e(2) f(2)
-    const vaM1 = byMeasure[0]?.find(v => v.some(p => p.phonet === 'c' && p.octave === 2));
-    assert(!!vaM1, `voiceA m1 found at expected octave 2`);
-    if (vaM1) {
-        const expected = [{ phonet: 'c', octave: 2 }, { phonet: 'd', octave: 2 }, { phonet: 'e', octave: 2 }, { phonet: 'f', octave: 2 }];
-        assert(JSON.stringify(vaM1) === JSON.stringify(expected), `voiceA m1 pitches: [${fmt(vaM1)}] === [${fmt(expected)}]`);
-    }
-    // voiceA m2: a(3) b(3) c(4) d(4)
-    const vaM2 = byMeasure[1]?.find(v => v.some(p => p.phonet === 'a' && p.octave === 3));
-    assert(!!vaM2, `voiceA m2 found at expected octave 3+`);
-    if (vaM2) {
-        const expected = [{ phonet: 'a', octave: 3 }, { phonet: 'b', octave: 3 }, { phonet: 'c', octave: 4 }, { phonet: 'd', octave: 4 }];
-        assert(JSON.stringify(vaM2) === JSON.stringify(expected), `voiceA m2 pitches: [${fmt(vaM2)}] === [${fmt(expected)}]`);
-    }
-    // voiceB m1: g(-2) g(-2)
-    const vbM1 = byMeasure[0]?.find(v => v.some(p => p.phonet === 'g' && p.octave === -2));
-    assert(!!vbM1, `voiceB m1 found at expected octave -2`);
-    if (vbM1) {
-        const expected = [{ phonet: 'g', octave: -2 }, { phonet: 'g', octave: -2 }];
-        assert(JSON.stringify(vbM1) === JSON.stringify(expected), `voiceB m1 pitches: [${fmt(vbM1)}] === [${fmt(expected)}]`);
-    }
-    // voiceB m2: e(-3) e(-3)
-    const vbM2 = byMeasure[1]?.find(v => v.some(p => p.phonet === 'e' && p.octave === -3));
-    assert(!!vbM2, `voiceB m2 found at expected octave -3`);
-    if (vbM2) {
-        const expected = [{ phonet: 'e', octave: -3 }, { phonet: 'e', octave: -3 }];
-        assert(JSON.stringify(vbM2) === JSON.stringify(expected), `voiceB m2 pitches: [${fmt(vbM2)}] === [${fmt(expected)}]`);
-    }
-})();
-// ─── Test 5: serializer→parser round-trip preserves absolute pitches ──────────
-// The serializer converts absolute pitches back to \relative lyl syntax.
-// If there is per-measure relative-mode drift, the parsed-back octaves will
-// differ from the decoded-doc octaves.
-console.log('\nTest 5: serialized .lyl round-trip preserves absolute pitches (detect relative-mode drift)');
-await (async () => {
-    const doc = await decode(LY_PARALLEL);
-    const lyl = serializeLilyletDoc(doc);
-    console.log('  lyl output:\n' + lyl.split('\n').map(l => '    ' + l).join('\n'));
-    let docRT;
-    try {
-        docRT = parseCode(lyl);
-    }
-    catch (e) {
-        assert(false, `parseCode threw: ${e.message}`);
-        return;
-    }
-    // Extract flat list of {phonet, octave} from all note events
-    const getPitches = (d) => d.measures.flatMap(m => m.parts.flatMap(p => p.voices.flatMap(v => v.events
-        .filter(e => e.type === 'note')
-        .map(e => {
-        const n = e;
-        return { phonet: n.pitches[0].phonet, octave: n.pitches[0].octave };
-    }))));
-    const origPitches = getPitches(doc);
-    const rtPitches = getPitches(docRT);
-    console.log('  orig pitches:', origPitches.map(p => p.phonet + p.octave).join(' '));
-    console.log('  rt   pitches:', rtPitches.map(p => p.phonet + p.octave).join(' '));
-    assert(origPitches.length === rtPitches.length, `Same note count: ${origPitches.length} === ${rtPitches.length}`);
-    let allMatch = true;
-    for (let i = 0; i < origPitches.length; i++) {
-        const o = origPitches[i], r = rtPitches[i];
-        if (o.phonet !== r.phonet || o.octave !== r.octave) {
-            assert(false, `Pitch ${i}: ${o.phonet}(${o.octave}) → round-trip gave ${r.phonet}(${r.octave}) — relative-mode drift`);
-            allMatch = false;
-        }
-    }
-    if (allMatch) {
-        assert(true, `All ${origPitches.length} pitches preserved through serializer round-trip`);
-    }
-})();
-// ─── Test 6: serialization produces valid .lyl ────────────────────────────────
-console.log('\nTest 6: serialized .lyl parses back without error');
-await (async () => {
-    const doc = await decode(LY_PARALLEL);
-    const lyl = serializeLilyletDoc(doc);
-    console.log('  lyl output:\n' + lyl.split('\n').map(l => '    ' + l).join('\n'));
-    let threw = false;
-    let docRT;
-    try {
-        docRT = parseCode(lyl);
-    }
-    catch (e) {
-        threw = true;
-        console.log(`  ! parseCode threw: ${e.message}`);
-    }
-    assert(!threw, 'Serialized .lyl parses back without error');
-    if (!docRT)
-        return;
-    const rtMeasures = getMeasureCount(docRT);
-    assert(rtMeasures === getMeasureCount(doc), `Round-trip measure count matches (${rtMeasures} === ${getMeasureCount(doc)})`);
-    const rtNotes = getNotes(docRT);
-    const origNotes = getNotes(doc);
-    assert(rtNotes.length === origNotes.length, `Round-trip note count matches (${rtNotes.length} === ${origNotes.length})`);
-})();
-// ─── Summary ─────────────────────────────────────────────────────────────────
-console.log(`\n${'═'.repeat(50)}`);
-if (failed > 0) {
-    console.log(`⚠️  ${failed} FAILED — \\parallelMusic not fully supported by decoder`);
-}
-console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
-process.exit(failed > 0 ? 1 : 0);

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

@@ -1,4 +0,0 @@
-/**
- * Unit tests for \partial syntax — duration check and warning emission.
- */
-export {};