@k-l-lambda/lilylet 0.1.66 → 0.1.68

package/source/lilylet/lilylet.jison

@@ -127,6 +127,7 @@
 	const barlineEvent = (style) => ({ type: 'barline', style });
 	const harmonyEvent = (text) => ({ type: 'harmony', text });
 	const markupEvent = (content, placement) => ({ type: 'markup', content, placement: placement || undefined });
+	const dynamicEvent = (type) => ({ type: 'dynamic', dynamicType: type });
 	const markupMark = (content) => ({ markType: 'markup', content });
 
 	// Parse PITCH token (e.g., "c", "cs", "bf", "css", "bff") into phonet and accidental
@@ -445,6 +446,7 @@ event
 	| barline_event
 	| harmony_event
 	| markup_event
+	| dynamic_event
 	;
 
 barline_event
@@ -457,6 +459,12 @@ harmony_event
 
 markup_event
 	: CMD_MARKUP STRING							-> markupEvent($2.slice(1, -1))
+	| '^' CMD_MARKUP STRING						-> markupEvent($3.slice(1, -1), 'above')
+	| '_' CMD_MARKUP STRING						-> markupEvent($3.slice(1, -1), 'below')
+	;
+
+dynamic_event
+	: dynamic_mark								-> dynamicEvent($1.type)
 	;
 
 pitch_reset_event

package/source/lilylet/meiEncoder.ts

@@ -12,6 +12,7 @@ import {
 	BarlineEvent,
 	HarmonyEvent,
 	MarkupEvent,
+	DynamicEvent,
 	Pitch,
 	Clef,
 	Accidental,
@@ -79,6 +80,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> = {
@@ -618,9 +654,10 @@ const noteEventToMEI = (
 
 
 // Convert RestEvent to MEI
-const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>, crossStaff?: number): string => {
+const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0, ottavaShift: number = 0, measureAccidentals?: Map<string, string>, crossStaff?: number): { xml: string; elementId: string } => {
 	const dur = DURATIONS[event.duration.division] || "4";
-	let attrs = `xml:id="${generateId('rest')}" dur="${dur}"`;
+	const restId = generateId('rest');
+	let attrs = `xml:id="${restId}" dur="${dur}"`;
 	if (event.duration.dots > 0) attrs += ` dots="${event.duration.dots}"`;
 
 	// Cross-staff attribute
@@ -634,15 +671,16 @@ const restEventToMEI = (event: RestEvent, indent: string, keyFifths: number = 0,
 
 	// Space rest (invisible)
 	if (event.invisible) {
-		return `${indent}<space ${attrs} />\n`;
+		return { xml: `${indent}<space ${attrs} />\n`, elementId: restId };
 	}
 
 	// Full measure rest
 	if (event.fullMeasure) {
-		return `${indent}<mRest xml:id="${generateId('mrest')}" />\n`;
+		const mRestId = generateId('mrest');
+		return { xml: `${indent}<mRest xml:id="${mRestId}" />\n`, elementId: mRestId };
 	}
 
-	return `${indent}<rest ${attrs} />\n`;
+	return { xml: `${indent}<rest ${attrs} />\n`, elementId: restId };
 };
 
 
@@ -749,7 +787,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 			}
 		} else if (e.type === 'rest') {
 			const restIndent = beamOpen ? baseIndent + '    ' : baseIndent;
-			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals);
+			xml += restEventToMEI(e as RestEvent, restIndent, keyFifths, ottavaShift, measureAccidentals).xml;
 		} else if (e.type === 'context') {
 			const ctx = e as ContextChange;
 			if (ctx.clef && ctx.clef !== activeClef) {
@@ -757,8 +795,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;
@@ -972,7 +1009,7 @@ interface LayerResult {
 
 
 // Helper: check if an event (or any note inside a tuplet) has beam start/end
-const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
+const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | DynamicEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
 	if (event.type === 'note') {
 		const markOptions = extractMarkOptions((event as NoteEvent).marks);
 		return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };
@@ -1045,6 +1082,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 	const barlines: BarlineRef[] = [];
 	const markups: MarkupRef[] = [];
 	const pendingMarkups: { content: string; placement?: 'above' | 'below' }[] = [];
+	const pendingDynamics: string[] = [];
 
 	// Track current stem direction from context changes
 	let currentStemDirection: StemDirection | undefined = undefined;
@@ -1066,6 +1104,14 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 		pendingMarkups.length = 0;
 	};
 
+	// Helper to flush pending leading dynamics onto a note ID
+	const flushPendingDynamics = (noteId: string) => {
+		for (const label of pendingDynamics) {
+			dynamics.push({ startid: noteId, label });
+		}
+		pendingDynamics.length = 0;
+	};
+
 	// Helper to check if pitches match for tie continuation
 	const pitchesMatch = (p1: Pitch[], p2: Pitch[]): boolean => {
 		if (p1.length !== p2.length) return false;
@@ -1135,6 +1181,9 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				// Flush any pending markups onto this note
 				flushPendingMarkups(result.elementId);
 
+				// Flush any pending leading dynamics onto this note
+				flushPendingDynamics(result.elementId);
+
 				// If there's a pending ottava, start the span on this note
 				if (pendingOttava !== null && pendingOttava !== 0) {
 					const dis: 8 | 15 = Math.abs(pendingOttava) === 2 ? 15 : 8;
@@ -1249,7 +1298,12 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 			case 'rest': {
 				// For cross-staff notation: pass staff number if different from voice's home staff
 				const restCrossStaff = currentStaff !== (voice.staff || 1) ? currentStaff : undefined;
-				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
+				const restResult = restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
+				xml += restResult.xml;
+				// A leading dynamic/markup attaches to the next event, which may be this rest
+				flushPendingMarkups(restResult.elementId);
+				flushPendingDynamics(restResult.elementId);
+				lastNoteId = restResult.elementId;
 				break;
 			}
 			case 'tuplet':
@@ -1267,6 +1321,7 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				// Flush any pending markups onto the first note of the tuplet
 				if (tupletResult.firstNoteId) {
 					flushPendingMarkups(tupletResult.firstNoteId);
+					flushPendingDynamics(tupletResult.firstNoteId);
 					lastNoteId = tupletResult.firstNoteId;
 				}
 
@@ -1306,8 +1361,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;
 				}
@@ -1383,6 +1437,13 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				}
 			}
 				break;
+
+			case 'dynamic': {
+				// Standalone (leading) dynamic - attaches to the following note
+				const dynEvent = event as DynamicEvent;
+				pendingDynamics.push(dynEvent.dynamicType);
+			}
+				break;
 		}
 
 		// Close beam element if beam ends
@@ -1959,16 +2020,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

@@ -18,6 +18,8 @@ import {
 	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
+	MarkupEvent,
+	DynamicEvent,
 	Pitch,
 	Duration,
 	Mark,
@@ -383,7 +385,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
@@ -578,6 +580,15 @@ const serializeEvent = (
 			return serializeTremoloEvent(event as TremoloEvent, env);
 		case 'barline':
 			return { str: serializeBarlineEvent(event as BarlineEvent), newEnv: env };
+		case 'markup': {
+			const mk = event as MarkupEvent;
+			const prefix = mk.placement === 'above' ? '^' : mk.placement === 'below' ? '_' : '';
+			return { str: `${prefix}\\markup "${mk.content}"`, newEnv: env };
+		}
+		case 'dynamic': {
+			const dynStr = DYNAMIC_MAP[(event as DynamicEvent).dynamicType];
+			return { str: dynStr || '', newEnv: env };
+		}
 		default:
 			return { str: '', newEnv: env };
 	}
@@ -591,8 +602,12 @@ interface MeasureContext {
 	clef?: Clef;
 }
 
-// Find first clef in voice events
+// Find the voice's leading clef: the clef in effect at the START of the voice, i.e.
+// a clef context event that appears before any musical event on the home staff.
+// A clef that first appears AFTER a note is a mid-voice change and must be emitted
+// inline where it occurs, not hoisted to the front — so it is not returned here.
 const findVoiceClef = (voice: Voice): Clef | undefined => {
+	const MUSICAL = new Set(['note', 'rest', 'tuplet', 'times', 'tremolo']);
 	let activeStaff = voice.staff;
 	for (const event of voice.events) {
 		if (event.type === 'context') {
@@ -601,6 +616,9 @@ const findVoiceClef = (voice: Voice): Clef | undefined => {
 			if (ctx.clef && activeStaff === voice.staff) {
 				return ctx.clef;
 			}
+		} else if (MUSICAL.has(event.type)) {
+			// Reached music on the home staff before any clef — no leading clef.
+			if (activeStaff === voice.staff) return undefined;
 		}
 	}
 	return undefined;
@@ -631,7 +649,6 @@ const serializeVoice = (
 	// 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++) {
@@ -653,7 +670,9 @@ const serializeVoice = (
 			leadStaffScanEnd = i + 1; // time/key/stemDir — continue scan
 			continue;
 		}
-		if (MUSICAL_TYPES.has(e.type)) break;
+		// Any other event (note/rest/tuplet/markup/dynamic/harmony/barline/…) has a
+		// visible position; a staff switch after it must not be hoisted ahead of it.
+		break;
 	}
 
 	// Output staff command if voice staff differs from current parser staff,
@@ -684,15 +703,16 @@ const serializeVoice = (
 		}
 	}
 
-	// Output clef only if not yet emitted or changed for this staff
-	const voiceClef = allStaffClefs?.[voice.staff] || findVoiceClef(voice);
+	// Output clef only if not yet emitted or changed for this staff.
+	// Prefer this voice's leading clef (a clef before any music); fall back to the
+	// carry-in clef from previous measures. A clef that first appears mid-voice is NOT
+	// hoisted here — it is emitted inline at its position.
+	const voiceClef = findVoiceClef(voice) ?? allStaffClefs?.[voice.staff];
 	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
-	const clefOutputted = !!voiceClef && !!emittedClefs?.[voice.staff];
 
 	let activeStaff = effectiveInitialStaff;
 	let activeStemDir: StemDirection | undefined;
@@ -712,15 +732,20 @@ 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;
 			}
 			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) {
+			// Skip a clef-only context event only if it is REDUNDANT — i.e. it restates the
+			// clef already active for this staff. A clef that differs is a genuine change and
+			// must be emitted inline at its position.
+			if (
+				ctx.clef && !ctx.key && !ctx.time && !ctx.ottava && !ctx.stemDirection && !ctx.tempo &&
+				emittedClefs?.[ctx.staff || activeStaff] === ctx.clef
+			) {
 				continue;
 			}
 		}
@@ -736,7 +761,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 +827,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 +855,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 +868,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 +887,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 +924,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 +967,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,25 +983,32 @@ export const serializeLilyletDoc = (doc: LilyletDoc): string => {
 			currentTime = measure.timeSig;
 		}
 
-		// Collect clefs from this measure's voices
-		for (const part of measure.parts) {
-			for (const voice of part.voices) {
-				let clefActiveStaff = voice.staff;
-				for (const event of voice.events) {
-					if (event.type === 'context') {
-						const ctx = event as ContextChange;
-						if (ctx.staff) {
-							clefActiveStaff = ctx.staff;
-						}
-						if (ctx.clef) {
-							staffClefs[clefActiveStaff] = ctx.clef;
+		// Collect clefs from this measure's voices, per part — but only AFTER serializing
+		// the measure, so that during serialization allStaffClefs reflects the clef state
+		// CARRIED IN from previous measures (a mid-measure clef change must not be hoisted
+		// to the measure's front; it is emitted inline at its position).
+		const collectClefs = () => {
+			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) {
+						if (event.type === 'context') {
+							const ctx = event as ContextChange;
+							if (ctx.staff) {
+								clefActiveStaff = ctx.staff;
+							}
+							if (ctx.clef) {
+								staffClefs[clefActiveStaff] = ctx.clef;
+							}
 						}
 					}
 				}
-			}
-		}
+			});
+		};
 
-		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);
+		collectClefs();
 		// Always include measure, even if empty (use space rest for empty measures)
 		measureStrs.push(measureStr || 's1');
 		currentStaff = newStaff;

package/source/lilylet/types.ts

@@ -278,7 +278,12 @@ export interface MarkupEvent {
 	placement?: Placement;  // Optional placement (above/below)
 }
 
-export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | TimesEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
+export interface DynamicEvent {
+	type: 'dynamic';
+	dynamicType: DynamicType;  // Standalone dynamic at a leading position (before any note)
+}
+
+export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | TimesEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent | DynamicEvent;
 
 // === Structure ===