@k-l-lambda/lilylet 0.1.60 → 0.1.63

package/source/lilylet/lilypondEncoder.ts

@@ -15,6 +15,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	HarmonyEvent,
@@ -164,6 +165,53 @@ const getSpacerRest = (timeSig?: { numerator: number; denominator: number }): st
 };
 
 
+// === Partial Measure Helpers ===
+
+const TPQN = 480;
+
+const voiceDurationTicks = (voice: Voice): number => {
+	let ticks = 0;
+	const addEvent = (e: Event, factor = 1): void => {
+		if (e.type === 'note' || e.type === 'rest') {
+			const ev = e as NoteEvent | RestEvent;
+			if ((ev as NoteEvent).grace) return;
+			let t = (TPQN * 4) / ev.duration.division;
+			let dot = t / 2;
+			for (let i = 0; i < ev.duration.dots; i++) { t += dot; dot /= 2; }
+			ticks += Math.round(t * factor);
+		} else if (e.type === 'tuplet' || e.type === 'times') {
+			const te = e as TupletEvent;
+			const f = factor * te.ratio.numerator / te.ratio.denominator;
+			for (const inner of te.events) addEvent(inner as Event, f);
+		}
+	};
+	for (const e of voice.events) addEvent(e);
+	return ticks;
+};
+
+const ticksToLyDuration = (ticks: number): string => {
+	const whole = TPQN * 4;
+	for (const div of [1, 2, 4, 8, 16, 32, 64]) {
+		const t = whole / div;
+		if (Math.abs(ticks - t) < 1) return String(div);
+		if (Math.abs(ticks - Math.round(t * 1.5)) < 1) return `${div}.`;
+		if (Math.abs(ticks - Math.round(t * 1.75)) < 1) return `${div}..`;
+	}
+	return '4';
+};
+
+// Return a spacer-rest suffix to pad a voice to the full measure duration.
+// Uses s16*N to avoid complexity with dotted/compound values.
+const padVoiceToMeasure = (voiceTicks: number, measureTicks: number): string => {
+	const remaining = Math.round(measureTicks - voiceTicks);
+	if (remaining <= 0) return '';
+	const sixteenth = Math.round(TPQN / 4); // 120 ticks
+	const numSixteenths = Math.round(remaining / sixteenth);
+	if (numSixteenths <= 0) return '';
+	return numSixteenths === 1 ? ' s16' : ` s16*${numSixteenths}`;
+};
+
+
 // === Pitch Environment for Relative Mode ===
 
 interface PitchEnv {
@@ -509,8 +557,12 @@ const encodeContextChange = (event: ContextChange): string => {
 /**
  * Encode a tuplet event
  */
-const encodeTupletEvent = (event: TupletEvent, env: PitchEnv, lastDuration: Duration | null): { str: string; newEnv: PitchEnv; newDuration: Duration | null } => {
-	let result = `\\tuplet ${event.ratio.denominator}/${event.ratio.numerator} { `;
+const encodeTupletEvent = (event: TupletEvent | TimesEvent, env: PitchEnv, lastDuration: Duration | null): { str: string; newEnv: PitchEnv; newDuration: Duration | null } => {
+	// \times preserves type:"times"; \tuplet is denominator/numerator
+	const header = event.type === 'times'
+		? `\\times ${event.ratio.numerator}/${event.ratio.denominator}`
+		: `\\tuplet ${event.ratio.denominator}/${event.ratio.numerator}`;
+	let result = `${header} { `;
 	let newEnv = env;
 	let newDuration = lastDuration;
 
@@ -525,6 +577,8 @@ const encodeTupletEvent = (event: TupletEvent, env: PitchEnv, lastDuration: Dura
 			result += str + ' ';
 			newEnv = ne;
 			newDuration = nd;
+		} else if (subEvent.type === 'context') {
+			result += encodeContextChange(subEvent) + ' ';
 		}
 	}
 
@@ -650,8 +704,9 @@ const encodeVoice = (
 				result += encodeContextChange(event) + ' ';
 				break;
 			}
-			case 'tuplet': {
-				const { str, newEnv, newDuration } = encodeTupletEvent(event, env, lastDuration);
+			case 'tuplet':
+			case 'times': {
+				const { str, newEnv, newDuration } = encodeTupletEvent(event as TupletEvent | TimesEvent, env, lastDuration);
 				result += str + ' ';
 				env = newEnv;
 				lastDuration = newDuration;
@@ -740,7 +795,7 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		for (const part of measure.parts) {
 			for (const voice of part.voices) {
 				for (const event of voice.events) {
-					if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'tremolo') {
+					if (event.type === 'note' || event.type === 'rest' || event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
 						return true;
 					}
 				}
@@ -769,6 +824,8 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 
 	// Track time signature for each measure (for spacer rests)
 	const measureTimeSigs: Array<{ numerator: number; denominator: number } | undefined> = [];
+	// Track partial (pickup) measure durations as LY duration strings (e.g. "8" for \partial 8)
+	const measurePartialDurs: Array<string | undefined> = [];
 
 	let currentKey: KeySignature | undefined;
 	let currentTimeSig: { numerator: number; denominator: number } | undefined;
@@ -783,6 +840,29 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		// Store time signature for this measure
 		measureTimeSigs[mi] = currentTimeSig;
 
+		// Detect partial (pickup) measures and compute their duration.
+		// Only the first measure (mi===0) can be an implicit partial;
+		// subsequent incomplete measures are NOT treated as partial.
+		const isExplicitPartial = measure.partial === true;
+		if (isExplicitPartial || (mi === 0 && currentTimeSig)) {
+			let maxVoiceTicks = 0;
+			for (const part of measure.parts) {
+				for (const v of part.voices) {
+					maxVoiceTicks = Math.max(maxVoiceTicks, voiceDurationTicks(v));
+				}
+			}
+			const expectedTicks = currentTimeSig
+				? Math.round(TPQN * 4 * currentTimeSig.numerator / currentTimeSig.denominator)
+				: TPQN * 4;
+			if (maxVoiceTicks > 0 && maxVoiceTicks < expectedTicks) {
+				measurePartialDurs[mi] = ticksToLyDuration(maxVoiceTicks);
+			} else {
+				measurePartialDurs[mi] = undefined;
+			}
+		} else {
+			measurePartialDurs[mi] = undefined;
+		}
+
 		// Process each part
 		for (let pi = 0; pi < measure.parts.length; pi++) {
 			const part = measure.parts[pi];
@@ -803,12 +883,21 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 				}
 
 				// Encode voice content
-				const voiceContent = encodeVoice(voice, {
+				let voiceContent = encodeVoice(voice, {
 					key: currentKey,
 					timeSig: currentTimeSig,
 					isFirst: mi === 0
 				}, vi);
 
+				// For non-partial measures, pad incomplete voices to fill the full
+				// measure duration. lotus doesn't auto-advance on barlines, so
+				// under-full voices cause measure boundary miscounting.
+				if (!measurePartialDurs[mi] && currentTimeSig) {
+					const expectedTicks = Math.round(TPQN * 4 * currentTimeSig.numerator / currentTimeSig.denominator);
+					const voiceTicks = voiceDurationTicks(voice);
+					voiceContent += padVoiceToMeasure(voiceTicks, expectedTicks);
+				}
+
 				staffMeasures[mi].push(voiceContent);
 			}
 		}
@@ -823,10 +912,28 @@ export const encode = (doc: LilyletDoc, options: RenderOptions = {}): string =>
 		// Build voice lines
 		const voiceLines: string[] = [];
 		for (let vi = 0; vi < maxVoices; vi++) {
+			let prevTimeSigStr: string | undefined;
 			const measureContents = measures.map((m, mi) => {
-				// Use correct spacer rest based on time signature
-				const spacer = getSpacerRest(measureTimeSigs[mi]);
-				const content = m[vi] || spacer;
+				// For partial (pickup) measures, use a partial-duration spacer
+				const partialDur = measurePartialDurs[mi];
+				const spacer = partialDur ? `s${partialDur}` : getSpacerRest(measureTimeSigs[mi]);
+				let content = m[vi] || spacer;
+				// Inject \time if the content lacks it and the time sig changed.
+				// lotus processes each voice independently — without \time it
+				// defaults to 4/4, miscounting measure boundaries for other meters.
+				const ts = measureTimeSigs[mi];
+				if (ts) {
+					const tsStr = `${ts.numerator}/${ts.denominator}`;
+					if (tsStr !== prevTimeSigStr && !content.includes('\\time')) {
+						content = `${encodeTimeSig(ts)} ${content}`;
+					}
+					prevTimeSigStr = tsStr;
+				}
+				// For partial measures, prepend \partial DUR before all other commands
+				// so the lotus interpreter correctly tracks the pickup measure boundary.
+				if (partialDur && !content.includes('\\partial')) {
+					content = `\\partial ${partialDur} ${content}`;
+				}
 				// Wrap each measure in its own \relative c' to reset pitch context
 				return `${indent}    \\relative c' { ${content} } |  % ${mi + 1}`;
 			});

package/source/lilylet/meiEncoder.ts

@@ -7,6 +7,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	HarmonyEvent,
@@ -654,6 +655,7 @@ interface TupletEventResult {
 	mordents: MordentRef[];
 	turns: TurnRef[];
 	arpeggios: ArpegRef[];
+	endingClef?: string;  // Updated clef name if changed inside the tuplet
 }
 
 // Check if a tuplet has balanced internal beam groups (both [ and ] inside the same tuplet)
@@ -672,7 +674,7 @@ const tupletHasInternalBeams = (event: TupletEvent): boolean => {
 };
 
 // Convert TupletEvent to MEI
-const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>): TupletEventResult => {
+const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: number, keyFifths: number = 0, currentStaff?: number, ottavaShift: number = 0, inParentBeam: boolean = false, measureAccidentals?: Map<string, string>, currentClef?: string): TupletEventResult => {
 	// LilyPond \times 2/3 means "multiply duration by 2/3"
 	// So 3 notes × 2/3 = 2 beats worth (3 in time of 2)
 	// MEI: num = number of notes written, numbase = normal equivalent
@@ -700,6 +702,8 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	// Handle internal beam groups: if notes have manual beam marks, respect them
 	const hasInternalBeams = !inParentBeam && tupletHasInternalBeams(event);
 	let beamOpen = false;
+	let activeClef = currentClef;
+	let endingClef: string | undefined;
 
 	for (const e of event.events) {
 		if (e.type === 'note') {
@@ -743,6 +747,19 @@ 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);
+		} else if (e.type === 'context') {
+			const ctx = e as ContextChange;
+			if (ctx.clef && ctx.clef !== activeClef) {
+				const layerStaffNum = layerStaff || 1;
+				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`;
+				}
+				activeClef = ctx.clef;
+				endingClef = ctx.clef;
+			}
 		}
 	}
 
@@ -752,7 +769,7 @@ const tupletEventToMEI = (event: TupletEvent, indent: string, layerStaff?: numbe
 	}
 
 	xml += `${indent}</tuplet>\n`;
-	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios };
+	return { xml, firstNoteId, slurStarts, slurEnds, dynamics, fermatas, trills, mordents, turns, arpeggios, endingClef };
 };
 
 
@@ -943,12 +960,12 @@ interface LayerResult {
 
 
 // Helper: check if an event (or any note inside a tuplet) has beam start/end
-const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
+const getEventBeamMarks = (event: NoteEvent | RestEvent | TupletEvent | TimesEvent | TremoloEvent | ContextChange | BarlineEvent | HarmonyEvent | MarkupEvent | { type: 'pitchReset' }): { beamStart: boolean; beamEnd: boolean } => {
 	if (event.type === 'note') {
 		const markOptions = extractMarkOptions((event as NoteEvent).marks);
 		return { beamStart: markOptions.beamStart, beamEnd: markOptions.beamEnd };
 	}
-	if (event.type === 'tuplet') {
+	if (event.type === 'tuplet' || event.type === 'times') {
 		const tuplet = event as TupletEvent;
 		// If the tuplet has internal beam groups, don't report beam marks to the parent
 		// so the parent won't wrap the tuplet in an external <beam>
@@ -1209,12 +1226,18 @@ const encodeLayer = (voice: Voice, layerN: number, indent: string, initialTiePit
 				xml += restEventToMEI(event as RestEvent, currentIndent, keyFifths, currentOttavaShift, measureAccidentals, restCrossStaff);
 				break;
 			}
-			case 'tuplet': {
+			case 'tuplet':
+			case 'times': {
 				// Tuplet can be nested inside beam in MEI: <beam><tuplet>...</tuplet></beam>
 				// Pass beamElementOpen to tuplet so it knows not to create its own beam
-				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals);
+				const tupletResult = tupletEventToMEI(event as TupletEvent, currentIndent, voice.staff, keyFifths, currentStaff, currentOttavaShift, beamElementOpen, measureAccidentals, currentClef);
 				xml += tupletResult.xml;
 
+				// Propagate clef change from inside the tuplet to the parent tracker
+				if (tupletResult.endingClef) {
+					currentClef = tupletResult.endingClef as Clef;
+				}
+
 				// Flush any pending markups onto the first note of the tuplet
 				if (tupletResult.firstNoteId) {
 					flushPendingMarkups(tupletResult.firstNoteId);
@@ -1943,7 +1966,7 @@ const docHasBeamMarks = (doc: LilyletDoc): boolean => {
 								if (m.markType === 'beam') return true;
 							}
 						}
-					} else if (event.type === 'tuplet') {
+					} else if (event.type === 'tuplet' || event.type === 'times') {
 						const tuplet = event as TupletEvent;
 						for (const e of tuplet.events) {
 							if (e.type === 'note') {
@@ -2118,7 +2141,7 @@ const applyAutoBeamToVoice = (events: Event[], beamGroups: number[]): void => {
 			// Rests break beam groups
 			flushRun();
 			position += dur;
-		} else if (event.type === 'tuplet') {
+		} else if (event.type === 'tuplet' || event.type === 'times') {
 			const tuplet = event as TupletEvent;
 			const ratio = tuplet.ratio; // LilyPond ratio: num/den
 
@@ -2320,7 +2343,7 @@ const encode = (doc: LilyletDoc, options: MEIEncoderOptions = {}): string => {
 				for (const event of voice.events) {
 					// Check for actual musical content (not just context changes or pitch resets)
 					if (event.type === 'note' || event.type === 'rest' ||
-						event.type === 'tuplet' || event.type === 'tremolo') {
+						event.type === 'tuplet' || event.type === 'times' || event.type === 'tremolo') {
 						return true;
 					}
 				}

package/source/lilylet/musicXmlDecoder.ts

@@ -1201,9 +1201,9 @@ const convertMeasure = (
 					// Calculate total duration of tuplet for voiceTracker
 					let totalDuration = 0;
 					for (const evt of tupletEvent.events) {
-						if (evt.duration) {
+						if ((evt as NoteEvent | RestEvent).duration) {
 							// Convert division to duration units (quarter = 1)
-							totalDuration += (4 / evt.duration.division) * voiceTracker.getDivisions();
+							totalDuration += (4 / (evt as NoteEvent | RestEvent).duration.division) * voiceTracker.getDivisions();
 						}
 					}
 					// Apply tuplet ratio to get actual duration

package/source/lilylet/musicXmlEncoder.ts

@@ -754,7 +754,7 @@ const encodeMeasure = (
 				}
 
 				case 'tuplet': {
-					const tupletEvents = event.events;
+					const tupletEvents = event.events.filter(e => e.type === 'note' || e.type === 'rest') as (NoteEvent | RestEvent)[];
 					for (let ti = 0; ti < tupletEvents.length; ti++) {
 						const subEvent = tupletEvents[ti];
 						// Set tuplet ratio on duration so encodeDuration emits <time-modification>

package/source/lilylet/parser.ts

@@ -157,6 +157,14 @@ const resolveDocumentPitches = (doc: LilyletDoc): void => {
 };
 
 
+export interface ParseWarning {
+	type: 'partial-mismatch';
+	message: string;
+	declared: number;  // ticks
+	actual: number;    // ticks
+}
+
+
 const parseCode = (code: string): LilyletDoc => {
 	// Reset parser state before each parse to avoid contamination
 	if (parser && (parser as any).resetState) {
@@ -172,7 +180,19 @@ const parseCode = (code: string): LilyletDoc => {
 };
 
 
+/**
+ * Return warnings emitted during the most recent parseCode() call.
+ * Currently reports \partial duration mismatches.
+ */
+const getParseWarnings = (): ParseWarning[] => {
+	if (parser && (parser as any).getWarnings) {
+		return (parser as any).getWarnings() as ParseWarning[];
+	}
+	return [];
+};
+
 
 export {
 	parseCode,
+	getParseWarnings,
 };

package/source/lilylet/serializer.ts

@@ -15,6 +15,7 @@ import {
 	RestEvent,
 	ContextChange,
 	TupletEvent,
+	TimesEvent,
 	TremoloEvent,
 	BarlineEvent,
 	Pitch,
@@ -400,6 +401,11 @@ const serializeContextChange = (event: ContextChange): string => {
 		parts.push('\\time ' + event.time.numerator + '/' + event.time.denominator);
 	}
 
+	// Partial (pickup measure duration check)
+	if (event.partial) {
+		parts.push('\\partial ' + event.partial.division + '.'.repeat(event.partial.dots || 0));
+	}
+
 	// Ottava
 	if (event.ottava !== undefined) {
 		if (event.ottava === 0) {
@@ -447,14 +453,17 @@ const serializeTempo = (tempo: Tempo): string => {
 
 // Serialize a tuplet event with pitch environment tracking
 const serializeTupletEvent = (
-	event: TupletEvent,
+	event: TupletEvent | TimesEvent,
 	env: PitchEnv
 ): { str: string; newEnv: PitchEnv } => {
 	const parts: string[] = [];
 	let currentEnv = env;
 
-	// \times numerator/denominator { ... }
-	parts.push('\\times ' + event.ratio.numerator + '/' + event.ratio.denominator + ' {');
+	// \tuplet denominator/numerator { ... } for tuplet type, \times numerator/denominator for times type
+	const keyword = event.type === 'times'
+		? '\\times ' + event.ratio.numerator + '/' + event.ratio.denominator
+		: '\\tuplet ' + event.ratio.denominator + '/' + event.ratio.numerator;
+	parts.push(keyword + ' {');
 
 	let prevDuration: Duration | undefined;
 	for (const e of event.events) {
@@ -468,6 +477,15 @@ const serializeTupletEvent = (
 			parts.push(' ' + str);
 			currentEnv = newEnv;
 			prevDuration = (e as RestEvent).duration;
+		} else if (e.type === 'context') {
+			const ctx = e as ContextChange;
+			if (ctx.staff != null) {
+				parts.push(' \\staff "' + ctx.staff + '"');
+			} else if (ctx.stemDirection != null) {
+				if (ctx.stemDirection === StemDirection.up) parts.push(' \\stemUp');
+				else if (ctx.stemDirection === StemDirection.down) parts.push(' \\stemDown');
+				else if (ctx.stemDirection === StemDirection.auto) parts.push(' \\stemNeutral');
+			}
 		}
 	}
 
@@ -554,7 +572,8 @@ const serializeEvent = (
 		case 'context':
 			return { str: serializeContextChange(event as ContextChange), newEnv: env };
 		case 'tuplet':
-			return serializeTupletEvent(event as TupletEvent, env);
+		case 'times':
+			return serializeTupletEvent(event as TupletEvent | TimesEvent, env);
 		case 'tremolo':
 			return serializeTremoloEvent(event as TremoloEvent, env);
 		case 'barline':
@@ -612,7 +631,7 @@ 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', 'tremolo']);
+	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++) {
@@ -749,6 +768,12 @@ const serializeVoice = (
 			prevDuration = (event as NoteEvent).duration;
 		} else if (event.type === 'rest') {
 			prevDuration = (event as RestEvent).duration;
+		} else if (event.type === 'tuplet' || event.type === 'times') {
+			// After a tuplet/times block the LilyPond parser's "current duration" is the
+			// last note duration inside the tuplet, not the duration before the tuplet.
+			// Reset prevDuration so the first note after the block always emits its
+			// duration explicitly, avoiding wrong inheritance from inside the tuplet.
+			prevDuration = undefined;
 		} else if (event.type === 'context' && (event as ContextChange).clef && emittedClefs) {
 			const ctx = event as ContextChange;
 			emittedClefs[ctx.staff || activeStaff] = ctx.clef!;
@@ -836,7 +861,7 @@ const serializeMeasure = (
 			}
 			staff = newStaff;
 		}
-		parts.push(partStrs.join(' \\\\\\\\\n'));
+		parts.push(partStrs.join(' \\\\\\\n'));
 	}
 
 	return { str: parts.join(' '), newStaff: staff };

package/source/lilylet/types.ts

@@ -229,6 +229,7 @@ export interface ContextChange {
 	type: 'context';
 	key?: KeySignature;
 	time?: Fraction;
+	partial?: Duration;				// Pickup measure duration (check-only, warns if mismatch)
 	clef?: Clef;
 	ottava?: number;				// -1, 0, 1
 	stemDirection?: StemDirection;
@@ -247,7 +248,14 @@ export interface TremoloEvent {
 export interface TupletEvent {
 	type: 'tuplet';
 	ratio: Fraction;				// e.g., {numerator: 2, denominator: 3} for triplet
-	events: (NoteEvent | RestEvent)[];
+	events: (NoteEvent | RestEvent | ContextChange)[];
+}
+
+// TimesEvent: from lilylet \times syntax (distinct from \tuplet decoded from LilyPond)
+export interface TimesEvent {
+	type: 'times';
+	ratio: Fraction;
+	events: (NoteEvent | RestEvent | ContextChange)[];
 }
 
 export interface PitchResetEvent {
@@ -270,7 +278,7 @@ export interface MarkupEvent {
 	placement?: Placement;  // Optional placement (above/below)
 }
 
-export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
+export type Event = NoteEvent | RestEvent | ContextChange | TremoloEvent | TupletEvent | TimesEvent | PitchResetEvent | BarlineEvent | HarmonyEvent | MarkupEvent;
 
 // === Structure ===