@k-l-lambda/lilylet 0.1.59 → 0.1.62

package/source/lilylet/lilylet.jison

@@ -51,22 +51,46 @@
 		mode,
 	});
 
-	const voice = (staff, events) => ({
-		staff: staff || 1,
-		events,
-	});
+	const voice = (staff, events) => {
+		// Use the first \staff "N" context event that appears before any musical event
+		// (notes/rests/tuplets) as the authoritative voice.staff.
+		// Skip pitchReset events (from NEWLINE tokens at voice-line boundaries).
+		// This ensures \staff "1" \times ... \staff "2" ... gives voice.staff=1,
+		// not 2 (the final currentStaff value), while \staff "2" c1 gives voice.staff=2.
+		let leadingStaff = null;
+		for (const e of events) {
+			if (!e) continue;
+			if (e.type === 'pitchReset') continue;
+			if (e.type === 'context') {
+				if (e.staff != null) { leadingStaff = e.staff; break; }
+				continue; // skip non-staff context events (key, clef, time, etc.)
+			}
+			break; // first musical/structural event — stop
+		}
+		return {
+			staff: leadingStaff != null ? leadingStaff : 1,
+			events,
+		};
+	};
 
 	const part = (voices, name) => ({
 		name: name || undefined,
 		voices,
 	});
 
-	const measure = (parts, key, timeSig, partial) => ({
-		key: key || undefined,
-		timeSig: timeSig || undefined,
-		parts,
-		partial: partial || undefined,
-	});
+	const MUSICAL = new Set(['note', 'rest', 'tuplet', 'times', 'tremolo']);
+	const hasMusicalContent = (parts) =>
+		parts.some(p => p.voices.some(v => v.events.some(e => e && MUSICAL.has(e.type))));
+
+	const measure = (parts, key, timeSig, partial) => {
+		if (!hasMusicalContent(parts)) return null;
+		return {
+			key: key || undefined,
+			timeSig: timeSig || undefined,
+			parts,
+			partial: partial || undefined,
+		};
+	};
 
 	const tupletEvent = (ratio, events) => ({
 		type: 'tuplet',
@@ -74,6 +98,12 @@
 		events,
 	});
 
+	const timesEvent = (ratio, events) => ({
+		type: 'times',
+		ratio,
+		events,
+	});
+
 	const tremoloEvent = (pitchA, pitchB, count, division) => ({
 		type: 'tremolo',
 		pitchA,
@@ -131,6 +161,9 @@
 	let numericTimeSignature = false; // When true, 4/4 and 2/2 use numeric display instead of C/C|
 	let currentOttava = 0; // Current ottava level, resets on newline
 
+	// \partial warnings accumulated during parse; reset before each parse
+	let parseWarnings = [];
+
 	// Reset parser state - call before each parse
 	const resetParserState = () => {
 		currentStaff = 1;
@@ -139,10 +172,40 @@
 		currentDuration = { division: 4, dots: 0 };
 		numericTimeSignature = false;
 		currentOttava = 0;
+		parseWarnings = [];
 	};
 
-	// Export reset function
+	// Export reset function and warning accessors
 	parser.resetState = resetParserState;
+	parser.getWarnings = () => parseWarnings;
+
+	// Duration ticks helper for \partial validation (TPQN=480)
+	const durationTicks = (dur) => {
+		let t = 1920 / dur.division; // 1920 = whole note ticks
+		let dot = t / 2;
+		for (let i = 0; i < (dur.dots || 0); i++) { t += dot; dot /= 2; }
+		return Math.round(t);
+	};
+
+	// Sum ticks for an event list (notes/rests only, skip graces)
+	const voiceEventTicks = (events) => {
+		let total = 0;
+		for (const e of events) {
+			if (!e) continue;
+			if (e.type === 'note' || e.type === 'rest') {
+				if (e.grace) continue;
+				total += durationTicks(e.duration);
+			} else if (e.type === 'tuplet' || e.type === 'times') {
+				const factor = e.ratio.numerator / e.ratio.denominator;
+				for (const inner of e.events || []) {
+					if (inner && (inner.type === 'note' || inner.type === 'rest') && !inner.grace) {
+						total += Math.round(durationTicks(inner.duration) * factor);
+					}
+				}
+			}
+		}
+		return total;
+	};
 %}
 
 
@@ -173,12 +236,14 @@
 "\\clef"						return 'CMD_CLEF'
 "\\key"							return 'CMD_KEY'
 "\\time"						return 'CMD_TIME'
+"\\partial"						return 'CMD_PARTIAL'
 "\\numericTimeSignature"		return 'CMD_NUMERIC_TIME_SIG'
 "\\defaultTimeSignature"		return 'CMD_DEFAULT_TIME_SIG'
 "\\tempo"						return 'CMD_TEMPO'
 "\\staff"						return 'CMD_STAFF'
 "\\grace"						return 'CMD_GRACE'
 "\\times"						return 'CMD_TIMES'
+"\\tuplet"						return 'CMD_TUPLET'
 "\\repeat"						return 'CMD_REPEAT'
 "\\ottava"						return 'CMD_OTTAVA'
 "\\stemUp"						return 'CMD_STEMUP'
@@ -313,13 +378,41 @@ header
 	;
 
 measures
-	: measure_content							{ $$ = [$1]; }
-	| measures '|' measure_content				{ $$ = $1.concat([$3]); }
+	: measure_content							{ $$ = $1 ? [$1] : []; }
+	| measures '|' measure_content				{ $$ = $3 ? $1.concat([$3]) : $1; }
 	| measures '|'								{ $$ = $1; }
 	;
 
 measure_content
-	: parts										-> measure($1, currentKey, currentTimeSig)
+	: parts										%{
+		// Check \partial declarations: warn if declared duration ≠ actual voice ticks
+		let partialDur = null;
+		outer: for (const p of $1) {
+			for (const v of p.voices) {
+				for (const e of v.events) {
+					if (e && e.type === 'context' && e.partial) {
+						partialDur = e.partial;
+						break outer;
+					}
+				}
+			}
+		}
+		if (partialDur) {
+			const declared = durationTicks(partialDur);
+			for (const p of $1) {
+				for (const v of p.voices) {
+					const actual = voiceEventTicks(v.events);
+					if (actual > 0 && actual !== declared) {
+						const durStr = partialDur.division + '.'.repeat(partialDur.dots || 0);
+						const msg = `\\partial ${durStr}: declared ${declared} ticks but voice has ${actual} ticks`;
+						console.warn('[lilylet] ' + msg);
+						parseWarnings.push({ type: 'partial-mismatch', message: msg, declared, actual });
+					}
+				}
+			}
+		}
+		$$ = measure($1, currentKey, currentTimeSig, partialDur ? true : undefined);
+	%}
 	;
 
 parts
@@ -429,6 +522,7 @@ context_event
 	: clef_cmd									-> contextChange({ clef: $1 })
 	| key_cmd									-> contextChange({ key: $1 })
 	| time_cmd									-> contextChange({ time: $1 })
+	| partial_cmd								-> contextChange({ partial: $1 })
 	| tempo_cmd									-> contextChange({ tempo: $1 })
 	| staff_cmd									-> contextChange({ staff: $1 })
 	| ottava_cmd								-> contextChange({ ottava: $1 })
@@ -480,6 +574,10 @@ default_time_sig_cmd
 	: CMD_DEFAULT_TIME_SIG						%{ numericTimeSignature = false; $$ = null; %}
 	;
 
+partial_cmd
+	: CMD_PARTIAL duration						-> $2
+	;
+
 tempo_cmd
 	: CMD_TEMPO STRING duration '=' NUMBER		-> ({ text: $2.slice(1, -1), beat: $3, bpm: Number($5) })
 	| CMD_TEMPO STRING							-> ({ text: $2.slice(1, -1) })
@@ -509,7 +607,8 @@ grace_event
 	;
 
 tuplet_event
-	: CMD_TIMES NUMBER '/' NUMBER '{' voice_events '}'		-> tupletEvent(fraction(Number($2), Number($4)), $6.filter(e => e.type === 'note' || e.type === 'rest'))
+	: CMD_TIMES NUMBER '/' NUMBER '{' voice_events '}'		-> timesEvent(fraction(Number($2), Number($4)), $6.filter(e => e.type === 'note' || e.type === 'rest' || e.type === 'context'))
+	| CMD_TUPLET NUMBER '/' NUMBER '{' voice_events '}'		-> tupletEvent(fraction(Number($4), Number($2)), $6.filter(e => e.type === 'note' || e.type === 'rest' || e.type === 'context'))
 	;
 
 tremolo_pitches

package/source/lilylet/lilypondDecoder.ts

@@ -489,6 +489,42 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 
 	const interpreter = lilyDocument.interpret();
 
+	// Pre-compute partIndex for each track using staff-number-sequence heuristic.
+	// When staff numbers reset (decrease), a new part starts — this handles multi-PianoStaff
+	// scores where both pianos reuse the same staff names ("1" and "2").
+	// Scores that embed partIndex in the staff name ("1_1", "1_2", "2_1") are handled
+	// by parseStaffName; this heuristic only kicks in for plain numeric names.
+	let _seqPart = 1;
+	let _seqMaxStaff = 0;
+	const _trackPartIndices: number[] = interpreter.layoutMusic.musicTracks.map((track: any) => {
+		const staffName: string | undefined = track.contextDict?.Staff;
+		if (staffName && /^\d+_\d+$/.test(staffName)) {
+			// Staff name encodes partIndex explicitly — don't apply heuristic
+			return parseInt(staffName.split('_')[0], 10);
+		}
+		// PianoStaff is present (even as empty string "") when inside a grand-staff group;
+		// undefined means standalone instrument → different part from grand-staff tracks.
+		const hasPianoStaff = (track.contextDict?.PianoStaff !== undefined);
+		const staffNum = parseInt(staffName || '1', 10) || 1;
+
+		if (hasPianoStaff) {
+			// Grand-staff: new part if transitioning from standalone or staff resets
+			if (_seqMaxStaff > 0 && staffNum < _seqMaxStaff) {
+				_seqPart++;
+				_seqMaxStaff = 0;
+			} else if (_seqMaxStaff === -1) {
+				// Transitioning from a standalone group
+				_seqPart++;
+				_seqMaxStaff = 0;
+			}
+			_seqMaxStaff = Math.max(_seqMaxStaff, staffNum);
+		} else {
+			// Standalone: mark with -1 so next grand-staff group increments
+			_seqMaxStaff = -1;
+		}
+		return _seqPart;
+	});
+
 	interpreter.layoutMusic.musicTracks.forEach((track, vi) => {
 		const appendStaff = (staffName: string): void => {
 			if (!staffNames.includes(staffName)) {
@@ -498,15 +534,20 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 
 		// Parse staff name to extract partIndex and staff number
 		// Format: "partIndex_staffIndex" (e.g., "1_1", "1_2", "2_1")
-		// Falls back to partIndex=1 if format doesn't match
+		// Falls back to positional ordering for non-numeric names (e.g., "upper"→1, "lower"→2)
 		const parseStaffName = (name: string): { partIndex: number; staffNum: number } => {
 			const match = name.match(/^(\d+)_(\d+)$/);
 			if (match) {
 				return { partIndex: parseInt(match[1], 10), staffNum: parseInt(match[2], 10) };
 			}
-			// Fallback: single part, staff number from name or 1
 			const num = parseInt(name, 10);
-			return { partIndex: 1, staffNum: isNaN(num) ? 1 : num };
+			if (!isNaN(num)) {
+				return { partIndex: 1, staffNum: num };
+			}
+			// Non-numeric name: assign staffNum by order of first appearance in staffNames
+			appendStaff(name);
+			const idx = staffNames.indexOf(name);
+			return { partIndex: 1, staffNum: idx + 1 };
 		};
 
 		// Use track.contextDict.Staff as the authoritative staff name (from Staff definition)
@@ -515,10 +556,14 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 		if (initialStaffName) {
 			appendStaff(initialStaffName);
 		}
-		const parsedStaff = initialStaffName ? parseStaffName(initialStaffName) : { partIndex: 1, staffNum: 1 };
+		// Empty string staff name ("") means unnamed staff — treat as staff 1 within its part
+		const parsedStaff = (initialStaffName != null && initialStaffName !== '')
+			? parseStaffName(initialStaffName)
+			: { partIndex: 1, staffNum: 1 };
 		// Use these as fixed values for this track - don't update from context.staffName
 		const trackStaff = parsedStaff.staffNum;
-		const trackPartIndex = parsedStaff.partIndex;
+		// Use sequence-based partIndex (detects multi-PianoStaff via staff number reset)
+		const trackPartIndex = _trackPartIndices[vi] ?? parsedStaff.partIndex;
 
 		// Track emitted context events across measures for this voice
 		let lastKey: number | undefined = undefined;  // Track value changes (key fifths)
@@ -526,6 +571,7 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 		let lastClef: Clef | undefined = undefined;  // Track value changes
 		let lastOttava: number | undefined = undefined;  // Track value changes
 		let lastStemDirection: string | undefined = undefined;  // Track value changes
+		let partialEmitted = false;  // Emit \partial context once per track
 
 		const context = new lilyParser.TrackContext(undefined, {
 			listener: (term: lilyParser.BaseTerm, context: lilyParser.TrackContext) => {
@@ -553,11 +599,12 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 				}
 				const voice = measure.voices[vi];
 
-				// Update key/time from context on music events
+				// Update key/time/partial from context on music events
 				if (term instanceof lilyParser.MusicEvent ||
 					term instanceof lilyParser.LilyTerms.StemDirection ||
 					term instanceof lilyParser.LilyTerms.OctaveShift ||
-					term instanceof lilyParser.LilyTerms.Change) {
+					term instanceof lilyParser.LilyTerms.Change ||
+					term instanceof lilyParser.LilyTerms.Partial) {
 
 					if (context.key && measure.key === null) {
 						measure.key = context.key.key;
@@ -573,6 +620,21 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 					}
 				}
 
+				// Emit \partial context event when the Partial term fires (before partialDuration is cleared)
+				if (term instanceof lilyParser.LilyTerms.Partial && context.partialDuration && !partialEmitted) {
+					const mag = (context.partialDuration as any).magnitude;
+					const WHOLE = 1920;
+					let division = 1, dots = 0;
+					for (const div of [1, 2, 4, 8, 16, 32, 64]) {
+						const base = WHOLE / div;
+						if (Math.abs(mag - base) < 1) { division = div; dots = 0; break; }
+						if (Math.abs(mag - Math.round(base * 1.5)) < 1) { division = div; dots = 1; break; }
+						if (Math.abs(mag - Math.round(base * 1.75)) < 1) { division = div; dots = 2; break; }
+					}
+					voice.events.push({ type: 'context', partial: { division, dots } });
+					partialEmitted = true;
+				}
+
 				// Handle music events
 				if (term instanceof lilyParser.MusicEvent) {
 					// Staff is fixed per track (from track definition)
@@ -706,14 +768,18 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 					}
 					// Process Rest
 					else if (term instanceof lilyParser.LilyTerms.Rest) {
-						const restEvent: RestEvent = {
-							type: 'rest',
-							duration: convertDuration(term.durationValue),
-							fullMeasure: (term.name === 'R') || undefined,
-							invisible: term.isSpacer || undefined,
-						};
+						// Ignore spacer rests inside grace contexts (e.g. \acciaccatura s8,
+						// \grace s4 — these are notation-only placeholders with no musical content)
+						if (!(term.isSpacer && context.inGrace)) {
+							const restEvent: RestEvent = {
+								type: 'rest',
+								duration: convertDuration(term.durationValue),
+								fullMeasure: (term.name === 'R') || undefined,
+								invisible: term.isSpacer || undefined,
+							};
 
-						voice.events.push(restEvent);
+							voice.events.push(restEvent);
+						}
 					}
 				}
 				// Handle standalone stem direction (emit when value changes)
@@ -834,46 +900,71 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 					// Handle tuplet
 					// Note: Lotus emits Chord events BEFORE the Tuplet term, so we need to
 					// remove the already-added notes and wrap them in a TupletEvent
-					else if (termAny.proto === 'Tuplet') {
-						const ratioStr = termAny.args?.[0];  // e.g., "3/2"
-						const body = termAny.args?.[1]?.body || [];
+					else if (termAny.proto === 'Tuplet' || termAny.proto === 'Times') {
+						const isTimes = termAny.proto === 'Times';
+						const ratioStr = termAny.args?.[0];  // "3/2" for \tuplet, "2/3" for \times
+						// \tuplet supports an optional base-duration arg: \tuplet 3/2 4 { notes }
+						// making args = [ratio, baseDur?, body]. Use the last arg (= music block),
+						// matching what lotus Tuplet.music getter does: this.args[this.args.length-1]
+						const body = termAny.args?.[termAny.args.length - 1]?.body || [];
 
 						if (ratioStr && body.length > 0) {
-							// Parse ratio string
 							const ratioMatch = ratioStr.match(/^(\d+)\/(\d+)$/);
 							if (ratioMatch) {
 								const [, num, denom] = ratioMatch;
-								const ratio: Fraction = {
-									numerator: parseInt(denom, 10),  // Swapped: lilylet uses actual/normal
-									denominator: parseInt(num, 10),
+								// \tuplet 3/2: divider = 3/2, lilylet ratio = 2/3 → swap
+								// \times 2/3: factor = 2/3, lilylet ratio = 2/3 → no swap
+								const ratio: Fraction = isTimes
+									? { numerator: parseInt(num, 10), denominator: parseInt(denom, 10) }
+									: { numerator: parseInt(denom, 10), denominator: parseInt(num, 10) };
+
+								// Count sounding (non-grace) notes/rests in the tuplet body,
+								// recursing into AfterGrace.body (main note) but not AfterGrace.grace.
+								// Grace / Acciaccatura / Appoggiatura blocks count as 0.
+								const countSounding = (items: any[]): number => {
+									let n = 0;
+									for (const item of items) {
+										if (!item) continue;
+										switch (item.proto) {
+											case 'Chord': case 'Rest': n++; break;
+											case 'AfterGrace': {
+												// args[0] = main note, args[1] = after-grace notes (0-dur, skip)
+												const main = item.args?.[0];
+												if (main?.proto === 'Chord' || main?.proto === 'Rest') n++;
+												else if (main?.body) n += countSounding(main.body);
+												break;
+											}
+											case 'Grace': case 'Acciaccatura': case 'Appoggiatura': break;
+											default: if (item.body) n += countSounding(item.body); break;
+										}
+									}
+									return n;
 								};
+								const noteCount = countSounding(body);
 
-								// Count how many note/rest events are in the tuplet body
-								const noteCount = body.filter((item: any) =>
-									item.proto === 'Chord' || item.proto === 'Rest'
-								).length;
-
-								// Remove the last noteCount note/rest events from voice.events
-								// (they were already added by the Chord/Rest handlers)
 								const tupletEvents: (NoteEvent | RestEvent)[] = [];
 								let removed = 0;
+								// Pop notes/rests from voice.events, skipping context events.
+								// Grace notes are moved inside the tuplet but do NOT consume a
+								// sounding-note slot (they have 0 duration in the time signature).
 								while (removed < noteCount && voice.events.length > 0) {
 									const lastEvent = voice.events[voice.events.length - 1];
 									if (lastEvent.type === 'note' || lastEvent.type === 'rest') {
 										tupletEvents.unshift(voice.events.pop()! as NoteEvent | RestEvent);
-										removed++;
+										if (!(lastEvent as NoteEvent).grace) removed++;
+									} else if (lastEvent.type === 'context' || lastEvent.type === 'pitchReset') {
+										// Context event between tuplet notes — move it inside tuplet too
+										tupletEvents.unshift(voice.events.pop()! as any);
 									} else {
-										break;  // Stop if we hit a non-note/rest event
+										break;
 									}
 								}
 
 								if (tupletEvents.length > 0) {
-									const tupletEvent: TupletEvent = {
-										type: 'tuplet',
-										ratio,
-										events: tupletEvents,
-									};
-									voice.events.push(tupletEvent);
+									voice.events.push(isTimes
+										? { type: 'times', ratio, events: tupletEvents } as any
+										: { type: 'tuplet', ratio, events: tupletEvents } as TupletEvent
+									);
 								}
 							}
 						}
@@ -924,6 +1015,52 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 		});
 
 		context.execute(track.music);
+
+		// Post-process: carry staff state across measure boundaries for this voice.
+		// If measure N ends on staff 2 (via \change Staff), measure N+1 must begin
+		// with context { staff: 2 } so notes at the start of that measure serialize
+		// on the correct staff.
+		{
+			const measureIndices = Array.from(measureMap.keys()).sort((a, b) => a - b);
+			let carryStaff = trackStaff;
+			for (const mi of measureIndices) {
+				const voice = measureMap.get(mi)?.voices[vi];
+				if (!voice) continue;
+
+				// Prepend carry-over event if previous measure ended on a different staff,
+				// but skip if the voice's first explicit staff event already resets to
+				// trackStaff — the carry-over would be immediately cancelled (no-op).
+				if (carryStaff !== trackStaff) {
+					// Suppress carry-over if the first staff event resets to trackStaff
+					// AND no musical events (notes/rests/etc.) precede it — meaning the
+					// carry-over would be immediately cancelled with no effect.
+					const firstStaffCtxIdx = voice.events.findIndex(
+						e => e.type === 'context' && (e as any).staff != null
+					);
+					const musicalTypes = new Set(['note', 'rest', 'tuplet', 'times', 'tremolo']);
+					const hasMusicBeforeFirstStaff = firstStaffCtxIdx > 0 &&
+						voice.events.slice(0, firstStaffCtxIdx).some(e => musicalTypes.has(e.type));
+					const immediatelyCancelled = firstStaffCtxIdx >= 0 &&
+						(voice.events[firstStaffCtxIdx] as any).staff === trackStaff &&
+						!hasMusicBeforeFirstStaff;
+					if (!immediatelyCancelled) {
+						voice.events.unshift({ type: 'context', staff: carryStaff } as any);
+					}
+				}
+
+				// Update carryStaff from this measure's events (including inside tuplets)
+				const scanStaff = (events: any[]): void => {
+					for (const e of events) {
+						if (e.type === 'context' && (e as any).staff) {
+							carryStaff = (e as any).staff;
+						} else if ((e.type === 'tuplet' || e.type === 'times') && e.events) {
+							scanStaff(e.events);
+						}
+					}
+				};
+				scanStaff(voice.events);
+			}
+		}
 	});
 
 	// Filter out empty voices and convert to array, sorted by measure number
@@ -944,6 +1081,7 @@ const hasRealContent = (events: Event[]): boolean => {
 		if (e.type === 'note') return true;
 		if (e.type === 'rest' && !(e as RestEvent).invisible) return true;
 		if (e.type === 'tuplet') return true;
+		if (e.type === 'times') return true;
 		if (e.type === 'tremolo') return true;
 		return false;
 	});