@k-l-lambda/lilylet 0.1.59 → 0.1.62

package/lib/lilylet/serializer.js

@@ -301,6 +301,10 @@ const serializeContextChange = (event) => {
     if (event.time) {
         parts.push('\\time ' + event.time.numerator + '/' + event.time.denominator);
     }
+    // Partial (pickup measure duration check)
+    if (event.partial) {
+        parts.push('\\partial ' + event.partial.division + '.'.repeat(event.partial.dots || 0));
+    }
     // Ottava
     if (event.ottava !== undefined) {
         if (event.ottava === 0) {
@@ -343,8 +347,11 @@ const serializeTempo = (tempo) => {
 const serializeTupletEvent = (event, env) => {
     const parts = [];
     let currentEnv = env;
-    // \times numerator/denominator { ... }
-    parts.push('\\times ' + event.ratio.numerator + '/' + event.ratio.denominator + ' {');
+    // \tuplet denominator/numerator { ... } for tuplet type, \times numerator/denominator for times type
+    const keyword = event.type === 'times'
+        ? '\\times ' + event.ratio.numerator + '/' + event.ratio.denominator
+        : '\\tuplet ' + event.ratio.denominator + '/' + event.ratio.numerator;
+    parts.push(keyword + ' {');
     let prevDuration;
     for (const e of event.events) {
         if (e.type === 'note') {
@@ -359,6 +366,20 @@ const serializeTupletEvent = (event, env) => {
             currentEnv = newEnv;
             prevDuration = e.duration;
         }
+        else if (e.type === 'context') {
+            const ctx = e;
+            if (ctx.staff != null) {
+                parts.push(' \\staff "' + ctx.staff + '"');
+            }
+            else if (ctx.stemDirection != null) {
+                if (ctx.stemDirection === StemDirection.up)
+                    parts.push(' \\stemUp');
+                else if (ctx.stemDirection === StemDirection.down)
+                    parts.push(' \\stemDown');
+                else if (ctx.stemDirection === StemDirection.auto)
+                    parts.push(' \\stemNeutral');
+            }
+        }
     }
     parts.push(' }');
     return { str: parts.join(''), newEnv: currentEnv };
@@ -428,6 +449,7 @@ const serializeEvent = (event, env, prevDuration) => {
         case 'context':
             return { str: serializeContextChange(event), newEnv: env };
         case 'tuplet':
+        case 'times':
             return serializeTupletEvent(event, env);
         case 'tremolo':
             return serializeTremoloEvent(event, env);
@@ -463,10 +485,45 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
     let prevDuration;
     // Each voice starts fresh from middle C (step=0, octave=0)
     let pitchEnv = { step: 0, octave: 0 };
+    // Scan leading context-staff events (before the first musical event or clef/ottava)
+    // to compute the effective initial staff. Multiple consecutive staff switches
+    // before any music collapse to the last one (earlier ones are no-ops).
+    // leadStaffScanEnd is the index of the first event that ends this scan —
+    // context{staff} events before this index are skipped in the main loop.
+    const MUSICAL_TYPES = new Set(['note', 'rest', 'tuplet', 'times', 'tremolo']);
+    let effectiveInitialStaff = voice.staff;
+    let leadStaffScanEnd = 0;
+    for (let i = 0; i < voice.events.length; i++) {
+        const e = voice.events[i];
+        if (e.type === 'pitchReset') {
+            leadStaffScanEnd = i + 1;
+            continue;
+        }
+        if (e.type === 'context') {
+            const ctx = e;
+            if (ctx.staff != null) {
+                effectiveInitialStaff = ctx.staff;
+                if (!ctx.clef && !ctx.ottava) {
+                    // Pure staff-only event — absorb
+                    leadStaffScanEnd = i + 1;
+                    continue;
+                }
+                // Compound (staff + clef/ottava) — update effectiveInitialStaff but stop scan
+                break;
+            }
+            if (ctx.clef || ctx.ottava)
+                break; // musical context — stop scan
+            leadStaffScanEnd = i + 1; // time/key/stemDir — continue scan
+            continue;
+        }
+        if (MUSICAL_TYPES.has(e.type))
+            break;
+    }
     // Output staff command if voice staff differs from current parser staff,
-    // or always output if it's a grand staff score for clarity
-    if (isGrandStaff || voice.staff !== currentStaff) {
-        parts.push('\\staff "' + voice.staff + '"');
+    // or always output if it's a grand staff score for clarity.
+    // Use effectiveInitialStaff so carry-over replaces the default emission.
+    if (isGrandStaff || effectiveInitialStaff !== currentStaff) {
+        parts.push('\\staff "' + effectiveInitialStaff + '"');
     }
     // Output key/time signatures after \staff (for first voice only)
     if (measureContext && isFirstVoice) {
@@ -498,9 +555,14 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
     }
     // Skip redundant clef context events if this staff's clef is already established
     const clefOutputted = !!voiceClef && !!emittedClefs?.[voice.staff];
-    let activeStaff = voice.staff;
+    let activeStaff = effectiveInitialStaff;
     let activeStemDir;
-    for (const event of voice.events) {
+    for (let eventIdx = 0; eventIdx < voice.events.length; eventIdx++) {
+        const event = voice.events[eventIdx];
+        // Skip leading context-staff events already absorbed into effectiveInitialStaff
+        if (eventIdx < leadStaffScanEnd && event.type === 'context' && event.staff != null) {
+            continue;
+        }
         if (event.type === 'context') {
             const ctx = event;
             // Cross-staff context: update activeStaff and emit \staff directive
@@ -516,8 +578,9 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
                 }
                 continue;
             }
-            if (ctx.staff)
-                continue; // same staff, no-op for staff field; clef handled below
+            if (ctx.staff && !ctx.clef && !ctx.ottava)
+                continue; // same staff, pure no-op
+            if (ctx.staff) { /* same staff but has clef/ottava — fall through to emit them */ }
             // Skip clef-only context events if clef already established for this staff
             if (clefOutputted && ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo) {
                 continue;
@@ -566,6 +629,13 @@ const serializeVoice = (voice, currentStaff, isGrandStaff = false, measureContex
         else if (event.type === 'rest') {
             prevDuration = event.duration;
         }
+        else if (event.type === 'tuplet' || event.type === 'times') {
+            // After a tuplet/times block the LilyPond parser's "current duration" is the
+            // last note duration inside the tuplet, not the duration before the tuplet.
+            // Reset prevDuration so the first note after the block always emits its
+            // duration explicitly, avoiding wrong inheritance from inside the tuplet.
+            prevDuration = undefined;
+        }
         else if (event.type === 'context' && event.clef && emittedClefs) {
             const ctx = event;
             emittedClefs[ctx.staff || activeStaff] = ctx.clef;
@@ -626,7 +696,7 @@ const serializeMeasure = (measure, _isFirst, currentStaff, isGrandStaff = false,
             }
             staff = newStaff;
         }
-        parts.push(partStrs.join(' \\\\\\\\\n'));
+        parts.push(partStrs.join(' \\\\\\\n'));
     }
     return { str: parts.join(' '), newStaff: staff };
 };

package/lib/lilylet/types.d.ts

@@ -181,6 +181,7 @@ export interface ContextChange {
     type: 'context';
     key?: KeySignature;
     time?: Fraction;
+    partial?: Duration;
     clef?: Clef;
     ottava?: number;
     stemDirection?: StemDirection;
@@ -197,7 +198,12 @@ export interface TremoloEvent {
 export interface TupletEvent {
     type: 'tuplet';
     ratio: Fraction;
-    events: (NoteEvent | RestEvent)[];
+    events: (NoteEvent | RestEvent | ContextChange)[];
+}
+export interface TimesEvent {
+    type: 'times';
+    ratio: Fraction;
+    events: (NoteEvent | RestEvent | ContextChange)[];
 }
 export interface PitchResetEvent {
     type: 'pitchReset';
@@ -215,7 +221,7 @@ export interface MarkupEvent {
     content: string;
     placement?: Placement;
 }
-export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
+export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | TimesEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
 export interface Voice {
     staff: number;
     events: Event[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k-l-lambda/lilylet",
-  "version": "0.1.59",
+  "version": "0.1.62",
   "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",
@@ -27,12 +27,16 @@
     "build": "tsc -p tsconfig.build.json && node tools/convertGrammarToESM.cjs && node tools/fixEsmExtensions.cjs",
     "build:grammar": "npx tsx ./tools/buildJisonParser.ts && node tools/convertGrammarToESM.cjs",
     "prepublishOnly": "npm run build:grammar && npm run build",
-    "test": "npx tsx ./tests/parser.ts",
-    "test:mei": "npx tsx ./tests/mei.ts",
-    "test:unit": "npx tsx ./tests/unit/encodePitch.test.ts",
-    "test:decoder": "npx tsx ./tests/lilypondDecoder.ts",
-    "test:abc": "npx tsx ./tests/abc-decoder.ts",
-    "ts": "npx tsx"
+    "test": "tsx ./tests/parser.ts",
+    "test:mei": "tsx ./tests/mei.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",
+    "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"
   },
   "repository": {
     "type": "git",
@@ -51,6 +55,7 @@
     "jison": "^0.4.18",
     "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",

package/source/abc/TODO.md

@@ -0,0 +1,97 @@
+# ABC Grammar TODO
+
+Issues found by comparing `abc.jison` against the abcjs parser implementation.
+
+---
+
+## High Priority
+
+### 1. Church modes in key signatures
+
+`key_mode` only distinguishes `major` / `minor`. The `NAME` fallback does a naive
+`startsWith("ma")` check, which mis-classifies all church modes:
+
+- Dorian (`Dor`, `dorian`)
+- Phrygian (`Phr`, `phrygian`)
+- Lydian (`Lyd`, `lydian`)
+- Mixolydian (`Mix`, `mixolydian`)
+- Aeolian (`Aeo`, `aeolian`)
+- Locrian (`Loc`, `locrian`)
+- Scottish bagpipe: `HP`, `Hp`
+
+These should be recognized as distinct modes rather than silently falling back to
+major or minor. The `abcDecoder.ts` key-mapping logic will also need updating to
+handle these modes.
+
+### 2. Bare-number Q: tempo (`Q:120`)
+
+`numeric_tempo` only matches `frac '=' number` (e.g. `Q:1/4=120`). Two common
+forms are not parsed:
+
+- `Q:120` — plain BPM number (unit inferred from the current meter/L: value)
+- `Q:"Allegro"` — text-only tempo marking
+- `Q:"Allegro" 1/4=120` — combined text + numeric form
+
+`Q:120` is the most frequently seen form in real-world ABC files.
+
+---
+
+## Medium Priority
+
+### 3. Missing rest type: `y` (spacer)
+
+The `rest_phonet` rule covers `z`, `Z`, `x` but not `y` (an invisible spacer rest
+used for spacing/layout). Files containing `y` currently cause a parse error.
+
+### 4. Volta ending bracket (`endEnding`)
+
+The `bar` rule appends the ending number directly to the bar token string
+(`'|' + N → "|1"`). There is no representation of the *closing* bracket of a
+first-ending, so `[1 ... [2` style repeat structures cannot be round-tripped.
+abcjs tracks `startEnding` / `endEnding` flags on bar elements; consider a
+similar approach.
+
+---
+
+## Low Priority
+
+### 5. `~` maps to `mordent` instead of `irishroll`
+
+`abc.jison` line 507: `'~' → articulation("mordent")`.  
+The standard ABC specification defines `~` as an *Irish roll* ornament, not a
+mordent. abcjs uses the name `irishroll`. The mordent is correctly represented by
+`M`. This is a semantic mismatch that may affect downstream rendering/export.
+
+### 6. Microtonal accidentals (`^/`, `_/`)
+
+The `accidentals` rule does not cover quarter-tone accidentals:
+
+- `^/` → quarter sharp
+- `_/` → quarter flat
+
+These are recognised by abcjs. Files using microtonal notation will silently drop
+the accidental.
+
+### 7. Short trill decoration `t`
+
+The single-letter `t` (half/short trill, `trillh` in abcjs) is not handled. The
+current `P`/`PP` lexer patterns only match uppercase ornament letters
+(`HJLMOPRSTuv`), so lowercase `t` falls through as an unknown token.
+
+### 8. Overlay voices (`&`)
+
+The `&` operator (alternative voice within a single bar, same staff) is not
+supported. abcjs resolves overlays into separate voices via `resolveOverlays()`.
+This is a moderately common pattern in two-voice piano or lute transcriptions.
+
+---
+
+## Out of Scope (noted for awareness)
+
+- **Lyrics** (`w:` / `W:` fields): not handled at the ABC grammar level; notes
+  have no `lyric` property. Would require grammar additions and decoder support.
+- **Extended clef types**: only `treble`, `bass`, `tenor` are recognised. abcjs
+  also handles `alto`, `baritone`, `mezzo`, `soprano`, `tab`, `perc`, etc.
+- **Decoration name aliases**: abcjs normalises `tr`→`trill`, `emphasis`→`accent`,
+  `marcato`→`umarcato`, `<`/`>`→`accent`. The lilylet grammar passes `NAME`
+  through as-is; the decoder would need to handle the aliases explicitly.