@k-l-lambda/lilylet 0.1.75 → 0.1.78

package/source/lilylet/musicXmlDecoder.ts

@@ -25,6 +25,7 @@ import {
 	HairpinType,
 	PedalType,
 	NavigationMarkType,
+	OrnamentType,
 	Placement,
 	BarlineEvent,
 	HarmonyEvent,
@@ -305,12 +306,13 @@ class VoiceTracker {
 			});
 			this.currentStaff.set(voiceNum, staff);
 		}
-		const voice = this.voices.get(voiceNum)!;
-		// Update staff if specified
-		if (staff > 0) {
-			voice.staff = staff;
-		}
-		return voice;
+		// NOTE: do NOT overwrite voice.staff on later notes. voice.staff is the voice's
+		// HOME staff — the staff of its first note — matching the parser, which fixes
+		// voice.staff to the first leading \staff (so `\staff "1" … \staff "2" …` gives
+		// voice.staff=1, with the switch carried by an inline ctx(staff=2) event). The
+		// previous code clobbered it to every note's staff, so a voice that ended on a
+		// different staff round-tripped with the wrong home staff.
+		return this.voices.get(voiceNum)!;
 	}
 
 	addEvent(voiceNum: number, event: Event, duration: number, staff: number = 1): void {
@@ -430,9 +432,11 @@ const parseNotations = (notationsEl: Element): MusicXmlNotations => {
 		}
 	}
 
-	// Fermata
-	if (hasElement(notationsEl, 'fermata')) {
-		result.fermata = true;
+	// Fermata. The "angled" shape is LilyPond's \shortfermata; everything else
+	// (normal/square/unset) is the ordinary \fermata.
+	const fermataEl = getElements(notationsEl, 'fermata')[0];
+	if (fermataEl) {
+		result.fermata = (fermataEl.textContent || '').trim() === 'angled' ? 'short' : 'normal';
 	}
 
 	// Arpeggiate
@@ -457,6 +461,14 @@ const parseNotations = (notationsEl: Element): MusicXmlNotations => {
 		};
 	}
 
+	// Glissando / slide — both are note-to-note slide lines. Only the START note
+	// carries the mark (LilyPond \glissando auto-connects to the next note), so we
+	// record presence of any start; stops are ignored.
+	const slideEls = [...getElements(notationsEl, 'glissando'), ...getElements(notationsEl, 'slide')];
+	if (slideEls.some(el => getAttribute(el, 'type') === 'start')) {
+		result.glissando = true;
+	}
+
 	return result;
 };
 
@@ -726,6 +738,17 @@ const parseDirection = (dirEl: Element): MusicXmlDirection => {
 		result.segno = true;
 	}
 
+	// Rehearsal mark (<direction-type><rehearsal>A</rehearsal>). May be split into
+	// multiple <rehearsal> (e.g. "A" + a Chinese gloss "段"); join them. Collected
+	// from the whole direction so it is found regardless of which direction-type it
+	// sits in. Surfaced as text → markup by directionToMarks (per the text-as-markup
+	// convention; LilyPond's musicxml2ly emits \mark \markup { \box { … } }).
+	const rehearsalEls = Array.from(dirEl.getElementsByTagName('rehearsal'));
+	if (rehearsalEls.length > 0) {
+		const text = rehearsalEls.map(el => el.textContent?.trim() || '').filter(Boolean).join(' ');
+		if (text) result.rehearsal = text;
+	}
+
 	return result;
 };
 
@@ -811,6 +834,21 @@ const parseMetadata = (doc: Document): Metadata => {
 		metadata.title = movementTitleEl.textContent.trim();
 	}
 
+	// Subtitle: MusicXML has no <subtitle> element — it lives in a page <credit>
+	// tagged <credit-type>subtitle</credit-type>, with the text in <credit-words>.
+	const creditEls = doc.getElementsByTagName('credit');
+	for (let i = 0; i < creditEls.length; i++) {
+		const credit = creditEls[i];
+		const typeEl = credit.getElementsByTagName('credit-type')[0];
+		if (typeEl?.textContent?.trim().toLowerCase() === 'subtitle') {
+			const words = Array.from(credit.getElementsByTagName('credit-words'))
+				.map(w => w.textContent?.trim() || '')
+				.filter(Boolean)
+				.join(' ');
+			if (words) { metadata.subtitle = words; break; }
+		}
+	}
+
 	// Identification (composer, arranger, lyricist)
 	const identificationEl = doc.getElementsByTagName('identification')[0];
 	if (identificationEl) {
@@ -890,6 +928,12 @@ const notationsToMarks = (
 	// Articulations
 	if (notations.articulations) {
 		for (const artName of notations.articulations) {
+			// breath-mark is a NoDirection articulation in MusicXML but maps to
+			// LilyPond's \breathe — model it as the breath ornament.
+			if (artName === 'breath-mark') {
+				marks.push({ markType: 'ornament', type: OrnamentType.breath });
+				continue;
+			}
 			const artType = convertArticulation(artName);
 			if (artType) {
 				marks.push({ markType: 'articulation', type: artType });
@@ -909,7 +953,7 @@ const notationsToMarks = (
 
 	// Fermata
 	if (notations.fermata) {
-		marks.push({ markType: 'ornament', type: 'fermata' as any });
+		marks.push({ markType: 'ornament', type: (notations.fermata === 'short' ? 'shortFermata' : 'fermata') as any });
 	}
 
 	// Arpeggiate
@@ -917,6 +961,11 @@ const notationsToMarks = (
 		marks.push({ markType: 'ornament', type: 'arpeggio' as any });
 	}
 
+	// Glissando / slide (start note only)
+	if (notations.glissando) {
+		marks.push({ markType: 'glissando' });
+	}
+
 	return marks;
 };
 
@@ -1082,16 +1131,31 @@ const directionToMarks = (
 		marks.push({ markType: 'navigation', type: NavigationMarkType.segno });
 	}
 
+	// Rehearsal mark → markup (text-as-markup convention; LilyPond uses \mark).
+	if (direction.rehearsal) {
+		const placement = direction.placement === 'above' ? Placement.above
+			: direction.placement === 'below' ? Placement.below
+			: undefined;
+		marks.push({ markType: 'markup', content: direction.rehearsal, placement });
+	}
+
 	// Words (text directions: "dolce", "espr.", "cresc.", "con forza", ...).
 	// Tempo words ("Allegro", "a tempo", ...) are consumed separately as a tempo
-	// ContextChange by directionToContextChange, so skip those here to avoid
-	// double-emitting; everything else becomes a markup mark → MEI <dir>. Metronome
-	// directions are tempo too, never markup. Navigation text ("D.C. al Fine",
-	// "To Coda", "Fine", "D.S. al Coda") is NOT a tempo word, so it flows here as a
-	// markup glyph — the jump SEMANTICS are captured separately as measure-layout.
+	// ContextChange by directionToContextChange (which takes words[0]), so skip that
+	// one here to avoid double-emitting; the REST become a markup mark → MEI <dir>.
+	// A single <direction> often carries a tempo word AND an expressive/translation
+	// word together (e.g. <words>Moderato</words><words>中板</words>) — only the tempo
+	// word is consumed; the rest must still surface as markup. Metronome directions
+	// are tempo too, never markup. Navigation text ("D.C. al Fine", "To Coda",
+	// "Fine", "D.S. al Coda") is NOT a tempo word, so it flows here as a markup glyph
+	// — the jump SEMANTICS are captured separately as measure-layout.
 	let emittedWords = false;
 	if (direction.words && direction.words.length > 0 && !direction.metronome) {
-		const text = direction.words.map(w => w.text).join('').trim();
+		// If words[0] was consumed as the tempo text, drop it and keep the remainder;
+		// otherwise the whole run is one expressive phrase, joined as today.
+		const firstIsTempo = isTempoWord(direction.words[0].text.trim());
+		const rest = firstIsTempo ? direction.words.slice(1) : direction.words;
+		const text = rest.map(w => w.text).join('').trim();
 		if (text && !isTempoWord(text)) {
 			const placement = direction.placement === 'above' ? Placement.above
 				: direction.placement === 'below' ? Placement.below
@@ -1338,7 +1402,16 @@ const convertMeasure = (
 			// hairpin stop that lands just before a rest (common in piano scores:
 			// `<pedal stop/>` followed by rests filling the voice) is silently dropped.
 			const marks: Mark[] = note.isRest ? [] : (pendingMarks.get(voiceNum) || []);
-			if (!note.isRest) pendingMarks.delete(voiceNum);
+			if (!note.isRest) {
+				pendingMarks.delete(voiceNum);
+				// Drain directions that named this note's staff but had no known voice
+				// yet (queued under the -staff placeholder key by the <direction> handler).
+				const staffPending = pendingMarks.get(-staffNum);
+				if (staffPending && staffPending.length > 0) {
+					marks.push(...staffPending);
+					pendingMarks.delete(-staffNum);
+				}
+			}
 
 			if (note.isRest) {
 				// Rest event
@@ -1366,7 +1439,7 @@ const convertMeasure = (
 				// so the encoder can emit <fermata startid="#rest">; without this the
 				// 3-of-4 fermatas that sit on rests in typical piano scores are lost.
 				if (note.notations?.fermata) {
-					restEvent.marks = [{ markType: 'ornament', type: 'fermata' as any }];
+					restEvent.marks = [{ markType: 'ornament', type: (note.notations.fermata === 'short' ? 'shortFermata' : 'fermata') as any }];
 				}
 
 				// Grace notes don't advance time
@@ -1480,9 +1553,17 @@ const convertMeasure = (
 			// Handle marks (dynamics, hairpins, etc.)
 			const marks = directionToMarks(direction, spannerTracker);
 			if (marks.length > 0) {
-				// Store marks to attach to next note in current voice
-				const existing = pendingMarks.get(currentVoice) || [];
-				pendingMarks.set(currentVoice, [...existing, ...marks]);
+				// Route to the voice the marks belong to. A <direction> in a grand-staff
+				// part names its <staff>; the matching note is the NEXT note on that staff
+				// — NOT currentVoice, which after a <backup> still points at the voice that
+				// just ended (so a staff-2 direction emitted after the backup would wrongly
+				// land on staff 1). Queue under a -staff placeholder key; the next note on
+				// that staff drains it, and the end-of-measure flush falls back to that
+				// staff's last note if no further note appears. Without a staff (single-
+				// staff parts), fall back to currentVoice as before.
+				const targetKey = direction.staff ? -direction.staff : currentVoice;
+				const existing = pendingMarks.get(targetKey) || [];
+				pendingMarks.set(targetKey, [...existing, ...marks]);
 			}
 		} else if (tagName === 'backup') {
 			// A <forward> with no note after it (before this backup) is cursor
@@ -1560,10 +1641,23 @@ const convertMeasure = (
 			}
 			return undefined;
 		};
+		// A staff-keyed leftover (negative key = -staffNum, queued for a "next note on
+		// this staff" that never came): resolve to the last note on any voice that lives
+		// on that staff.
+		const findLastNoteOnStaff = (staff: number): NoteEvent | undefined => {
+			let best: NoteEvent | undefined;
+			for (const [, vs] of allVoices) {
+				if ((vs.staff || 1) !== staff) continue;
+				for (let i = vs.events.length - 1; i >= 0; i--) {
+					if (vs.events[i].type === 'note') { best = vs.events[i] as NoteEvent; break; }
+				}
+			}
+			return best;
+		};
 		for (const [voiceNum, marks] of pendingMarks) {
 			if (marks.length === 0) continue;
-			let target = findLastNote(voiceNum);
-			// Voice had no note (e.g. direction-only or rest-only): attach to the
+			let target = voiceNum < 0 ? findLastNoteOnStaff(-voiceNum) : findLastNote(voiceNum);
+			// Voice/staff had no note (e.g. direction-only or rest-only): attach to the
 			// last note of any voice so the marking is not silently dropped.
 			if (!target) {
 				for (const vn of allVoices.keys()) {

package/source/lilylet/musicXmlEncoder.ts

@@ -32,6 +32,7 @@ import {
 	DynamicType,
 	HairpinType,
 	PedalType,
+	NavigationMarkType,
 	Tempo,
 	Metadata,
 	Fraction,
@@ -124,6 +125,7 @@ const DYNAMIC_TO_XML: Record<string, string> = {
 	fff: 'fff',
 	sfz: 'sfz',
 	rfz: 'rfz',
+	fp: 'fp',
 };
 
 // Barline style to MusicXML
@@ -289,6 +291,7 @@ const encodeAttributes = (
 const encodeNotations = (marks: Mark[], level: number): string => {
 	const articulations: string[] = [];
 	const ornaments: string[] = [];
+	const technical: string[] = [];
 	const otherNotations: string[] = [];
 
 	for (const mark of marks) {
@@ -301,15 +304,20 @@ const encodeNotations = (marks: Mark[], level: number): string => {
 				break;
 
 			case 'ornament':
-				const ornXml = ORNAMENT_TO_XML[mark.type];
-				if (ornXml) {
-					if (mark.type === 'fermata') {
-						otherNotations.push('<fermata/>');
-					} else if (mark.type === 'arpeggio') {
-						otherNotations.push('<arpeggiate/>');
-					} else {
-						ornaments.push(`<${ornXml}/>`);
-					}
+				// fermata / arpeggio live at the <notations> level; breath-mark is an
+				// <articulations> child; the rest are true <ornaments>. (shortFermata is
+				// a fermata with an "angled" shape — decoder maps it back.)
+				if (mark.type === 'fermata') {
+					otherNotations.push('<fermata/>');
+				} else if (mark.type === 'shortFermata') {
+					otherNotations.push('<fermata>angled</fermata>');
+				} else if (mark.type === 'arpeggio') {
+					otherNotations.push('<arpeggiate/>');
+				} else if (mark.type === 'breath') {
+					articulations.push('<breath-mark/>');
+				} else {
+					const ornXml = ORNAMENT_TO_XML[mark.type];
+					if (ornXml) ornaments.push(`<${ornXml}/>`);
 				}
 				break;
 
@@ -325,13 +333,22 @@ const encodeNotations = (marks: Mark[], level: number): string => {
 				otherNotations.push(`<tuplet type="${(mark as any).start ? 'start' : 'stop'}"/>`);
 				break;
 
+			case 'glissando':
+				// Lilylet \glissando is start-only (the line auto-connects to the next
+				// note); emit just the start spanner so the decoder reads it back.
+				otherNotations.push('<glissando type="start" number="1"/>');
+				break;
+
 			case 'fingering':
-				// Fingering goes in technical
+				technical.push(`<fingering>${mark.finger}</fingering>`);
 				break;
 		}
 	}
 
-	if (articulations.length === 0 && ornaments.length === 0 && otherNotations.length === 0) {
+	if (
+		articulations.length === 0 && ornaments.length === 0 &&
+		technical.length === 0 && otherNotations.length === 0
+	) {
 		return '';
 	}
 
@@ -357,6 +374,14 @@ const encodeNotations = (marks: Mark[], level: number): string => {
 		xml += `${indent(level + 1)}</ornaments>\n`;
 	}
 
+	if (technical.length > 0) {
+		xml += `${indent(level + 1)}<technical>\n`;
+		for (const tech of technical) {
+			xml += `${indent(level + 2)}${tech}\n`;
+		}
+		xml += `${indent(level + 1)}</technical>\n`;
+	}
+
 	xml += `${indent(level)}</notations>\n`;
 
 	return xml;
@@ -518,10 +543,19 @@ const encodeRestWithTuplet = (
  */
 const encodeDirection = (
 	marks: Mark[],
-	level: number
+	level: number,
+	staff: number = 0,
+	emitStaff: boolean = false
 ): string => {
 	let xml = '';
 
+	// In a grand-staff part, a <direction> must name its <staff> or the decoder
+	// can't route the mark back to the right staff (it would attach to the current
+	// voice/staff and drift — observed on chopin dynamics and cross-measure pedals).
+	const staffTag = (emitStaff && staff > 0)
+		? `${indent(level + 1)}<staff>${staff}</staff>\n`
+		: '';
+
 	for (const mark of marks) {
 		if (mark.markType === 'dynamic') {
 			const dynXml = DYNAMIC_TO_XML[mark.type];
@@ -532,6 +566,7 @@ const encodeDirection = (
 				xml += `${indent(level + 3)}<${dynXml}/>\n`;
 				xml += `${indent(level + 2)}</dynamics>\n`;
 				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += staffTag;
 				xml += `${indent(level)}</direction>\n`;
 			}
 		} else if (mark.markType === 'hairpin') {
@@ -548,6 +583,7 @@ const encodeDirection = (
 				xml += `${indent(level + 1)}<direction-type>\n`;
 				xml += `${indent(level + 2)}<wedge type="${wedgeType}"/>\n`;
 				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += staffTag;
 				xml += `${indent(level)}</direction>\n`;
 			}
 		} else if (mark.markType === 'pedal') {
@@ -562,8 +598,28 @@ const encodeDirection = (
 				xml += `${indent(level + 1)}<direction-type>\n`;
 				xml += `${indent(level + 2)}<pedal type="${pedalType}"/>\n`;
 				xml += `${indent(level + 1)}</direction-type>\n`;
+				xml += staffTag;
 				xml += `${indent(level)}</direction>\n`;
 			}
+		} else if (mark.markType === 'markup') {
+			// Text direction → <words>. The decoder reads any non-tempo <words> back
+			// as a markup mark (text-as-markup convention).
+			const placement = mark.placement ? ` placement="${mark.placement}"` : '';
+			xml += `${indent(level)}<direction${placement}>\n`;
+			xml += `${indent(level + 1)}<direction-type>\n`;
+			xml += `${indent(level + 2)}<words>${escapeXml(mark.content)}</words>\n`;
+			xml += `${indent(level + 1)}</direction-type>\n`;
+			xml += staffTag;
+			xml += `${indent(level)}</direction>\n`;
+		} else if (mark.markType === 'navigation') {
+			// \coda / \segno glyph → <direction-type><coda|segno>.
+			const glyph = mark.type === NavigationMarkType.coda ? 'coda' : 'segno';
+			xml += `${indent(level)}<direction>\n`;
+			xml += `${indent(level + 1)}<direction-type>\n`;
+			xml += `${indent(level + 2)}<${glyph}/>\n`;
+			xml += `${indent(level + 1)}</direction-type>\n`;
+			xml += staffTag;
+			xml += `${indent(level)}</direction>\n`;
 		}
 	}
 
@@ -718,12 +774,14 @@ const encodeMeasure = (
 		for (const event of voice.events) {
 			switch (event.type) {
 				case 'note': {
-					// Check for direction marks (dynamics, hairpins, pedals)
+					// Check for direction marks (dynamics, hairpins, pedals, text, nav)
 					const directionMarks = event.marks?.filter(m =>
-						m.markType === 'dynamic' || m.markType === 'hairpin' || m.markType === 'pedal'
+						m.markType === 'dynamic' || m.markType === 'hairpin' ||
+						m.markType === 'pedal' || m.markType === 'markup' ||
+						m.markType === 'navigation'
 					) || [];
 					if (directionMarks.length > 0) {
-						xml += encodeDirection(directionMarks, level + 1);
+						xml += encodeDirection(directionMarks, level + 1, currentStaff, maxStaff > 1);
 					}
 
 					// Encode main note
@@ -731,11 +789,15 @@ const encodeMeasure = (
 					const dur = calculateDuration(event.duration);
 					voicePosition += dur;
 
-					// Encode chord notes
+					// Encode chord notes. Marks live on the parent NoteEvent (the whole
+					// chord) and are emitted on the first note only — re-emitting them on
+					// each member would multiply them on decode (the decoder aggregates
+					// every member's marks back onto the one chord event).
 					for (let i = 1; i < event.pitches.length; i++) {
 						const chordEvent: NoteEvent = {
 							...event,
 							pitches: [event.pitches[i]],
+							marks: undefined,
 						};
 						xml += encodeNote(chordEvent, voiceNum, currentStaff, level + 1, true);
 					}
@@ -773,6 +835,17 @@ const encodeMeasure = (
 						const isLast = ti === tupletEvents.length - 1;
 
 						if (subEvent.type === 'note') {
+							// Direction marks (dynamics, hairpins, pedals, text, nav) — same
+							// as the plain-note case; without this they vanish inside tuplets.
+							const directionMarks = subEvent.marks?.filter(m =>
+								m.markType === 'dynamic' || m.markType === 'hairpin' ||
+								m.markType === 'pedal' || m.markType === 'markup' ||
+								m.markType === 'navigation'
+							) || [];
+							if (directionMarks.length > 0) {
+								xml += encodeDirection(directionMarks, level + 1, currentStaff, maxStaff > 1);
+							}
+
 							// Add tuplet notation marks
 							const tupletMarks: Mark[] = [];
 							if (isFirst) tupletMarks.push({ markType: 'tuplet', start: true } as any);

package/source/lilylet/musicXmlTypes.ts

@@ -59,10 +59,13 @@ export interface MusicXmlNotations {
 	beams?: { type: 'begin' | 'continue' | 'end'; number: number }[];
 	articulations?: string[];   // staccato, accent, tenuto, etc.
 	ornaments?: string[];       // trill, turn, mordent, etc.
-	fermata?: boolean;
+	fermata?: 'normal' | 'short';   // 'short' = angled shape (LilyPond \shortfermata)
 	arpeggiate?: boolean;
 	tremolo?: { type: 'single' | 'start' | 'stop'; value: number };
 	tuplet?: { type: 'start' | 'stop'; number: number };
+	// Glissando / slide spanner: only the start matters for lilylet (LilyPond emits
+	// \glissando on the start note; the line auto-connects to the next note).
+	glissando?: boolean;
 }
 
 export interface MusicXmlNote {
@@ -121,6 +124,7 @@ export interface MusicXmlDirection {
 	pedal?: MusicXmlPedal;
 	metronome?: MusicXmlMetronome;
 	words?: MusicXmlWords[];
+	rehearsal?: string;         // <direction-type><rehearsal> text (e.g. "A", "段")
 	octaveShift?: MusicXmlOctaveShift;
 	coda?: boolean;
 	segno?: boolean;

package/source/lilylet/musicXmlUtils.ts

@@ -416,7 +416,7 @@ const DYNAMIC_MAP: Record<string, DynamicType> = {
 	fz: DynamicType.sfz,
 	sfp: DynamicType.sfz,
 	sfpp: DynamicType.sfz,
-	fp: DynamicType.f, // forte-piano, approximate
+	fp: DynamicType.fp, // forte-piano
 };
 
 export const convertDynamic = (name: string): DynamicType | undefined => {

package/source/lilylet/serializer.ts

@@ -166,6 +166,7 @@ const ORNAMENT_MAP: Record<string, string> = {
 	fermata: '\\fermata',
 	shortFermata: '\\shortfermata',
 	arpeggio: '\\arpeggio',
+	breath: '\\breathe',
 };
 
 
@@ -301,6 +302,19 @@ const serializeMarks = (marks: Mark[]): string => {
 			case 'fingering':
 				parts.push('-' + mark.finger);
 				break;
+			case 'markup': {
+				// Text direction attached to a note (e.g. ^\markup "cantabile").
+				// Placement: above → ^, below → _, unspecified → - (default).
+				const prefix = mark.placement === 'above' ? '^' : mark.placement === 'below' ? '_' : '-';
+				parts.push(prefix + '\\markup "' + escapeString(mark.content) + '"');
+				break;
+			}
+			case 'navigation':
+				parts.push(mark.type === 'coda' ? '\\coda' : '\\segno');
+				break;
+			case 'glissando':
+				parts.push('\\glissando');
+				break;
 		}
 	}
 
@@ -631,7 +645,7 @@ const serializeEvent = (
 		case 'markup': {
 			const mk = event as MarkupEvent;
 			const prefix = mk.placement === 'above' ? '^' : mk.placement === 'below' ? '_' : '';
-			return { str: `${prefix}\\markup "${mk.content}"`, newEnv: env };
+			return { str: `${prefix}\\markup "${escapeString(mk.content)}"`, newEnv: env };
 		}
 		case 'dynamic': {
 			const dynStr = DYNAMIC_MAP[(event as DynamicEvent).dynamicType];
@@ -1011,7 +1025,12 @@ const serializeMeasure = (
 
 // Escape string for serialization (quotes and backslashes)
 const escapeString = (str: string): string => {
-	return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+	return str
+		.replace(/\\/g, '\\\\')
+		.replace(/"/g, '\\"')
+		.replace(/\n/g, '\\n')
+		.replace(/\r/g, '\\r')
+		.replace(/\t/g, '\\t');
 };
 
 // Serialize metadata

package/source/lilylet/types.ts

@@ -47,6 +47,7 @@ export enum OrnamentType {
 	fermata = 'fermata',
 	shortFermata = 'shortFermata',
 	arpeggio = 'arpeggio',
+	breath = 'breath',	// breath mark (\breathe) — MusicXML <breath-mark>
 }
 
 export enum DynamicType {
@@ -187,7 +188,15 @@ export interface MarkupMark {
 	placement?: Placement;
 }
 
-export type Mark = Articulation | Ornament | Dynamic | Hairpin | Tie | Slur | Beam | Pedal | Fingering | NavigationMark | MarkupMark;
+// Glissando / slide: a note-to-note slide line. Mirrors LilyPond's \glissando,
+// which is emitted only on the START note (the line auto-connects to the next
+// note), so this is a single mark — no start/stop pairing. MusicXML <glissando>
+// and <slide> both decode to this.
+export interface Glissando {
+	markType: 'glissando';
+}
+
+export type Mark = Articulation | Ornament | Dynamic | Hairpin | Tie | Slur | Beam | Pedal | Fingering | NavigationMark | MarkupMark | Glissando;
 
 // === Key Signature ===