@k-l-lambda/lilylet 0.1.65 → 0.1.67

package/source/lilylet/abcDecoder.ts

@@ -39,6 +39,34 @@ import {
 
 // ============ Constants ============
 
+// NotaGen catalog tags appear as leading single-% comments in ABC files,
+// in the order: period, composer, instrumentation. They are mapped to
+// Lilylet metadata: period -> genre, instrumentation -> instrument.
+const NOTAGEN_PERIOD_SET = new Set([
+	"Baroque", "Classical", "Romantic",
+]);
+const NOTAGEN_INSTRUMENTATION_SET = new Set([
+	"Art Song", "Chamber", "Choral", "Keyboard", "Orchestral", "Vocal-Orchestral",
+]);
+const NOTAGEN_COMPOSER_SET = new Set([
+	"Bach, Johann Sebastian", "Bartok, Bela", "Beethoven, Ludwig van", "Berlioz, Hector",
+	"Bizet, Georges", "Boulanger, Lili", "Boulton, Harold", "Brahms, Johannes",
+	"Burgmuller, Friedrich", "Butterworth, George", "Chaminade, Cecile", "Chausson, Ernest",
+	"Chopin, Frederic", "Corelli, Arcangelo", "Cornelius, Peter", "Debussy, Claude",
+	"Dvorak, Antonin", "Faisst, Clara", "Faure, Gabriel", "Franz, Robert",
+	"Gonzaga, Chiquinha", "Grandval, Clemence de", "Grieg, Edvard", "Handel, George Frideric",
+	"Haydn, Joseph", "Hensel, Fanny", "Holmes, Augusta Mary Anne", "Jaell, Marie",
+	"Kinkel, Johanna", "Kralik, Mathilde", "Lang, Josephine", "Lehmann, Liza",
+	"Liszt, Franz", "Mayer, Emilie", "Medtner, Nikolay", "Mendelssohn, Felix",
+	"Mozart, Wolfgang Amadeus", "Munktell, Helena", "Paradis, Maria Theresia von",
+	"Parratt, Walter", "Prokofiev, Sergey", "Rachmaninoff, Sergei", "Ravel, Maurice",
+	"Reichardt, Louise", "Saint-Georges, Joseph Bologne", "Saint-Saens, Camille",
+	"Satie, Erik", "Scarlatti, Domenico", "Schroter, Corona", "Schubert, Franz",
+	"Schumann, Clara", "Schumann, Robert", "Scriabin, Aleksandr", "Shostakovich, Dmitry",
+	"Sibelius, Jean", "Smetana, Bedrich", "Tchaikovsky, Pyotr", "Viardot, Pauline",
+	"Vivaldi, Antonio", "Warlock, Peter", "Wolf, Hugo", "Zumsteeg, Emilie",
+]);
+
 const ABC_PHONET_MAP: Record<string, Phonet> = {
 	"C": Phonet.c, "D": Phonet.d, "E": Phonet.e, "F": Phonet.f, "G": Phonet.g, "A": Phonet.a, "B": Phonet.b,
 	"c": Phonet.c, "d": Phonet.d, "e": Phonet.e, "f": Phonet.f, "g": Phonet.g, "a": Phonet.a, "b": Phonet.b,
@@ -286,12 +314,20 @@ const convertKeySignature = (abcKey: ABC.KeySignature): KeySignature => {
  * Convert ABC clef string to Lilylet Clef
  */
 const convertClef = (clefStr: string): Clef | undefined => {
-	switch (clefStr?.toLowerCase()) {
-		case "treble": return Clef.treble;
-		case "bass": return Clef.bass;
-		case "alto": case "tenor": return Clef.alto;
+	// Split off an optional ABC octave shift suffix: "treble-8", "bass+8", "treble-15".
+	// ABC: "-N" lowers the sounding pitch (small N drawn below), "+N" raises it.
+	// LilyPond/Lilylet: "_N" = below, "^N" = above. Translate the sign accordingly.
+	const shift = clefStr?.match(/^(.*?)([+-])(8|15)$/);
+	const base = shift ? shift[1] : clefStr;
+	let resolved: string | undefined;
+	switch (base?.toLowerCase()) {
+		case "treble": resolved = "treble"; break;
+		case "bass": resolved = "bass"; break;
+		case "alto": case "tenor": resolved = "alto"; break;
 		default: return undefined;
 	}
+	if (shift) resolved += (shift[2] === "-" ? "_" : "^") + shift[3];
+	return resolved as Clef;
 };
 
 /**
@@ -323,9 +359,60 @@ interface StaffAssignment {
 
 /**
  * Parse %%score layout to determine voice→(part, staff) mapping.
- * {(...) | (...)} = one part with two staves
- * (...) = voices sharing one staff
+ *
+ * Grouping semantics (recursive, any nesting depth):
+ *   [ ... ]  square: each child becomes a separate part        -> serialized with \\\
+ *   ( ... )  arc:    all voices share one staff in one part     -> voices joined with \\
+ *   { ... }  curly:  one part, each child is a separate staff   -> grand staff
+ *   leaf     a bare voice number "1" (often wrapped as {items:["1"]}) -> one part, one staff
+ *
+ * The AST wraps each leaf voice one level deep, e.g. ( 1 2 ) becomes
+ *   {bound:'arc', items:[{items:['1']},{items:['2']}]}
+ * so leaves must be collected recursively rather than assuming a fixed depth.
  */
+
+type ScoreNode = ABC.StaffGroup | string;
+
+// All voice numbers under a node, flattened.
+const collectScoreVoices = (node: ScoreNode): number[] => {
+	if (typeof node === "string") {
+		const v = parseInt(node, 10);
+		return isNaN(v) ? [] : [v];
+	}
+	const voices: number[] = [];
+	for (const item of node.items || []) {
+		voices.push(...collectScoreVoices(item));
+	}
+	return voices;
+};
+
+// Expand a node into a list of parts; each part is a list of staves; each staff is a list of voices.
+const scoreNodeToParts = (node: ScoreNode): number[][][] => {
+	if (typeof node === "string") {
+		const v = parseInt(node, 10);
+		return isNaN(v) ? [] : [[[v]]];
+	}
+
+	if (node.bound === "square") {
+		// each child is its own part
+		const parts: number[][][] = [];
+		for (const child of node.items || []) {
+			parts.push(...scoreNodeToParts(child));
+		}
+		return parts;
+	}
+
+	if (node.bound === "curly") {
+		// one part, each child is a separate staff (grand staff)
+		const staves = (node.items || []).map(child => collectScoreVoices(child)).filter(s => s.length > 0);
+		return staves.length > 0 ? [staves] : [];
+	}
+
+	// arc or no bound: one part, all voices on a single staff
+	const voices = collectScoreVoices(node);
+	return voices.length > 0 ? [[voices]] : [];
+};
+
 const parseScoreLayout = (
 	headers: any[]
 ): Map<number, StaffAssignment> | null => {
@@ -336,78 +423,14 @@ const parseScoreLayout = (
 	const voiceMap = new Map<number, StaffAssignment>();
 
 	let partIndex = 0;
-
-	for (const group of layout) {
-		if (group.bound === "curly") {
-			// Curly braces = one instrument/part with multiple staves
-			let staffInPart = 1;
-			for (const item of group.items) {
-				if (typeof item === "string") {
-					voiceMap.set(parseInt(item), { partIndex, staffInPart });
-				} else if ((item as ABC.StaffGroup).items) {
-					const sg = item as ABC.StaffGroup;
-					for (const subItem of sg.items) {
-						if (typeof subItem === "string") {
-							voiceMap.set(parseInt(subItem), { partIndex, staffInPart });
-						} else if ((subItem as ABC.StaffGroup).items) {
-							for (const leaf of (subItem as ABC.StaffGroup).items) {
-								if (typeof leaf === "string") {
-									voiceMap.set(parseInt(leaf), { partIndex, staffInPart });
-								}
-							}
-						}
-					}
-					staffInPart++;
+	for (const top of layout) {
+		for (const part of scoreNodeToParts(top)) {
+			part.forEach((staff, staffIdx) => {
+				for (const voice of staff) {
+					voiceMap.set(voice, { partIndex, staffInPart: staffIdx + 1 });
 				}
-			}
+			});
 			partIndex++;
-		} else if (group.bound === "arc" || !group.bound) {
-			// Arc or plain = voices sharing a staff in same part
-			for (const item of group.items) {
-				if (typeof item === "string") {
-					voiceMap.set(parseInt(item), { partIndex, staffInPart: 1 });
-				} else if ((item as ABC.StaffGroup).items) {
-					for (const subItem of (item as ABC.StaffGroup).items) {
-						if (typeof subItem === "string") {
-							voiceMap.set(parseInt(subItem), { partIndex, staffInPart: 1 });
-						}
-					}
-				}
-			}
-			partIndex++;
-		} else {
-			// Square bracket or unknown - treat each item as separate part
-			for (const item of group.items) {
-				if (typeof item === "string") {
-					voiceMap.set(parseInt(item), { partIndex, staffInPart: 1 });
-					partIndex++;
-				} else if ((item as ABC.StaffGroup).items) {
-					const sg = item as ABC.StaffGroup;
-					if (sg.bound === "curly") {
-						let staffInPart = 1;
-						for (const subItem of sg.items) {
-							if (typeof subItem === "string") {
-								voiceMap.set(parseInt(subItem), { partIndex, staffInPart });
-							} else if ((subItem as ABC.StaffGroup).items) {
-								for (const leaf of (subItem as ABC.StaffGroup).items) {
-									if (typeof leaf === "string") {
-										voiceMap.set(parseInt(leaf), { partIndex, staffInPart });
-									}
-								}
-								staffInPart++;
-							}
-						}
-						partIndex++;
-					} else {
-						for (const subItem of sg.items) {
-							if (typeof subItem === "string") {
-								voiceMap.set(parseInt(subItem), { partIndex, staffInPart: 1 });
-							}
-						}
-						partIndex++;
-					}
-				}
-			}
 		}
 	}
 
@@ -878,7 +901,14 @@ const decodeTune = (tune: ABC.Tune): LilyletDoc => {
 	}
 
 	for (const h of headers) {
-		if ((h as any).comment) continue;
+		const comment = (h as any).comment;
+		if (typeof comment === "string") {
+			const value = comment.trim();
+			if (!metadata.genre && NOTAGEN_PERIOD_SET.has(value)) metadata.genre = value;
+			else if (!metadata.instrument && NOTAGEN_INSTRUMENTATION_SET.has(value)) metadata.instrument = value;
+			else if (!metadata.composer && NOTAGEN_COMPOSER_SET.has(value)) metadata.composer = value;
+			continue;
+		}
 		if ((h as any).staffLayout) continue;
 
 		const header = h as { name: string; value: any };

package/source/lilylet/meiEncoder.ts

@@ -79,6 +79,41 @@ const CLEF_SHAPES: Record<string, { shape: string; line: number }> = {
 };
 
 
+// Resolve a clef string into MEI shape/line plus optional octave displacement.
+// Octave transposition follows the LilyPond convention: a "_8"/"_15" suffix lowers
+// the sounding pitch by one/two octaves (the small 8/15 is drawn below the clef),
+// and "^8"/"^15" raises it (drawn above). MEI encodes this as dis ("8" | "15")
+// and dis.place ("below" | "above").
+const resolveClef = (clefStr: string): { shape: string; line: number; dis?: "8" | "15"; disPlace?: "above" | "below" } => {
+	const match = clefStr.match(/^(.*?)([_^])(8|15)$/);
+	const base = match ? match[1] : clefStr;
+	const clefInfo = CLEF_SHAPES[base] || CLEF_SHAPES.treble;
+	if (!match) return { shape: clefInfo.shape, line: clefInfo.line };
+	return {
+		shape: clefInfo.shape,
+		line: clefInfo.line,
+		dis: match[3] as "8" | "15",
+		disPlace: match[2] === "^" ? "above" : "below",
+	};
+};
+
+// Attributes for a standalone <clef> element (mid-measure clef change).
+const clefElementAttrs = (clefStr: string): string => {
+	const c = resolveClef(clefStr);
+	let attrs = `shape="${c.shape}" line="${c.line}"`;
+	if (c.dis) attrs += ` dis="${c.dis}" dis.place="${c.disPlace}"`;
+	return attrs;
+};
+
+// Attributes for a <staffDef> clef (clef.* namespace).
+const staffDefClefAttrs = (clefStr: string): string => {
+	const c = resolveClef(clefStr);
+	let attrs = `clef.shape="${c.shape}" clef.line="${c.line}"`;
+	if (c.dis) attrs += ` clef.dis="${c.dis}" clef.dis.place="${c.disPlace}"`;
+	return attrs;
+};
+
+
 // Lilylet duration division to MEI dur
 // division: 1=whole, 2=half, 4=quarter, 8=eighth, etc.
 const DURATIONS: Record<number, string> = {
@@ -178,11 +213,13 @@ const getKeyAccidentals = (fifths: number): Record<string, string> => {
 // The written pitch should be adjusted by subtracting the ottava shift
 // measureAccidentals: tracks accidentals used earlier in the same measure (keyed by "pname-oct")
 //   - mutated to record new accidentals; used to add cancellation naturals
-const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): { pname: string; oct: number; accid?: string; accidGes?: string } => {
+const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>): { pname: string; oct: number; octGes?: number; accid?: string; accidGes?: string } => {
 	// Lilylet octave: 0 = middle C octave (C4), positive = higher, negative = lower
 	// When ottava is active, the source pitch is the sounding pitch, but we need to output the written pitch
 	// For 8va up (ottavaShift=1), written pitch is one octave lower than sounding
-	const oct = 4 + pitch.octave - ottavaShift;
+	const soundingOct = 4 + pitch.octave;
+	const oct = soundingOct - ottavaShift;
+	const octGes = ottavaShift !== 0 ? soundingOct : undefined;
 
 	// Get the accidental implied by the key signature for this note
 	const keyAccidentals = getKeyAccidentals(keyFifths);
@@ -239,7 +276,7 @@ const encodePitch = (pitch: Pitch, keyFifths: number = 0, ottavaShift: number =
 		}
 	}
 
-	return { pname: pitch.phonet, oct, accid, accidGes };
+	return { pname: pitch.phonet, oct, octGes, accid, accidGes };
 };
 
 
@@ -255,7 +292,7 @@ const tremoloToStemMod = (division: number): string | undefined => {
 
 // Build note element
 const buildNoteElement = (
-	pitch: { pname: string; oct: number; accid?: string; accidGes?: string },
+	pitch: { pname: string; oct: number; octGes?: number; accid?: string; accidGes?: string },
 	dur: string,
 	dots: number,
 	indent: string,
@@ -278,6 +315,7 @@ const buildNoteElement = (
 		attrs += ` dur="${dur}"`;
 	}
 	if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
+	if (pitch.octGes !== undefined) attrs += ` oct.ges="${pitch.octGes}"`;
 	if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
 	if (!inChord && dots > 0) attrs += ` dots="${dots}"`;
 	if (!inChord && options.grace) attrs += ` grace="unacc"`;
@@ -754,8 +792,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 				const effectiveStaffNum = effectiveStaff ?? layerStaffNum;
 				if (effectiveStaffNum === layerStaffNum) {
 					const clefIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-					const clefInfo = CLEF_SHAPES[ctx.clef] || CLEF_SHAPES.treble;
-					xml += `${clefIndent}<clef xml:id="${generateId('clef')}" shape="${clefInfo.shape}" line="${clefInfo.line}" />\n`;
+					xml += `${clefIndent}<clef xml:id="${generateId('clef')}" ${clefElementAttrs(ctx.clef)} />\n`;
 				}
 				activeClef = ctx.clef;
 				endingClef = ctx.clef;
@@ -801,6 +838,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 		const pitch = encodePitch(event.pitchA[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
+		if (pitch.octGes !== undefined) attrs += ` oct.ges="${pitch.octGes}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
 		result += `${indent}    <note ${attrs} />\n`;
 	} else if (event.pitchA.length > 1) {
@@ -809,6 +847,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
+			if (pitch.octGes !== undefined) attrs += ` oct.ges="${pitch.octGes}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
 			result += `${indent}        <note ${attrs} />\n`;
 		}
@@ -820,6 +859,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 		const pitch = encodePitch(event.pitchB[0], keyFifths, ottavaShift, measureAccidentals);
 		let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}" dur="${noteDur}"`;
 		if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
+		if (pitch.octGes !== undefined) attrs += ` oct.ges="${pitch.octGes}"`;
 		if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
 		result += `${indent}    <note ${attrs} />\n`;
 	} else if (event.pitchB.length > 1) {
@@ -828,6 +868,7 @@ const tremoloEventToMEI = (event: TremoloEvent, indent: string, keyFifths: numbe
 			const pitch = encodePitch(p, keyFifths, ottavaShift, measureAccidentals);
 			let attrs = `xml:id="${generateId('note')}" pname="${pitch.pname}" oct="${pitch.oct}"`;
 			if (pitch.accid) attrs += ` accid="${pitch.accid}"`;
+			if (pitch.octGes !== undefined) attrs += ` oct.ges="${pitch.octGes}"`;
 			if (pitch.accidGes) attrs += ` accid.ges="${pitch.accidGes}"`;
 			result += `${indent}        <note ${attrs} />\n`;
 		}
@@ -1299,8 +1340,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				if (ctx.clef && ctx.clef !== currentClef) {
 					const layerStaff = voice.staff || 1;
 					if (currentStaff === layerStaff) {
-						const clefInfo = CLEF_SHAPES[ctx.clef] || CLEF_SHAPES.treble;
-						xml += `${currentIndent}<clef xml:id="${generateId('clef')}" shape="${clefInfo.shape}" line="${clefInfo.line}" />\n`;
+						xml += `${currentIndent}<clef xml:id="${generateId('clef')}" ${clefElementAttrs(ctx.clef)} />\n`;
 					}
 					currentClef = ctx.clef;
 				}
@@ -1952,16 +1992,14 @@ const encodeScoreDef = (
 			for (let ls = 1; ls <= info.maxStaff; ls++) {
 				const globalStaff = info.staffOffset + ls;
 				const clef = info.clefs[ls] || Clef.treble;
-				const clefInfo = CLEF_SHAPES[clef] || CLEF_SHAPES.treble;
-				xml += `${indent}            <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" clef.shape="${clefInfo.shape}" clef.line="${clefInfo.line}" />\n`;
+				xml += `${indent}            <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" ${staffDefClefAttrs(clef)} />\n`;
 			}
 			xml += `${indent}        </staffGrp>\n`;
 		} else {
 			// Single staff part
 			const globalStaff = info.staffOffset + 1;
 			const clef = info.clefs[1] || Clef.treble;
-			const clefInfo = CLEF_SHAPES[clef] || CLEF_SHAPES.treble;
-			xml += `${indent}        <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" clef.shape="${clefInfo.shape}" clef.line="${clefInfo.line}" />\n`;
+			xml += `${indent}        <staffDef xml:id="${generateId('staffdef')}" n="${globalStaff}" lines="5" ${staffDefClefAttrs(clef)} />\n`;
 		}
 	}
 

package/source/lilylet/serializer.ts

@@ -383,7 +383,7 @@ const serializeContextChange = (event: ContextChange): string => {
 
 	// Clef
 	if (event.clef) {
-		parts.push('\\clef "' + CLEF_MAP[event.clef] + '"');
+		parts.push('\\clef "' + (CLEF_MAP[event.clef] ?? event.clef) + '"');
 	}
 
 	// Key signature
@@ -688,7 +688,7 @@ const serializeVoice = (
 	const voiceClef = allStaffClefs?.[voice.staff] || findVoiceClef(voice);
 	const clefAlreadyEmitted = voiceClef && emittedClefs?.[voice.staff] === voiceClef;
 	if (voiceClef && !clefAlreadyEmitted) {
-		parts.push('\\clef "' + CLEF_MAP[voiceClef] + '"');
+		parts.push('\\clef "' + (CLEF_MAP[voiceClef] ?? voiceClef) + '"');
 		if (emittedClefs) emittedClefs[voice.staff] = voiceClef;
 	}
 	// Skip redundant clef context events if this staff's clef is already established
@@ -712,7 +712,7 @@ const serializeVoice = (
 				// Emit target staff clef if the event carries one or allStaffClefs knows it
 				const ctxClef = ctx.clef || allStaffClefs?.[activeStaff];
 				if (ctxClef && emittedClefs?.[activeStaff] !== ctxClef) {
-					parts.push('\\clef "' + CLEF_MAP[ctxClef] + '"');
+					parts.push('\\clef "' + (CLEF_MAP[ctxClef] ?? ctxClef) + '"');
 					if (emittedClefs) emittedClefs[activeStaff] = ctxClef;
 				}
 				continue;
@@ -736,7 +736,7 @@ const serializeVoice = (
 				// Emit the target staff's clef if it differs from what was last emitted for this staff
 				const targetClef = allStaffClefs?.[activeStaff];
 				if (targetClef && emittedClefs?.[activeStaff] !== targetClef) {
-					parts.push('\\clef "' + CLEF_MAP[targetClef] + '"');
+					parts.push('\\clef "' + (CLEF_MAP[targetClef] ?? targetClef) + '"');
 					if (emittedClefs) emittedClefs[activeStaff] = targetClef;
 				}
 			}
@@ -802,11 +802,16 @@ const serializePart = (
 	const voiceStrs: string[] = [];
 	let staff = currentStaff;
 
+	// A part is a grand staff only if its voices span more than one staff.
+	// Only then do we force \staff on every voice; single-staff parts emit \staff
+	// solely when the staff actually changes (e.g. resetting after a prior grand staff).
+	const partIsGrandStaff = new Set(part.voices.map(v => v.staff)).size > 1;
+
 	for (let i = 0; i < part.voices.length; i++) {
 		const voice = part.voices[i];
 		// Pass measureContext to all voices, isFirstVoice for key/time
 		const isFirstVoice = isFirstPart && i === 0;
-		const { str, newStaff } = serializeVoice(voice, staff, isGrandStaff, measureContext, isFirstVoice, clefsByStaff, emittedClefs);
+		const { str, newStaff } = serializeVoice(voice, staff, partIsGrandStaff, measureContext, isFirstVoice, clefsByStaff, emittedClefs);
 		voiceStrs.push(str);
 		staff = newStaff;
 	}
@@ -825,8 +830,8 @@ const serializeMeasure = (
 	isGrandStaff: boolean = false,
 	currentKey?: KeySignature,
 	currentTime?: { numerator: number; denominator: number; symbol?: 'common' | 'cut' },
-	staffClefs?: Record<number, Clef>,
-	emittedClefs?: Record<number, Clef>
+	partStaffClefs?: Record<number, Record<number, Clef>>,
+	partEmittedClefs?: Record<number, Record<number, Clef>>
 ): { str: string; newStaff: number } => {
 	const parts: string[] = [];
 
@@ -838,13 +843,15 @@ const serializeMeasure = (
 		time: currentTime,
 	};
 
-	// Pass staffClefs to parts for per-voice clef lookup
-	const clefsByStaff = staffClefs || {};
+	// Per-part clef state: each part has its own staff→clef maps so that distinct
+	// parts sharing staff number 1 do not clobber each other's clefs.
+	const clefsFor = (pi: number) => partStaffClefs?.[pi] || {};
+	const emittedFor = (pi: number) => partEmittedClefs?.[pi] || (partEmittedClefs ? (partEmittedClefs[pi] = {}) : {});
 
 	// Parts
 	let staff = currentStaff;
 	if (measure.parts.length === 1) {
-		const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsByStaff, emittedClefs);
+		const { str: partStr, newStaff } = serializePart(measure.parts[0], staff, isGrandStaff, measureContext, true, clefsFor(0), emittedFor(0));
 		if (partStr) {
 			parts.push(partStr);
 		}
@@ -855,7 +862,7 @@ const serializeMeasure = (
 		for (let i = 0; i < measure.parts.length; i++) {
 			const part = measure.parts[i];
 			// Pass measureContext to all parts, isFirstPart to first part only
-			const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsByStaff, emittedClefs);
+			const { str, newStaff } = serializePart(part, staff, isGrandStaff, measureContext, i === 0, clefsFor(i), emittedFor(i));
 			if (str) {
 				partStrs.push(str);
 			}
@@ -892,6 +899,12 @@ const serializeMetadata = (metadata: Metadata): string => {
 	if (metadata.lyricist) {
 		lines.push('[lyricist "' + escapeString(metadata.lyricist) + '"]');
 	}
+	if (metadata.genre) {
+		lines.push('[genre "' + escapeString(metadata.genre) + '"]');
+	}
+	if (metadata.instrument) {
+		lines.push('[instrument "' + escapeString(metadata.instrument) + '"]');
+	}
 	if (metadata.autoBeam) {
 		lines.push('[auto-beam "' + escapeString(metadata.autoBeam) + '"]');
 	}
@@ -929,8 +942,11 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 	let currentStaff = 1; // Parser starts at staff 1
 	let currentKey: KeySignature | undefined;
 	let currentTime: { numerator: number; denominator: number; symbol?: 'common' | 'cut' } | undefined;
-	const staffClefs: Record<number, Clef> = {}; // Track clef per staff
-	const emittedClefs: Record<number, Clef> = {}; // Track which clefs have been output
+	// Clefs are tracked per part (each part is an independent instrument). Voice `staff`
+	// numbers are staff-within-part, so distinct parts may both use staff 1 — keying clef
+	// state by staff alone would conflate them. Outer key = part index, inner key = staff.
+	const partStaffClefs: Record<number, Record<number, Clef>> = {};
+	const partEmittedClefs: Record<number, Record<number, Clef>> = {};
 
 	for (let i = 0; i < doc.measures.length; i++) {
 		const measure = doc.measures[i];
@@ -942,8 +958,9 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 			currentTime = measure.timeSig;
 		}
 
-		// Collect clefs from this measure's voices
-		for (const part of measure.parts) {
+		// Collect clefs from this measure's voices, per part
+		measure.parts.forEach((part, pi) => {
+			const staffClefs = partStaffClefs[pi] || (partStaffClefs[pi] = {});
 			for (const voice of part.voices) {
 				let clefActiveStaff = voice.staff;
 				for (const event of voice.events) {
@@ -958,9 +975,9 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 					}
 				}
 			}
-		}
+		});
 
-		const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, staffClefs, emittedClefs);
+		const { str: measureStr, newStaff } = serializeMeasure(measure, i === 0, currentStaff, isGrandStaff, currentKey, currentTime, partStaffClefs, partEmittedClefs);
 		// Always include measure, even if empty (use space rest for empty measures)
 		measureStrs.push(measureStr || 's1');
 		currentStaff = newStaff;