@k-l-lambda/lilylet 0.1.59 → 0.1.62

package/source/lilylet/lilypondEncoder.ts

@@ -15,6 +15,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	HarmonyEvent,
@@ -164,6 +165,53 @@ const getSpacerRest = (timeSig?: { numerator: number; denominator: number }): st
 };
 
 
+// === Partial Measure Helpers ===
+
+const TPQN = 480;
+
+const voiceDurationTicks = (voice: Voice): number => {
+	let ticks = 0;
+	const addEvent = (e: Event, factor = 1): void => {
+		if (e.type === 'note' || e.type === 'rest') {
+			const ev = e as NoteEvent | RestEvent;
+			if ((ev as NoteEvent).grace) return;
+			let t = (TPQN * 4) / ev.duration.division;
+			let dot = t / 2;
+			for (let i = 0; i < ev.duration.dots; i++) { t += dot; dot /= 2; }
+			ticks += Math.round(t * factor);
+		} else if (e.type === 'tuplet' || e.type === 'times') {
+			const te = e as TupletEvent;
+			const f = factor * te.ratio.numerator / te.ratio.denominator;
+			for (const inner of te.events) addEvent(inner as Event, f);
+		}
+	};
+	for (const e of voice.events) addEvent(e);
+	return ticks;
+};
+
+const ticksToLyDuration = (ticks: number): string => {
+	const whole = TPQN * 4;
+	for (const div of [1, 2, 4, 8, 16, 32, 64]) {
+		const t = whole / div;
+		if (Math.abs(ticks - t) < 1) return String(div);
+		if (Math.abs(ticks - Math.round(t * 1.5)) < 1) return `${div}.`;
+		if (Math.abs(ticks - Math.round(t * 1.75)) < 1) return `${div}..`;
+	}
+	return '4';
+};
+
+// Return a spacer-rest suffix to pad a voice to the full measure duration.
+// Uses s16*N to avoid complexity with dotted/compound values.
+const padVoiceToMeasure = (voiceTicks: number, measureTicks: number): string => {
+	const remaining = Math.round(measureTicks - voiceTicks);
+	if (remaining <= 0) return '';
+	const sixteenth = Math.round(TPQN / 4); // 120 ticks
+	const numSixteenths = Math.round(remaining / sixteenth);
+	if (numSixteenths <= 0) return '';
+	return numSixteenths === 1 ? ' s16' : ` s16*${numSixteenths}`;
+};
+
+
 // === Pitch Environment for Relative Mode ===
 
 interface PitchEnv {
@@ -509,8 +557,12 @@ const encodeContextChange = (event: ContextChange): string => {
 /**
  * Encode a tuplet event
  */
-const encodeTupletEvent = (event: TupletEvent, env: PitchEnv, lastDuration: Duration | null): { str: string; newEnv: PitchEnv; newDuration: Duration | null } => {
-	let result = `\\tuplet ${event.ratio.denominator}/${event.ratio.numerator} { `;
+const encodeTupletEvent = (event: TupletEvent | TimesEvent, env: PitchEnv, lastDuration: Duration | null): { str: string; newEnv: PitchEnv; newDuration: Duration | null } => {
+	// \times preserves type:"times"; \tuplet is denominator/numerator
+	const header = event.type === 'times'
+		? `\\times ${event.ratio.numerator}/${event.ratio.denominator}`
+		: `\\tuplet ${event.ratio.denominator}/${event.ratio.numerator}`;
+	let result = `${header} { `;
 	let newEnv = env;
 	let newDuration = lastDuration;
 
@@ -650,8 +702,9 @@ const encodeVoice = (
 				result += encodeContextChange(event) + ' ';
 				break;
 			}
-			case 'tuplet': {
-				const { str, newEnv, newDuration } = encodeTupletEvent(event, env, lastDuration);
+			case 'tuplet':
+			case 'times': {
+				const { str, newEnv, newDuration } = encodeTupletEvent(event as TupletEvent | TimesEvent, env, lastDuration);
 				result += str + ' ';
 				env = newEnv;
 				lastDuration = newDuration;
@@ -740,7 +793,7 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		for (const part of measure.parts) {
 			for (const voice of part.voices) {
 				for (const event of voice.events) {
-					if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'tremolo') {
+					if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
 						return true;
 					}
 				}
@@ -769,6 +822,8 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 
 	// Track time signature for each measure (for spacer rests)
 	const measureTimeSigs: Array<{ numerator: number; denominator: number } | undefined> = [];
+	// Track partial (pickup) measure durations as LY duration strings (e.g. "8" for \partial 8)
+	const measurePartialDurs: Array<string | undefined> = [];
 
 	let currentKey: KeySignature | undefined;
 	let currentTimeSig: { numerator: number; denominator: number } | undefined;
@@ -783,6 +838,29 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		// Store time signature for this measure
 		measureTimeSigs[mi] = currentTimeSig;
 
+		// Detect partial (pickup) measures and compute their duration.
+		// Only the first measure (mi===0) can be an implicit partial;
+		// subsequent incomplete measures are NOT treated as partial.
+		const isExplicitPartial = measure.partial === true;
+		if (isExplicitPartial || (mi === 0 && currentTimeSig)) {
+			let maxVoiceTicks = 0;
+			for (const part of measure.parts) {
+				for (const v of part.voices) {
+					maxVoiceTicks = Math.max(maxVoiceTicks, voiceDurationTicks(v));
+				}
+			}
+			const expectedTicks = currentTimeSig
+				? Math.round(TPQN * 4 * currentTimeSig.numerator / currentTimeSig.denominator)
+				: TPQN * 4;
+			if (maxVoiceTicks > 0 && maxVoiceTicks < expectedTicks) {
+				measurePartialDurs[mi] = ticksToLyDuration(maxVoiceTicks);
+			} else {
+				measurePartialDurs[mi] = undefined;
+			}
+		} else {
+			measurePartialDurs[mi] = undefined;
+		}
+
 		// Process each part
 		for (let pi = 0; pi < measure.parts.length; pi++) {
 			const part = measure.parts[pi];
@@ -803,12 +881,21 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 				}
 
 				// Encode voice content
-				const voiceContent = encodeVoice(voice, {
+				let voiceContent = encodeVoice(voice, {
 					key: currentKey,
 					timeSig: currentTimeSig,
 					isFirst: mi === 0
 				}, vi);
 
+				// For non-partial measures, pad incomplete voices to fill the full
+				// measure duration. lotus doesn't auto-advance on barlines, so
+				// under-full voices cause measure boundary miscounting.
+				if (!measurePartialDurs[mi] && currentTimeSig) {
+					const expectedTicks = Math.round(TPQN * 4 * currentTimeSig.numerator / currentTimeSig.denominator);
+					const voiceTicks = voiceDurationTicks(voice);
+					voiceContent += padVoiceToMeasure(voiceTicks, expectedTicks);
+				}
+
 				staffMeasures[mi].push(voiceContent);
 			}
 		}
@@ -823,10 +910,28 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		// Build voice lines
 		const voiceLines: string[] = [];
 		for (let vi = 0; vi < maxVoices; vi++) {
+			let prevTimeSigStr: string | undefined;
 			const measureContents = measures.map((m, mi) => {
-				// Use correct spacer rest based on time signature
-				const spacer = getSpacerRest(measureTimeSigs[mi]);
-				const content = m[vi] || spacer;
+				// For partial (pickup) measures, use a partial-duration spacer
+				const partialDur = measurePartialDurs[mi];
+				const spacer = partialDur ? `s${partialDur}` : getSpacerRest(measureTimeSigs[mi]);
+				let content = m[vi] || spacer;
+				// Inject \time if the content lacks it and the time sig changed.
+				// lotus processes each voice independently — without \time it
+				// defaults to 4/4, miscounting measure boundaries for other meters.
+				const ts = measureTimeSigs[mi];
+				if (ts) {
+					const tsStr = `${ts.numerator}/${ts.denominator}`;
+					if (tsStr !== prevTimeSigStr && !content.includes('\\time')) {
+						content = `${encodeTimeSig(ts)} ${content}`;
+					}
+					prevTimeSigStr = tsStr;
+				}
+				// For partial measures, prepend \partial DUR before all other commands
+				// so the lotus interpreter correctly tracks the pickup measure boundary.
+				if (partialDur && !content.includes('\\partial')) {
+					content = `\\partial ${partialDur} ${content}`;
+				}
 				// Wrap each measure in its own \relative c' to reset pitch context
 				return `${indent}    \\relative c' { ${content} } |  % ${mi + 1}`;
 			});

package/source/lilylet/meiEncoder.ts

@@ -7,6 +7,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	HarmonyEvent,
@@ -943,7 +944,7 @@ interface LayerResult {
 
 
 // Helper: check if an event (or any note inside a tuplet) has beam start/end
-const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
+const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
 	if (event.type === 'note') {
 		const markOptions = extractMarkOptions((event as NoteEvent).marks);
 		return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };

package/source/lilylet/musicXmlDecoder.ts

@@ -1201,9 +1201,9 @@ const convertMeasure = (
 					// Calculate total duration of tuplet for voiceTracker
 					let totalDuration = 0;
 					for (const evt of tupletEvent.events) {
-						if (evt.duration) {
+						if ((evt as NoteEvent | RestEvent).duration) {
 							// Convert division to duration units (quarter = 1)
-							totalDuration += (4 / evt.duration.division) * voiceTracker.getDivisions();
+							totalDuration += (4 / (evt as NoteEvent | RestEvent).duration.division) * voiceTracker.getDivisions();
 						}
 					}
 					// Apply tuplet ratio to get actual duration

package/source/lilylet/musicXmlEncoder.ts

@@ -754,7 +754,7 @@ const encodeMeasure = (
 				}
 
 				case 'tuplet': {
-					const tupletEvents = event.events;
+					const tupletEvents = event.events.filter(e => e.type === 'note' || e.type === 'rest') as (NoteEvent | RestEvent)[];
 					for (let ti = 0; ti < tupletEvents.length; ti++) {
 						const subEvent = tupletEvents[ti];
 						// Set tuplet ratio on duration so encodeDuration emits <time-modification>

package/source/lilylet/parser.ts

@@ -157,6 +157,14 @@ const resolveDocumentPitches = (doc: LilyletDoc): void => {
 };
 
 
+export interface ParseWarning {
+	type: 'partial-mismatch';
+	message: string;
+	declared: number;  // ticks
+	actual: number;    // ticks
+}
+
+
 const parseCode = (code: string): LilyletDoc => {
 	// Reset parser state before each parse to avoid contamination
 	if (parser && (parser as any).resetState) {
@@ -172,7 +180,19 @@ const parseCode = (code: string): LilyletDoc => {
 };
 
 
+/**
+ * Return warnings emitted during the most recent parseCode() call.
+ * Currently reports \partial duration mismatches.
+ */
+const getParseWarnings = (): ParseWarning[] => {
+	if (parser && (parser as any).getWarnings) {
+		return (parser as any).getWarnings() as ParseWarning[];
+	}
+	return [];
+};
+
 
 export {
 	parseCode,
+	getParseWarnings,
 };

package/source/lilylet/serializer.ts

@@ -15,6 +15,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	Pitch,
@@ -400,6 +401,11 @@ const serializeContextChange = (event: ContextChange): string => {
 		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) {
@@ -447,14 +453,17 @@ const serializeTempo = (tempo: Tempo): string => {
 
 // Serialize a tuplet event with pitch environment tracking
 const serializeTupletEvent = (
-	event: TupletEvent,
+	event: TupletEvent | TimesEvent,
 	env: PitchEnv
 ): { str: string; newEnv: PitchEnv } => {
 	const parts: string[] = [];
 	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: Duration | undefined;
 	for (const e of event.events) {
@@ -468,6 +477,15 @@ const serializeTupletEvent = (
 			parts.push(' ' + str);
 			currentEnv = newEnv;
 			prevDuration = (e as RestEvent).duration;
+		} else if (e.type === 'context') {
+			const ctx = e as ContextChange;
+			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');
+			}
 		}
 	}
 
@@ -554,7 +572,8 @@ const serializeEvent = (
 		case 'context':
 			return { str: serializeContextChange(event as ContextChange), newEnv: env };
 		case 'tuplet':
-			return serializeTupletEvent(event as TupletEvent, env);
+		case 'times':
+			return serializeTupletEvent(event as TupletEvent | TimesEvent, env);
 		case 'tremolo':
 			return serializeTremoloEvent(event as TremoloEvent, env);
 		case 'barline':
@@ -607,10 +626,41 @@ const serializeVoice = (
 	// Each voice starts fresh from middle C (step=0, octave=0)
 	let pitchEnv: 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 as ContextChange;
+			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)
@@ -644,10 +694,15 @@ const serializeVoice = (
 	// 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: StemDirection | undefined;
 
-	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 as ContextChange).staff != null) {
+			continue;
+		}
 		if (event.type === 'context') {
 			const ctx = event as ContextChange;
 			// Cross-staff context: update activeStaff and emit \staff directive
@@ -662,7 +717,8 @@ const serializeVoice = (
 				}
 				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;
@@ -712,6 +768,12 @@ const serializeVoice = (
 			prevDuration = (event as NoteEvent).duration;
 		} else if (event.type === 'rest') {
 			prevDuration = (event as RestEvent).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 as ContextChange).clef && emittedClefs) {
 			const ctx = event as ContextChange;
 			emittedClefs[ctx.staff || activeStaff] = ctx.clef!;
@@ -799,7 +861,7 @@ const serializeMeasure = (
 			}
 			staff = newStaff;
 		}
-		parts.push(partStrs.join(' \\\\\\\\\n'));
+		parts.push(partStrs.join(' \\\\\\\n'));
 	}
 
 	return { str: parts.join(' '), newStaff: staff };

package/source/lilylet/types.ts

@@ -229,6 +229,7 @@ export interface ContextChange {
 	type: 'context';
 	key?: KeySignature;
 	time?: Fraction;
+	partial?: Duration;				// Pickup measure duration (check-only, warns if mismatch)
 	clef?: Clef;
 	ottava?: number;				// -1, 0, 1
 	stemDirection?: StemDirection;
@@ -247,7 +248,14 @@ export interface TremoloEvent {
 export interface TupletEvent {
 	type: 'tuplet';
 	ratio: Fraction;				// e.g., {numerator: 2, denominator: 3} for triplet
-	events: (NoteEvent | RestEvent)[];
+	events: (NoteEvent | RestEvent | ContextChange)[];
+}
+
+// TimesEvent: from lilylet \times syntax (distinct from \tuplet decoded from LilyPond)
+export interface TimesEvent {
+	type: 'times';
+	ratio: Fraction;
+	events: (NoteEvent | RestEvent | ContextChange)[];
 }
 
 export interface PitchResetEvent {
@@ -270,7 +278,7 @@ export interface MarkupEvent {
 	placement?: Placement;  // Optional placement (above/below)
 }
 
-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;
 
 // === Structure ===