@k-l-lambda/lilylet 0.1.76 → 0.1.79

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;
 		}
 	}
 

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 ===