@k-l-lambda/lilylet 0.1.62 → 0.1.64

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

@@ -0,0 +1,17 @@
+/**
+ * Unit test: \tuplet N/M D { notes } with base-duration argument must
+ * preserve the tuplet wrapper in the decoded doc.
+ *
+ * Bug: The LilyPond decoder accessed args[1].body to find the tuplet body,
+ * but \tuplet 3/2 4 { ... } has args = ["3/2", "4", {body}].
+ * args[1] is "4" (the base duration), not the music block, so body was
+ * empty and all notes were silently decoded as plain notes outside any tuplet.
+ *
+ * Real-world case: chopin-28-14.ly — every measure is wrapped in
+ *   \tuplet 3/2 4 { | notes }
+ * producing 12 eighth notes in the time of 8, but the decoded lyl had
+ * no \times wrapper at all.
+ *
+ * Usage: npx tsx tests/unit/tupletWithBaseDuration.test.ts
+ */
+export {};

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

@@ -0,0 +1,139 @@
+/**
+ * Unit test: \tuplet N/M D { notes } with base-duration argument must
+ * preserve the tuplet wrapper in the decoded doc.
+ *
+ * Bug: The LilyPond decoder accessed args[1].body to find the tuplet body,
+ * but \tuplet 3/2 4 { ... } has args = ["3/2", "4", {body}].
+ * args[1] is "4" (the base duration), not the music block, so body was
+ * empty and all notes were silently decoded as plain notes outside any tuplet.
+ *
+ * Real-world case: chopin-28-14.ly — every measure is wrapped in
+ *   \tuplet 3/2 4 { | notes }
+ * producing 12 eighth notes in the time of 8, but the decoded lyl had
+ * no \times wrapper at all.
+ *
+ * Usage: npx tsx tests/unit/tupletWithBaseDuration.test.ts
+ */
+import { decode } from "../../source/lilylet/lilypondDecoder.js";
+import { serializeLilyletDoc } from "../../source/lilylet/serializer.js";
+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 }
+\\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: \tuplet 3/2 4 { notes } preserves tuplet ─────────────────────
+// Chopin 28-14 pattern: \tuplet 3/2 4 wraps 12 eighth notes per measure.
+// Without base-duration: \tuplet 3/2 { ef8 bf gf ... } = 12 notes
+// With base-duration:    \tuplet 3/2 4 { | ef8 bf gf ... } = same semantics
+console.log('\nTest 1: \\tuplet 3/2 4 { notes } — tuplet wrapper preserved');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 4 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    assert(doc.measures.length >= 1, `decoded 1 measure (got ${doc.measures.length})`);
+    if (!doc.measures[0])
+        return;
+    const voice = doc.measures[0].parts[0]?.voices[0];
+    assert(!!voice, 'voice exists');
+    if (!voice)
+        return;
+    // The voice should have a tuplet event, NOT 12 bare note events
+    const tuplets = voice.events.filter(e => e.type === 'tuplet' || e.type === 'times');
+    const bareNotes = voice.events.filter(e => e.type === 'note');
+    assert(tuplets.length >= 1, `voice contains at least 1 tuplet/times event (got ${tuplets.length}) — not bare notes`);
+    assert(bareNotes.length === 0, `no bare notes at top level (got ${bareNotes.length}) — all should be inside tuplet`);
+    if (tuplets.length >= 1) {
+        const t = tuplets[0];
+        const innerNotes = t.events.filter(e => e.type === 'note');
+        assert(innerNotes.length === 12, `tuplet contains 12 inner notes (got ${innerNotes.length})`);
+        assert(t.ratio.numerator === 2 && t.ratio.denominator === 3, `ratio is 2/3 (lilylet: play 12 eighth notes in time of 8) — got ${t.ratio.numerator}/${t.ratio.denominator}`);
+    }
+})();
+// ─── Test 2: \tuplet 3/2 (no base duration) — should still work ────────────
+console.log('\nTest 2: \\tuplet 3/2 { notes } without base duration (baseline)');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    const voice = doc.measures[0]?.parts[0]?.voices[0];
+    const tuplets = voice?.events.filter(e => e.type === 'tuplet' || e.type === 'times') ?? [];
+    assert(tuplets.length >= 1, `\\tuplet 3/2 (no base dur) also produces tuplet event (got ${tuplets.length})`);
+})();
+// ─── Test 3: serialized lyl contains \tuplet or \times wrapper ─────────────
+console.log('\nTest 3: serialized lyl contains tuplet notation');
+await (async () => {
+    const LY = LY_BOILERPLATE + `
+\\score {
+  \\new Staff {
+    \\new Voice {
+      \\relative ef, {
+        \\time 4/4
+        \\tuplet 3/2 4 {
+          ef8 [ bf' gf ] cf [ ef, cf' ] d, [ cf' f, ] bf [ d, bf']
+        }
+      }
+    }
+  }
+  \\layout {}
+}
+`;
+    const doc = await decode(LY);
+    const lyl = serializeLilyletDoc(doc);
+    console.log(`  lyl: ${lyl.trim().split('\n').find(l => l.includes('time') || l.includes('tuplet') || l.includes('times')) ?? '(not found)'}`);
+    assert(lyl.includes('\\tuplet') || lyl.includes('\\times'), `serialized lyl contains \\tuplet or \\times notation (got no tuplet wrapper)`);
+})();
+// ─── 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/voiceStaffParsing.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unit tests for voice.staff parsing edge cases from GPT review of the
+ * leadingStaff fix (commit c0763a4, 47fcf61).
+ *
+ * Cases:
+ *   A. non-staff context before \staff "N" in same voice line
+ *   B. second voice after \\ with no explicit \staff (fallback)
+ *   C. trailing | + newline → spurious empty measure filtered
+ *   D. measure with only \bar → filtered as empty
+ *
+ * Usage: npx tsx tests/unit/voiceStaffParsing.test.ts
+ */
+export {};

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

@@ -0,0 +1,118 @@
+/**
+ * Unit tests for voice.staff parsing edge cases from GPT review of the
+ * leadingStaff fix (commit c0763a4, 47fcf61).
+ *
+ * Cases:
+ *   A. non-staff context before \staff "N" in same voice line
+ *   B. second voice after \\ with no explicit \staff (fallback)
+ *   C. trailing | + newline → spurious empty measure filtered
+ *   D. measure with only \bar → filtered as empty
+ *
+ * Usage: npx tsx tests/unit/voiceStaffParsing.test.ts
+ */
+import { parseCode } from '../../source/lilylet/parser.js';
+let passed = 0;
+let failed = 0;
+function assert(condition, message) {
+    if (condition) {
+        console.log(`  ✓ ${message}`);
+        passed++;
+    }
+    else {
+        console.error(`  ✗ FAIL: ${message}`);
+        failed++;
+    }
+}
+function voiceStaff(lyl, measureIdx = 0, voiceIdx = 0) {
+    const doc = parseCode(lyl);
+    return doc.measures[measureIdx]?.parts[0]?.voices[voiceIdx]?.staff ?? -1;
+}
+function measureCount(lyl) {
+    return parseCode(lyl).measures.length;
+}
+// ─── Case A1: \clef before \staff "2" ────────────────────────────────────────
+console.log('\nCase A1: \\clef before \\staff "2" — staff must be 2');
+{
+    const lyl = `\\clef "bass" \\staff "2" c4 d e f |`;
+    assert(voiceStaff(lyl) === 2, `\\clef "bass" \\staff "2" c4 → voice.staff=2 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case A2: \key before \staff "2" ─────────────────────────────────────────
+console.log('\nCase A2: \\key before \\staff "2" — staff must be 2');
+{
+    const lyl = `\\key g \\major \\staff "2" c4 d e f |`;
+    assert(voiceStaff(lyl) === 2, `\\key g \\major \\staff "2" → voice.staff=2 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case A3: \time \clef \key before \staff "2" \times ──────────────────────
+console.log('\nCase A3: multiple context events before \\staff "2" \\times');
+{
+    const lyl = `\\time 4/4 \\clef "treble" \\key c \\major \\staff "2" \\times 2/3 { c8 d e } r2. |`;
+    const doc = parseCode(lyl);
+    const voice = doc.measures[0]?.parts[0]?.voices[0];
+    assert(!!voice, 'voice exists');
+    if (voice) {
+        assert(voice.staff === 2, `context chain before \\staff "2" → voice.staff=2 (got ${voice.staff})`);
+        // Verify the event stream: leading context events (non-staff) then staff=2 context before tuplet
+        const staffCtxIdx = voice.events.findIndex((e) => e.type === 'context' && e.staff === 2);
+        const tupletIdx = voice.events.findIndex((e) => e.type === 'tuplet' || e.type === 'times');
+        assert(staffCtxIdx >= 0, `context{staff:2} event exists in events`);
+        assert(tupletIdx >= 0, `tuplet event exists in events`);
+        assert(staffCtxIdx < tupletIdx, `context{staff:2} (idx=${staffCtxIdx}) appears before tuplet (idx=${tupletIdx})`);
+    }
+}
+// ─── Case A4: \staff "1" first, cross-staff switch — staff must be 1 ─────────
+console.log('\nCase A4: \\staff "1" then \\staff "2" — leading staff is 1');
+{
+    const lyl = `\\staff "1" c4 d \\staff "2" e f |`;
+    assert(voiceStaff(lyl) === 1, `\\staff "1" c4 d \\staff "2" e f → voice.staff=1 (got ${voiceStaff(lyl)})`);
+}
+// ─── Case B1: second voice — stale currentStaff=2 must NOT leak ──────────────
+// Voice 0 ends after switching to \staff "2" (currentStaff=2 is stale).
+// Voice 1 has no explicit \staff — should default to staff=1 (part_start reset),
+// NOT inherit the stale currentStaff=2 from voice 0.
+console.log('\nCase B1: second voice (no \\staff) must NOT inherit stale currentStaff=2');
+{
+    const lyl = `\\staff "1" c4 \\staff "2" d e f \\\\ g4 a b c |`;
+    const doc = parseCode(lyl);
+    const voices = doc.measures[0]?.parts[0]?.voices ?? [];
+    assert(voices.length === 2, `two voices parsed (got ${voices.length})`);
+    assert(voices[0].staff === 1, `voice 0 leading \\staff "1" (got ${voices[0]?.staff})`);
+    // part_start resets currentStaff=1 for each part_voices attempt;
+    // if stale currentStaff=2 leaked, voice 1 would wrongly get staff=2
+    assert(voices[1].staff === 1, `voice 1 no \\staff → defaults to 1, not stale 2 (got ${voices[1]?.staff})`);
+}
+// ─── Case B2: \\ then \staff "2" ─────────────────────────────────────────────
+console.log('\nCase B2: second voice starts with \\staff "2"');
+{
+    const lyl = `\\staff "1" c4 d e f \\\\ \\staff "2" c4 d e f |`;
+    const doc = parseCode(lyl);
+    const voices = doc.measures[0]?.parts[0]?.voices ?? [];
+    assert(voices.length === 2, `two voices parsed (got ${voices.length})`);
+    assert(voices[1].staff === 2, `voice 1 \\staff "2" → staff=2 (got ${voices[1]?.staff})`);
+}
+// ─── Case C: trailing newline after last | — no spurious measure ─────────────
+console.log('\nCase C: trailing newline after last | — no spurious empty measure');
+{
+    // lyl with explicit trailing newline
+    const lyl = `\\staff "1" c4 d e f |\n`;
+    const count = measureCount(lyl);
+    assert(count === 1, `exactly 1 measure (got ${count})`);
+}
+// ─── Case D: measure with only \bar — filtered as empty ──────────────────────
+console.log('\nCase D: measure with only \\bar "|." — filtered as empty');
+{
+    const lyl = `\\staff "1" c4 d e f | \\bar "|." |`;
+    const count = measureCount(lyl);
+    // The real measure (c4 d e f) is kept; the barline-only measure is filtered
+    assert(count === 1, `barline-only measure filtered, 1 real measure remains (got ${count})`);
+}
+// ─── Case E: measure with notes then trailing empty measure ──────────────────
+console.log('\nCase E: two real measures, no spurious third');
+{
+    const lyl = `\\staff "1" c4 d e f | g4 a b c |\n`;
+    const count = measureCount(lyl);
+    assert(count === 2, `exactly 2 measures (got ${count})`);
+}
+// ─── Summary ─────────────────────────────────────────────────────────────────
+console.log(`\n${'═'.repeat(50)}`);
+console.log(`Total: ${passed + failed}  Passed: ${passed}  Failed: ${failed}`);
+process.exit(failed > 0 ? 1 : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "Lilylet is a lilyopnd-like sheet music language designed for Markdown rendering and symbolic music representation in AIGC applications.",
   "type": "module",
   "main": "lib/index.js",
@@ -29,11 +29,13 @@
     "prepublishOnly": "npm run build:grammar && npm run build",
     "test": "tsx ./tests/parser.ts",
     "test:mei": "tsx ./tests/mei.ts",
+    "test:mei-hashes": "tsx ./tests/computeMeiHashes.ts",
     "test:unit": "tsx ./tests/unit/encodePitch.test.ts",
     "test:partial": "tsx ./tests/unit/partialWarning.test.ts",
     "test:decoder": "tsx ./tests/lilypondDecoder.ts",
     "test:abc": "tsx ./tests/abc-decoder.ts",
     "test:roundtrip": "tsx ./tests/lilypond-roundtrip.ts",
+    "test:abc-svg": "tsx ./tests/abc-abcjs-svg.ts",
     "build:tests": "tsc -p tsconfig.tests.json; cp source/lilylet/grammar.jison.js lib-tests/source/lilylet/ && cp source/abc/grammar.jison.js lib-tests/source/abc/ && node tools/fixEsmExtensions.cjs lib-tests && ln -sfn ../../tests/assets lib-tests/tests/assets",
     "test:roundtrip:compiled": "node lib-tests/tests/lilypond-roundtrip.js",
     "ts": "tsx"
@@ -51,14 +53,15 @@
   "devDependencies": {
     "@types/node": "^20.11.20",
     "@types/yargs": "^17.0.32",
+    "abcjs": "^6.6.2",
     "formidable": "^3.5.4",
     "jison": "^0.4.18",
+    "jsdom": "^29.0.2",
     "sha1": "^1.1.1",
     "ts-node": "^10.9.2",
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
     "verovio": "^5.7.0",
-    "xmldom": "^0.6.0",
     "yargs": "^17.7.2"
   },
   "dependencies": {

package/source/abc/abc.jison

@@ -82,18 +82,24 @@
 		const {patches} = body;
 		const measures = [];
 		let measure = null;
-		let lastVoice = 1;
+		const seenVoices = new Set();
+
 		patches.forEach(patch => {
 			const voice = patch.control.V || 1;
-			if (voice <= lastVoice) {
+			if (seenVoices.has(voice)) {
 				if (measure)
 					measures.push(measure);
 				measure = {voices: []};
+				seenVoices.clear();
 			}
+			if (!measure)
+				measure = {voices: []};
+			seenVoices.add(voice);
 			measure.voices.push(patch);
 		});
 
-		measures.push(measure);
+		if (measure)
+			measures.push(measure);
 
 		measures.forEach((measure, index) => measure.index = index + 1);
 
@@ -151,6 +157,21 @@
 
 
 	const octaveShift = shift => ({octaveShift: shift});
+
+
+	const parseMode = (name) => {
+		const n = name.toLowerCase();
+		if (n.startsWith("ma")) return "major";
+		if (n === "m" || n.startsWith("mi")) return "minor";
+		if (n.startsWith("dor")) return "dorian";
+		if (n.startsWith("phr")) return "phrygian";
+		if (n.startsWith("lyd")) return "lydian";
+		if (n.startsWith("mix")) return "mixolydian";
+		if (n.startsWith("aeo")) return "aeolian";
+		if (n.startsWith("loc")) return "locrian";
+		if (n === "hp") return "highland";
+		return n;
+	};
 %}
 
 
@@ -160,24 +181,27 @@
 
 %x string
 %x comment
+%x spec_comment_name
 %x spec_comment
+%x spec_comment_skip
 %x title_string
 %x key_signature
+%x voice_header
 %x exclamation_exp
 
-
 H									\b[A-Z](?=\:[^|])
-A									\b[A-G](?=[\W\d\sA-Ga-g_zHJLMOPRSTuv]*\b)
+A									\b[A-G](?=[\W\d\sA-Ga-g_yzHJLMOPRSTuv]*\b)
 Am									\b[A-G](?=[m][a][j]|[m][i][n]\b)
-a									\b[a-g](?=[\W\d\sA-Ga-g_zHJLMOPRSTuv]*\b)
+a									\b[a-g](?=[\W\d\sA-Ga-g_yzHJLMOPRSTuv]*\b)
 z									\b[z]
 Z									\b[Z]
 x									\b[x](?=[\W\d\s])
+y									\b[y]
 N									[0-9]
 P									\b[HJLMOPRSTuv](?=[A-Ga-g][A-Ga-g0-9]*\b)
 PP									\b[HJLMOPRSTuv](?=[xz!\[^_=\s"])
 
-SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~]
+SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~&]
 
 
 %%
@@ -193,10 +217,30 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~]
 <title_string>[^\n]+				return 'STR_CONTENT'
 
 ^[K][:][\s]*						{ this.pushState('key_signature'); return 'K:'; }
+^[V][:][ \t]*						{ this.pushState('voice_header'); return 'V:'; }
+<voice_header>\"					{ this.pushState('string'); return 'STR_START'; }
+<voice_header>[a-zA-Z][a-zA-Z0-9,]*	return 'NAME';
+<voice_header>[0-9]+				return 'N';
+<voice_header>[=]					return '=';
+<voice_header>[+\-]					return yytext;
+<voice_header>[ \t]+				{}
+<voice_header>\n					{ this.popState(); }
+<voice_header>\]					{ this.popState(); return ']'; }
 <key_signature>"treble"				return 'TREBLE';
 <key_signature>"bass"				return 'BASS';
 <key_signature>"tenor"				return 'TENOR';
+<key_signature>"none"				return 'NAME';
+<key_signature>"Dor"				return 'NAME';
+<key_signature>"Phr"				return 'NAME';
+<key_signature>"Lyd"				return 'NAME';
+<key_signature>"Mix"				return 'NAME';
+<key_signature>"Aeo"				return 'NAME';
+<key_signature>"Loc"				return 'NAME';
+<key_signature>"HP"					return 'NAME';
+<key_signature>"Hp"					return 'NAME';
+<key_signature>[a-z]+[ \t]*=[^\n\]]*	{}
 <key_signature>[A-G]				return 'A';
+<key_signature>[A-Z][a-z]+			return 'NAME';
 <key_signature>[b]					return 'FLAT';
 <key_signature>[#]					return 'SHARP';
 <key_signature>[m][a-z]*			return 'NAME';
@@ -208,14 +252,20 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~]
 <key_signature>\]					{ this.popState(); return ']'; }
 
 ^[%]								{ this.pushState('comment'); }
-<comment>[%]						{ this.pushState('spec_comment'); }
+<comment>[%]						{ this.pushState('spec_comment_name'); }
 <comment>[^\n]+						{ return 'COMMENT'; }
-<spec_comment>\n					{ this.popState(); this.popState(); }
 <comment>\n							{ this.popState(); }
-<spec_comment>\s					{}
-<spec_comment>"score"				return 'SCORE'
-<spec_comment>[\w]+					return 'NN'
+<spec_comment_name>[ \t]+			{}
+<spec_comment_name>"score"			{ this.popState(); this.pushState('spec_comment'); return 'SCORE'; }
+<spec_comment_name>"staves"			{ this.popState(); this.pushState('spec_comment'); return 'SCORE'; }
+<spec_comment_name>[\w]+			{ this.popState(); this.pushState('spec_comment_skip'); }
+<spec_comment_name>\n				{ this.popState(); this.popState(); }
+<spec_comment>[ \t]+				{}
 <spec_comment>[(){}\[\]|]			return yytext
+<spec_comment>[\w]+					return 'NN'
+<spec_comment>\n					{ this.popState(); this.popState(); return 'LAYOUT_END'; }
+<spec_comment_skip>[^\n]+			{}
+<spec_comment_skip>\n				{ this.popState(); this.popState(); }
 
 [!]									{ this.pushState('exclamation_exp'); return '!'; }
 <exclamation_exp>[!]				{ this.popState(); return '!'; }
@@ -231,6 +281,7 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~]
 <exclamation_exp>{N}				return 'N'
 <exclamation_exp>[a-zA-Z][\w-]*		return 'NAME'
 
+\\\n								{}
 \s+									{}
 
 {SPECIAL}							return yytext
@@ -250,6 +301,7 @@ SPECIAL								[:!^_,'/<>={}()\[\]|.\-+~]
 "staff"								return 'STAFF'
 "maj"								return 'MAJ'
 "min"								return 'MIN'
+{y}									return 'y'
 [a-zA-Z][\w-]*						return 'NAME'
 
 <<EOF>>								return 'EOF'
@@ -284,6 +336,7 @@ head_lines
 	| head_lines head_line				-> [...$1, $2]
 	| head_lines comment				-> [...$1, $2]
 	| head_lines staff_layout_statement	-> [...$1, $2]
+	| head_lines 'LAYOUT_END'			-> $1
 	| head_lines ']'					-> $1
 	| head_lines '}'					-> $1
 	| head_lines ')'					-> $1
@@ -294,7 +347,7 @@ comment
 	;
 
 staff_layout_statement
-	: 'SCORE' staff_layout				-> $2
+	: 'SCORE' staff_layout 'LAYOUT_END'	-> $2
 	;
 
 staff_layout
@@ -320,6 +373,7 @@ head_line
 	: 'T:' string_content				-> header('T', $2)
 	| 'C:' string_content				-> header('C', $2)
 	| 'K:' key_signature				-> header('K', $2)
+	| 'V:' header_value					-> header('V', $2)
 	| H ':' header_value				-> header($1, $3)
 	;
 
@@ -328,6 +382,7 @@ header_value
 	| number
 	| frac
 	| numeric_tempo
+	| string frac '=' number			-> ({text: $1, note: $2, bpm: $4})
 	| upper_phonet
 	| voice_exp
 	| staff_shift
@@ -342,6 +397,11 @@ staff_shift
 	;
 
 key_signature
+	: key_root							-> $1
+	| NAME								-> key(null, $1)
+	;
+
+key_root
 	: A									-> key($1, null)
 	| A sharp_or_flat					-> key($1 + $2, null)
 	| A key_mode						-> key($1, $2)
@@ -362,7 +422,7 @@ sharp_or_flat
 key_mode
 	: MAJ								-> 'major'
 	| MIN								-> 'minor'
-	| NAME								-> $1.startsWith("ma") ? "major" : "minor"
+	| NAME								-> parseMode($1)
 	;
 
 plus_minus_number
@@ -402,6 +462,10 @@ voice_exp
 	| number NAME assigns				-> voice($1, $2, $3)
 	| NAME								-> voice(1, $1)
 	| NAME assigns						-> voice(1, $1, $2)
+	| upper_phonet number				-> voice(1, $1 + String($2))
+	| upper_phonet number assigns		-> voice(1, $1 + String($2), $3)
+	| upper_phonet number NAME			-> voice(1, $1 + String($2))
+	| upper_phonet number NAME assigns	-> voice(1, $1 + String($2), $4)
 	;
 
 assigns
@@ -418,6 +482,7 @@ assign_value
 	| number
 	| plus_minus_number
 	| NAME
+	| upper_phonet
 	;
 
 upper_phonet
@@ -437,6 +502,9 @@ patches
 	| patches tailless_patch			-> [...$1, $2]
 	| patches ']'						-> $1
 	| patches '}'						-> $1
+	| patches head_line					-> $1
+	| patches 'LAYOUT_END'				-> $1
+	| patches '&' patch					-> $1
 	;
 
 patch
@@ -459,10 +527,11 @@ bar
 	| ':' '|' ']'						-> ':|]'
 	| '|' N								-> '|' + $2
 	| ':' '|' N							-> ':|' + $2
+	| '&'								-> '&'
 	;
 
 music
-	: %empty
+	: %empty							-> []
 	| music expressive_mark				-> $1 ? [...$1, $2] : [$2]
 	| music text						-> $1 ? [...$1, $2] : [$2]
 	| music event						-> $1 ? [...$1, $2] : [$2]
@@ -474,11 +543,13 @@ music
 	| music NAME						-> $1
 	| music '^' NAME					-> $1
 	| music '^'							-> $1
+	| music '[' N						-> $1
 	;
 
 control
 	: '[' H ':' header_value ']'		-> ({control: header($2, $4)})
 	| '[' 'K:' header_value ']'			-> ({control: header("K", $3)})
+	| '[' 'V:' header_value ']'			-> ({control: header("V", $3)})
 	| '[' NAME ':' header_value ']'		-> ({control: header($2, $4)})
 	;
 
@@ -510,6 +581,7 @@ articulation
 articulation_content
 	: scope_articulation				-> articulation($1)
 	| scope_articulation parenthese		-> articulation($1, $2)
+	| scope_articulation '=' assign_value	-> articulation($1 + '=' + String($3))
 	| DYNAMIC							-> articulation($1)
 	| a									-> articulation($1)
 	| "^"								-> articulation($1)
@@ -613,6 +685,8 @@ accidentals
 	| '^' '^'							-> 2
 	| '_' '_'							-> -2
 	| '=' '='							-> 0
+	| '^' '/'							-> 0.5
+	| '_' '/'							-> -0.5
 	;
 
 pitch
@@ -637,6 +711,7 @@ rest_phonet
 	: z
 	| Z
 	| x
+	| y
 	;
 
 event