@k-l-lambda/lilylet 0.1.49 → 0.1.50

package/source/lilylet/index.ts

@@ -7,13 +7,14 @@ import * as meiEncoder from "./meiEncoder";
 import * as musicXmlDecoder from "./musicXmlDecoder";
 import * as lilypondEncoder from "./lilypondEncoder";
 import * as musicXmlEncoder from "./musicXmlEncoder";
+import * as lilypondDecoder from "./lilypondDecoder";
+import * as abcDecoder from "./abcDecoder";
 
 export {
 	meiEncoder,
 	musicXmlDecoder,
 	lilypondEncoder,
 	musicXmlEncoder,
+	lilypondDecoder,
+	abcDecoder,
 };
-
-// Note: lilypondDecoder is optional and requires @k-l-lambda/lotus
-// Import it directly from '@k-l-lambda/lilylet/lib/lilypondDecoder.js' if needed

package/source/lilylet/lilylet.jison

@@ -165,6 +165,7 @@
 \[opus							return 'HEADER_OPUS'
 \[instrument					return 'HEADER_INSTRUMENT'
 \[genre							return 'HEADER_GENRE'
+\[auto\-beam					return 'HEADER_AUTOBEAM'
 \]								return ']'
 
 \"[^"]*\"						return 'STRING'
@@ -307,6 +308,7 @@ header
 	| HEADER_OPUS STRING ']'					-> ({ opus: $2.slice(1, -1) })
 	| HEADER_INSTRUMENT STRING ']'				-> ({ instrument: $2.slice(1, -1) })
 	| HEADER_GENRE STRING ']'					-> ({ genre: $2.slice(1, -1) })
+	| HEADER_AUTOBEAM STRING ']'				-> ({ autoBeam: $2.slice(1, -1) })
 	;
 
 measures

package/source/lilylet/lilypondDecoder.ts

@@ -641,7 +641,7 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 						}
 					}
 
-					// Process Chord (note or chord)
+					// Process Chord (note or chord, or positioned rest if isRest)
 					if (term instanceof lilyParser.LilyTerms.Chord) {
 						const pitches: Pitch[] = [];
 
@@ -656,40 +656,50 @@ const parseLilyDocument = (lilyDocument: lilyParser.LilyDocument): ParsedMeasure
 						}
 
 						if (pitches.length > 0) {
-							const { marks, harmonyText } = parsePostEvents(term.post_events);
-
-							// Add beam marks
-							if (term.beamOn) {
-								marks.push({ markType: 'beam', start: true });
-							} else if (term.beamOff) {
-								marks.push({ markType: 'beam', start: false });
-							}
+							// Check if this is a positioned rest (a\rest syntax)
+							if (term.isRest) {
+								const restEvent: RestEvent = {
+									type: 'rest',
+									duration: convertDuration(term.durationValue),
+									pitch: pitches[0],  // Use first pitch for positioning
+								};
+								voice.events.push(restEvent);
+							} else {
+								const { marks, harmonyText } = parsePostEvents(term.post_events);
+
+								// Add beam marks
+								if (term.beamOn) {
+									marks.push({ markType: 'beam', start: true });
+								} else if (term.beamOff) {
+									marks.push({ markType: 'beam', start: false });
+								}
 
-							// Add tie
-							if (term.isTying) {
-								marks.push({ markType: 'tie', start: true });
-							}
+								// Add tie
+								if (term.isTying) {
+									marks.push({ markType: 'tie', start: true });
+								}
 
-							const noteEvent: NoteEvent = {
-								type: 'note',
-								pitches,
-								duration: convertDuration(term.durationValue),
-								grace: context.inGrace || undefined,
-							};
+								const noteEvent: NoteEvent = {
+									type: 'note',
+									pitches,
+									duration: convertDuration(term.durationValue),
+									grace: context.inGrace || undefined,
+								};
 
-							if (marks.length > 0) {
-								noteEvent.marks = marks;
-							}
+								if (marks.length > 0) {
+									noteEvent.marks = marks;
+								}
 
-							voice.events.push(noteEvent);
+								voice.events.push(noteEvent);
 
-							// Add harmony event if detected (chord symbol encoded as \bold markup)
-							if (harmonyText) {
-								const harmonyEvent: HarmonyEvent = {
-									type: 'harmony',
-									text: harmonyText,
-								};
-								voice.events.push(harmonyEvent);
+								// Add harmony event if detected (chord symbol encoded as \bold markup)
+								if (harmonyText) {
+									const harmonyEvent: HarmonyEvent = {
+										type: 'harmony',
+										text: harmonyText,
+									};
+									voice.events.push(harmonyEvent);
+								}
 							}
 						}
 					}
@@ -1100,30 +1110,70 @@ const extractMetadata = (lilyDocument: lilyParser.LilyDocument): Metadata | unde
 };
 
 
+// Dedupe consecutive context events in merged voice
+// This is needed because multiple tracks merged into one voice may have redundant context events
+const dedupeContextEvents = (events: Event[]): Event[] => {
+	const result: Event[] = [];
+	let lastStemDirection: string | undefined;
+	let lastClef: string | undefined;
+
+	for (const e of events) {
+		if (e.type === 'context') {
+			const ctx = e as ContextChange;
+
+			// Dedupe stemDirection
+			if ('stemDirection' in ctx) {
+				if (ctx.stemDirection === lastStemDirection) continue;
+				lastStemDirection = ctx.stemDirection;
+			}
+
+			// Dedupe clef
+			if ('clef' in ctx) {
+				if (ctx.clef === lastClef) continue;
+				lastClef = ctx.clef;
+			}
+		}
+		result.push(e);
+	}
+	return result;
+};
+
+
 // Convert parsed measures to LilyletDoc
 const parsedMeasuresToDoc = (parsedMeasures: ParsedMeasure[], metadata?: Metadata): LilyletDoc => {
 	const measures: Measure[] = parsedMeasures.map(pm => {
 		// Filter out voices that only contain spacer rests and context changes
 		const filteredVoices = pm.voices.filter(v => hasRealContent(v.events));
 
-		// Group voices by partIndex
-		const partMap = new Map<number, Array<{ staff: number; events: Event[] }>>();
+		// Group voices by partIndex, then merge voices on the same staff
+		const partMap = new Map<number, Map<number, Event[]>>();
 		for (const v of filteredVoices) {
 			const pi = v.partIndex || 1;
 			if (!partMap.has(pi)) {
-				partMap.set(pi, []);
+				partMap.set(pi, new Map());
+			}
+			const staffMap = partMap.get(pi)!;
+
+			// Merge events from voices on the same staff
+			if (!staffMap.has(v.staff)) {
+				staffMap.set(v.staff, []);
 			}
-			partMap.get(pi)!.push({
-				staff: v.staff,
-				events: v.events,
-			});
+			staffMap.get(v.staff)!.push(...v.events);
 		}
 
-		// Convert to parts array (sorted by part index)
+		// Convert to parts array (sorted by part index, then by staff)
+		// Apply deduplication to merged events
 		const partIndices = Array.from(partMap.keys()).sort((a, b) => a - b);
-		const parts = partIndices.map(pi => ({
-			voices: partMap.get(pi)!,
-		}));
+		const parts = partIndices.map(pi => {
+			const staffMap = partMap.get(pi)!;
+			const staffNums = Array.from(staffMap.keys()).sort((a, b) => a - b);
+			return {
+				voices: staffNums.map(staff => ({
+					staff,
+					events: dedupeContextEvents(staffMap.get(staff)!),
+				})),
+			};
+		});
 
 		// Fallback to single empty part if no voices
 		const measure: Measure = {

package/source/lilylet/meiEncoder.ts

@@ -17,10 +17,12 @@ import {
 	OrnamentType,
 	StemDirection,
 	Mark,
+	Beam,
 	HairpinType,
 	PedalType,
 	NavigationMarkType,
 	Tempo,
+	Event,
 } from "./types";
 
 
@@ -1764,6 +1766,278 @@ const encodeScoreDef = (
 };
 
 
+// === Auto-beam logic ===
+
+// Check if any NoteEvent in the document has a beam mark
+const docHasBeamMarks = (doc: LilyletDoc): boolean => {
+	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 === 'note') {
+						const note = event as NoteEvent;
+						if (note.marks) {
+							for (const m of note.marks) {
+								if (m.markType === 'beam') return true;
+							}
+						}
+					} else if (event.type === 'tuplet') {
+						const tuplet = event as TupletEvent;
+						for (const e of tuplet.events) {
+							if (e.type === 'note') {
+								const note = e as NoteEvent;
+								if (note.marks) {
+									for (const m of note.marks) {
+										if (m.markType === 'beam') return true;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return false;
+};
+
+// Resolve whether auto-beam should be applied
+const resolveAutoBeam = (doc: LilyletDoc): boolean => {
+	if (doc.metadata?.autoBeam === 'off') return false;
+	if (doc.metadata?.autoBeam === 'on') return true;
+	// 'auto' or undefined: auto-beam if no manual beam marks exist
+	return !docHasBeamMarks(doc);
+};
+
+// Compute beam group sizes in eighth-note units for a given time signature
+const getBeamGroups = (timeNum: number, timeDen: number): number[] => {
+	// Compound meters (n/8 where n is divisible by 3, and n > 3)
+	if (timeDen === 8 && timeNum % 3 === 0 && timeNum > 3) {
+		const groupCount = timeNum / 3;
+		return Array(groupCount).fill(3);
+	}
+
+	// Specific common time signatures (LilyPond defaults)
+	if (timeDen === 8 && timeNum === 3) return [3];
+	if (timeDen === 4 && timeNum === 2) return [2, 2];
+	if (timeDen === 4 && timeNum === 3) return [3, 3];
+	if (timeDen === 4 && timeNum === 4) return [4, 4];
+	if (timeDen === 2 && timeNum === 2) return [4, 4];
+
+	// Generic simple meters: each beat = 8/den eighths
+	const eighthsPerBeat = 8 / timeDen;
+	if (eighthsPerBeat >= 1) {
+		return Array(timeNum).fill(eighthsPerBeat);
+	}
+
+	// Fallback: one group for the whole measure
+	const totalEighths = timeNum * 8 / timeDen;
+	return [totalEighths];
+};
+
+// Calculate duration in eighth-note units
+const durationInEighths = (division: number, dots: number, tupletRatio?: { numerator: number; denominator: number }): number => {
+	// Base duration in eighths: 8 / division
+	let dur = 8 / division;
+	// Dot multiplier: 1 + 1/2 + 1/4 + ... = 2 - 1/2^dots
+	if (dots > 0) {
+		dur *= (2 - Math.pow(0.5, dots));
+	}
+	// Tuplet ratio: multiply by num/den (LilyPond semantics)
+	if (tupletRatio) {
+		dur *= tupletRatio.numerator / tupletRatio.denominator;
+	}
+	return dur;
+};
+
+// Apply auto-beam to the document, mutating events' marks arrays in-place
+const applyAutoBeam = (doc: LilyletDoc): void => {
+	// Track time signature across measures
+	let timeNum = 4;
+	let timeDen = 4;
+
+	// Get initial time signature
+	if (doc.measures.length > 0 && doc.measures[0].timeSig) {
+		timeNum = doc.measures[0].timeSig.numerator;
+		timeDen = doc.measures[0].timeSig.denominator;
+	}
+
+	for (const measure of doc.measures) {
+		// Update time signature if changed
+		if (measure.timeSig) {
+			timeNum = measure.timeSig.numerator;
+			timeDen = measure.timeSig.denominator;
+		}
+
+		const beamGroups = getBeamGroups(timeNum, timeDen);
+
+		for (const part of measure.parts) {
+			for (const voice of part.voices) {
+				applyAutoBeamToVoice(voice.events, beamGroups);
+			}
+		}
+	}
+};
+
+// A beamable note reference: points to a NoteEvent that can receive beam marks
+interface BeamableNote {
+	note: NoteEvent;
+	position: number; // position in eighths at start of this note
+}
+
+// Apply auto-beam to a single voice's events
+const applyAutoBeamToVoice = (events: Event[], beamGroups: number[]): void => {
+	// Compute group boundary positions in eighths
+	const groupBoundaries: number[] = [];
+	let boundary = 0;
+	for (const size of beamGroups) {
+		boundary += size;
+		groupBoundaries.push(boundary);
+	}
+	const totalMeasureEighths = boundary;
+
+	// Collect beamable notes with their positions
+	let position = 0;
+	const beamableRuns: BeamableNote[][] = [];
+	let currentRun: BeamableNote[] = [];
+
+	// Helper: find which group index a position belongs to
+	const getGroupIndex = (pos: number): number => {
+		for (let i = 0; i < groupBoundaries.length; i++) {
+			if (pos < groupBoundaries[i]) return i;
+		}
+		return groupBoundaries.length - 1;
+	};
+
+	// Helper: flush current run into beamableRuns
+	const flushRun = () => {
+		if (currentRun.length >= 2) {
+			beamableRuns.push(currentRun);
+		}
+		currentRun = [];
+	};
+
+	for (const event of events) {
+		if (event.type === 'note') {
+			const note = event as NoteEvent;
+			if (note.grace) continue; // skip grace notes
+
+			const dur = durationInEighths(note.duration.division, note.duration.dots);
+
+			if (note.duration.division >= 8) {
+				// Beamable note
+				const groupIdx = getGroupIndex(position);
+				const noteEndPos = position + dur;
+				const endGroupIdx = getGroupIndex(Math.min(noteEndPos - 0.001, totalMeasureEighths - 0.001));
+
+				// Note must start and end within the same group
+				if (groupIdx === endGroupIdx) {
+					// Check if current run is in the same group
+					if (currentRun.length > 0) {
+						const lastGroupIdx = getGroupIndex(currentRun[0].position);
+						if (lastGroupIdx !== groupIdx) {
+							flushRun();
+						}
+					}
+					currentRun.push({ note, position });
+				} else {
+					// Note spans group boundary — break
+					flushRun();
+				}
+			} else {
+				// Non-beamable note (quarter or longer) — break
+				flushRun();
+			}
+
+			position += dur;
+		} else if (event.type === 'rest') {
+			const rest = event as RestEvent;
+			const dur = durationInEighths(rest.duration.division, rest.duration.dots);
+			// Rests break beam groups
+			flushRun();
+			position += dur;
+		} else if (event.type === 'tuplet') {
+			const tuplet = event as TupletEvent;
+			const ratio = tuplet.ratio; // LilyPond ratio: num/den
+
+			// Check if all inner notes are beamable (division >= 8)
+			const innerNotes: { note: NoteEvent; dur: number }[] = [];
+			let allBeamable = true;
+			let tupletDur = 0;
+
+			for (const e of tuplet.events) {
+				if (e.type === 'note') {
+					const note = e as NoteEvent;
+					if (note.grace) continue;
+					const dur = durationInEighths(note.duration.division, note.duration.dots, ratio);
+					innerNotes.push({ note, dur });
+					tupletDur += dur;
+					if (note.duration.division < 8) {
+						allBeamable = false;
+					}
+				} else if (e.type === 'rest') {
+					allBeamable = false;
+					const dur = durationInEighths(e.duration.division, e.duration.dots, ratio);
+					tupletDur += dur;
+				}
+			}
+
+			if (allBeamable && innerNotes.length > 0) {
+				const groupIdx = getGroupIndex(position);
+				const endGroupIdx = getGroupIndex(Math.min(position + tupletDur - 0.001, totalMeasureEighths - 0.001));
+
+				if (groupIdx === endGroupIdx) {
+					// Tuplet fits within one group — add inner notes to current run
+					if (currentRun.length > 0) {
+						const lastGroupIdx = getGroupIndex(currentRun[0].position);
+						if (lastGroupIdx !== groupIdx) {
+							flushRun();
+						}
+					}
+					let innerPos = position;
+					for (const { note, dur } of innerNotes) {
+						currentRun.push({ note, position: innerPos });
+						innerPos += dur;
+					}
+				} else {
+					flushRun();
+				}
+			} else {
+				flushRun();
+			}
+
+			position += tupletDur;
+		} else if (event.type === 'context' || event.type === 'pitchReset' || event.type === 'barline' || event.type === 'harmony' || event.type === 'markup') {
+			// Non-musical events: don't advance position, don't break beams
+			continue;
+		} else if (event.type === 'tremolo') {
+			// Tremolo breaks beams
+			const trem = event as TremoloEvent;
+			// Total duration = count * 2 * (1/division) in whole notes
+			// In eighths: count * 2 * (8/division)
+			const dur = trem.count * 2 * (8 / trem.division);
+			flushRun();
+			position += dur;
+		}
+	}
+
+	// Flush any remaining run
+	flushRun();
+
+	// Apply beam marks to collected runs
+	for (const run of beamableRuns) {
+		const first = run[0].note;
+		const last = run[run.length - 1].note;
+
+		if (!first.marks) first.marks = [];
+		first.marks.push({ markType: 'beam', start: true } as Beam);
+
+		if (!last.marks) last.marks = [];
+		last.marks.push({ markType: 'beam', start: false } as Beam);
+	}
+};
+
+
 // Main encode function
 const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 	const indent = options.indent || "    ";
@@ -1797,6 +2071,12 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 
 	const keySig = KEY_SIGS[currentKey] || "0";
 
+	// Apply auto-beam if needed (before encoding so beam marks are picked up by encodeLayer)
+	const shouldAutoBeam = resolveAutoBeam(doc);
+	if (shouldAutoBeam) {
+		applyAutoBeam(doc);
+	}
+
 	// Build MEI document
 	const xmlDecl = options.xmlDeclaration !== false
 		? '<?xml version="1.0" encoding="UTF-8"?>\n'

package/source/lilylet/musicXmlDecoder.ts

@@ -66,6 +66,7 @@ import {
 	convertBarlineStyle,
 	convertHarmonyToText,
 	createFraction,
+	TYPE_TO_DIVISION,
 } from './musicXmlUtils';
 
 // ============ Spanner Tracker ============
@@ -163,12 +164,9 @@ class TupletTracker {
 		// Add to all active tuplets (in case of nested tuplets)
 		for (const [, tuplet] of this.activeTuplets) {
 			// Set ratio from first event's duration.tuplet
+			// convertDuration already stores Lilylet ratio semantics (normalNotes/actualNotes)
 			if (!tuplet.ratio && event.duration.tuplet) {
-				// In Lilylet, ratio is denominator/numerator (e.g., 2/3 for triplet)
-				tuplet.ratio = {
-					numerator: event.duration.tuplet.denominator,
-					denominator: event.duration.tuplet.numerator,
-				};
+				tuplet.ratio = { ...event.duration.tuplet };
 			}
 			// Store event without tuplet info in duration (it's handled at TupletEvent level)
 			const cleanEvent = { ...event, duration: { ...event.duration } };
@@ -237,6 +235,7 @@ class VoiceTracker {
 	private currentPosition: number = 0;
 	private divisions: number = 1;
 	private staves: number = 1;
+	private currentStaff: Map<number, number> = new Map();
 
 	setDivisions(div: number): void {
 		this.divisions = div;
@@ -260,6 +259,7 @@ class VoiceTracker {
 				events: [],
 				staff,
 			});
+			this.currentStaff.set(voiceNum, staff);
 		}
 		const voice = this.voices.get(voiceNum)!;
 		// Update staff if specified
@@ -271,6 +271,11 @@ class VoiceTracker {
 
 	addEvent(voiceNum: number, event: Event, duration: number, staff: number = 1): void {
 		const voice = this.getOrCreateVoice(voiceNum, staff);
+		const prevStaff = this.currentStaff.get(voiceNum) || 1;
+		if (staff > 0 && staff !== prevStaff) {
+			voice.events.push({ type: 'context', staff } as ContextChange);
+			this.currentStaff.set(voiceNum, staff);
+		}
 		voice.events.push(event);
 		voice.lastEvent = event;
 		this.currentPosition += duration;
@@ -306,6 +311,7 @@ class VoiceTracker {
 	reset(): void {
 		this.voices.clear();
 		this.currentPosition = 0;
+		this.currentStaff.clear();
 	}
 }
 
@@ -825,20 +831,6 @@ const notationsToMarks = (
 	return marks;
 };
 
-// MusicXML beat-unit to division mapping
-const BEAT_UNIT_TO_DIVISION: Record<string, number> = {
-	'maxima': 0.125,
-	'long': 0.25,
-	'breve': 0.5,
-	'whole': 1,
-	'half': 2,
-	'quarter': 4,
-	'eighth': 8,
-	'16th': 16,
-	'32nd': 32,
-	'64th': 64,
-};
-
 // Common tempo words that should be converted to \tempo
 const TEMPO_WORDS = new Set([
 	// Very slow
@@ -878,7 +870,7 @@ const directionToContextChange = (
 	// Metronome → Tempo (may combine with words)
 	if (direction.metronome) {
 		const { beatUnit, beatUnitDot, perMinute } = direction.metronome;
-		const division = BEAT_UNIT_TO_DIVISION[beatUnit] || 4;
+		const division = TYPE_TO_DIVISION[beatUnit] || 4;
 
 		// Check if there's accompanying tempo text
 		let tempoText: string | undefined;
@@ -1078,6 +1070,10 @@ const convertMeasure = (
 			const staffNum = note.staff || 1;
 			currentVoice = voiceNum;
 
+			// Ensure voice exists with correct staff tracking (needed for cross-staff tuplets
+			// where notes go to tupletTracker but voice must be initialized for staff detection)
+			voiceTracker.getOrCreateVoice(voiceNum, staffNum);
+
 			// Check for tuplet start BEFORE processing the note
 			const tupletNotation = note.notations?.tuplet;
 			if (tupletNotation?.type === 'start') {
@@ -1283,6 +1279,7 @@ const convertPart = (partEl: Element): { measures: Measure[]; name?: string } =>
 	let lastKey: KeySignature | undefined;
 	let lastTimeSig: Fraction | undefined;
 	let isFirstMeasure = true;
+	let lastVoiceStaff = 1;  // Track last known primary voice staff for empty measure fallback
 	const lastClefs: Map<number, ContextChange> = new Map();  // Track last clef per staff
 
 	const measureEls = getDirectChildren(partEl, 'measure');
@@ -1351,7 +1348,9 @@ const convertPart = (partEl: Element): { measures: Measure[]; name?: string } =>
 
 		// If no voices found, create an empty one
 		if (voices.length === 0) {
-			voices.push({ staff: 1, events: [] });
+			voices.push({ staff: lastVoiceStaff, events: [] });
+		} else {
+			lastVoiceStaff = voices[0].staff || 1;
 		}
 
 		const measure: Measure = {
@@ -1395,19 +1394,67 @@ export const decode = (xmlString: string): LilyletDoc => {
 	// Parse metadata
 	const metadata = parseMetadata(doc);
 
+	// Parse <part-list> to get part names
+	const partNames: Map<string, string> = new Map();
+	const partListEl = doc.getElementsByTagName('part-list')[0];
+	if (partListEl) {
+		const scorePartEls = getElements(partListEl, 'score-part');
+		for (const sp of scorePartEls) {
+			const id = getAttribute(sp, 'id');
+			const name = getElementText(sp, 'part-name');
+			if (id && name) {
+				partNames.set(id, name);
+			}
+		}
+	}
+
 	// Get parts
-	const partEls = Array.from(doc.getElementsByTagName('part'));
+	const partEls = getDirectChildren(root, 'part');
 	if (partEls.length === 0) {
 		throw new Error('No parts found in MusicXML');
 	}
 
-	// For now, convert only the first part
-	// TODO: Handle multiple parts
-	const firstPart = partEls[0];
-	const { measures } = convertPart(firstPart);
+	// Convert all parts
+	const allPartResults: { measures: Measure[]; name?: string; partId?: string }[] = [];
+	for (const partEl of partEls) {
+		const partId = getAttribute(partEl, 'id') || undefined;
+		const { measures } = convertPart(partEl);
+		const name = partId ? partNames.get(partId) : undefined;
+		allPartResults.push({ measures, name, partId });
+	}
+
+	// Merge parts: combine into multi-part measures
+	const numMeasures = Math.max(...allPartResults.map(p => p.measures.length));
+	const mergedMeasures: Measure[] = [];
+
+	for (let mi = 0; mi < numMeasures; mi++) {
+		const parts: Part[] = [];
+
+		for (const partResult of allPartResults) {
+			const sourceMeasure = partResult.measures[mi];
+			if (sourceMeasure && sourceMeasure.parts.length > 0) {
+				const part = sourceMeasure.parts[0];
+				if (partResult.name) {
+					part.name = partResult.name;
+				}
+				parts.push(part);
+			} else {
+				// Empty part placeholder
+				parts.push({ voices: [{ staff: 1, events: [] }] });
+			}
+		}
+
+		// Use key/timeSig from the first part's measure (they should be consistent)
+		const firstPartMeasure = allPartResults[0].measures[mi];
+		const measure: Measure = { parts };
+		if (firstPartMeasure?.key) measure.key = firstPartMeasure.key;
+		if (firstPartMeasure?.timeSig) measure.timeSig = firstPartMeasure.timeSig;
+
+		mergedMeasures.push(measure);
+	}
 
 	const result: LilyletDoc = {
-		measures,
+		measures: mergedMeasures,
 	};
 
 	if (Object.keys(metadata).length > 0) {