musicxml-io 0.1.0

package/dist/accessors/index.mjs

@@ -0,0 +1,198 @@
+// src/utils/index.ts
+function createPositionState() {
+  return { position: 0, lastNonChordPosition: 0 };
+}
+function updatePositionForEntry(state, entry) {
+  const pos = state.position;
+  switch (entry.type) {
+    case "note": {
+      const note = entry;
+      if (!note.chord) {
+        state.lastNonChordPosition = state.position;
+        state.position += note.duration;
+      }
+      return note.chord ? state.lastNonChordPosition : pos;
+    }
+    case "backup":
+      state.position -= entry.duration;
+      state.lastNonChordPosition = state.position;
+      return pos;
+    case "forward":
+      state.position += entry.duration;
+      state.lastNonChordPosition = state.position;
+      return pos;
+    default:
+      return pos;
+  }
+}
+function getAbsolutePositionForNote(note, measure) {
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry === note) return entry.chord ? state.lastNonChordPosition : state.position;
+    updatePositionForEntry(state, entry);
+  }
+  return state.position;
+}
+
+// src/accessors/index.ts
+function getNotesForVoice(measure, filter) {
+  return measure.entries.filter((entry) => {
+    if (entry.type !== "note") return false;
+    if (filter.voice !== void 0 && entry.voice !== filter.voice) return false;
+    if (filter.staff !== void 0 && (entry.staff ?? 1) !== filter.staff) return false;
+    return true;
+  });
+}
+function getNotesForStaff(measure, filter) {
+  return measure.entries.filter((entry) => {
+    if (entry.type !== "note") return false;
+    return (entry.staff ?? 1) === filter.staff;
+  });
+}
+function groupByVoice(measure) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type !== "note") continue;
+    const staff = entry.staff ?? 1;
+    const voice = entry.voice;
+    const key = `${staff}-${voice}`;
+    if (!groups.has(key)) {
+      groups.set(key, { staff, voice, notes: [] });
+    }
+    groups.get(key).notes.push(entry);
+  }
+  return Array.from(groups.values()).sort((a, b) => {
+    if (a.staff !== b.staff) return a.staff - b.staff;
+    return a.voice - b.voice;
+  });
+}
+function groupByStaff(measure) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type !== "note") continue;
+    const staff = entry.staff ?? 1;
+    if (!groups.has(staff)) {
+      groups.set(staff, { staff, notes: [] });
+    }
+    groups.get(staff).notes.push(entry);
+  }
+  return Array.from(groups.values()).sort((a, b) => a.staff - b.staff);
+}
+function getAbsolutePosition(note, measure) {
+  return getAbsolutePositionForNote(note, measure);
+}
+function withAbsolutePositions(measure) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      const notePosition = entry.chord ? state.lastNonChordPosition : state.position;
+      result.push({
+        ...entry,
+        absolutePosition: notePosition
+      });
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return result;
+}
+function getChords(measure, filter) {
+  const notesWithPos = withAbsolutePositions(measure);
+  const filteredNotes = filter ? notesWithPos.filter((note) => {
+    if (filter.voice !== void 0 && note.voice !== filter.voice) return false;
+    if (filter.staff !== void 0 && (note.staff ?? 1) !== filter.staff) return false;
+    return true;
+  }) : notesWithPos;
+  const chordMap = /* @__PURE__ */ new Map();
+  for (const note of filteredNotes) {
+    const pos = note.absolutePosition;
+    if (!chordMap.has(pos)) {
+      chordMap.set(pos, []);
+    }
+    chordMap.get(pos).push(note);
+  }
+  const chords = [];
+  for (const [position, notes] of chordMap.entries()) {
+    const duration = notes[0].duration;
+    chords.push({
+      position,
+      duration,
+      notes: notes.map(({ absolutePosition, ...note }) => note)
+    });
+  }
+  return chords.sort((a, b) => a.position - b.position);
+}
+function* iterateNotes(score) {
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const notePosition = entry.chord ? state.lastNonChordPosition : state.position;
+          yield {
+            part,
+            measure,
+            note: entry,
+            position: notePosition
+          };
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+}
+function getAllNotes(score) {
+  return Array.from(iterateNotes(score));
+}
+function getVoices(measure) {
+  const voices = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      voices.add(entry.voice);
+    }
+  }
+  return Array.from(voices).sort((a, b) => a - b);
+}
+function getStaves(measure) {
+  const staves = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      staves.add(entry.staff ?? 1);
+    }
+  }
+  return Array.from(staves).sort((a, b) => a - b);
+}
+function hasNotes(measure) {
+  return measure.entries.some((entry) => entry.type === "note");
+}
+function isRestMeasure(measure) {
+  const notes = measure.entries.filter((entry) => entry.type === "note");
+  return notes.length === 0 || notes.every((note) => !note.pitch);
+}
+function getNormalizedPosition(note, measure, options) {
+  const absolutePosition = getAbsolutePosition(note, measure);
+  const currentDivisions = options.currentDivisions ?? measure.attributes?.divisions ?? 1;
+  return absolutePosition * options.baseDivisions / currentDivisions;
+}
+function getNormalizedDuration(note, options) {
+  const currentDivisions = options.currentDivisions ?? 1;
+  return note.duration * options.baseDivisions / currentDivisions;
+}
+export {
+  getAbsolutePosition,
+  getAllNotes,
+  getChords,
+  getNormalizedDuration,
+  getNormalizedPosition,
+  getNotesForStaff,
+  getNotesForVoice,
+  getStaves,
+  getVoices,
+  groupByStaff,
+  groupByVoice,
+  hasNotes,
+  isRestMeasure,
+  iterateNotes,
+  withAbsolutePositions
+};
+//# sourceMappingURL=index.mjs.map

package/dist/accessors/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/index.ts","../../src/accessors/index.ts"],"sourcesContent":["import type { Pitch, Measure, MeasureEntry, NoteEntry } from '../types';\n\n// Pitch constants\nexport const STEPS: Pitch['step'][] = ['C', 'D', 'E', 'F', 'G', 'A', 'B'];\nexport const STEP_SEMITONES: Record<Pitch['step'], number> = {\n  'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11,\n};\n\n/** Convert pitch to semitone value (MIDI-like) */\nexport function pitchToSemitone(pitch: Pitch): number {\n  return pitch.octave * 12 + STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0);\n}\n\n// Position tracking for measure iteration\nexport interface PositionState {\n  position: number;\n  lastNonChordPosition: number;\n}\n\nexport function createPositionState(): PositionState {\n  return { position: 0, lastNonChordPosition: 0 };\n}\n\n/** Update position state for entry, returns position before update */\nexport function updatePositionForEntry(state: PositionState, entry: MeasureEntry): number {\n  const pos = state.position;\n  switch (entry.type) {\n    case 'note': {\n      const note = entry as NoteEntry;\n      if (!note.chord) {\n        state.lastNonChordPosition = state.position;\n        state.position += note.duration;\n      }\n      return note.chord ? state.lastNonChordPosition : pos;\n    }\n    case 'backup':\n      state.position -= entry.duration;\n      state.lastNonChordPosition = state.position;\n      return pos;\n    case 'forward':\n      state.position += entry.duration;\n      state.lastNonChordPosition = state.position;\n      return pos;\n    default:\n      return pos;\n  }\n}\n\n/** Get absolute position of a note within a measure */\nexport function getAbsolutePositionForNote(note: NoteEntry, measure: Measure): number {\n  const state = createPositionState();\n  for (const entry of measure.entries) {\n    if (entry === note) return entry.chord ? state.lastNonChordPosition : state.position;\n    updatePositionForEntry(state, entry);\n  }\n  return state.position;\n}\n\n/** Get position at end of measure */\nexport function getMeasureEndPosition(measure: Measure): number {\n  const state = createPositionState();\n  for (const entry of measure.entries) updatePositionForEntry(state, entry);\n  return state.position;\n}\n","import type {\n  Score,\n  Measure,\n  NoteEntry,\n  VoiceGroup,\n  StaffGroup,\n  NoteWithPosition,\n  Chord,\n  NoteIteratorItem,\n} from '../types';\nimport { getAbsolutePositionForNote, createPositionState, updatePositionForEntry } from '../utils';\n\n/**\n * Filter options for voice/staff selection\n */\nexport interface VoiceFilter {\n  voice?: number;\n  staff?: number;\n}\n\n/**\n * Get all notes for a specific voice (and optionally staff)\n */\nexport function getNotesForVoice(measure: Measure, filter: VoiceFilter): NoteEntry[] {\n  return measure.entries.filter((entry): entry is NoteEntry => {\n    if (entry.type !== 'note') return false;\n    if (filter.voice !== undefined && entry.voice !== filter.voice) return false;\n    if (filter.staff !== undefined && (entry.staff ?? 1) !== filter.staff) return false;\n    return true;\n  });\n}\n\n/**\n * Get all notes for a specific staff (regardless of voice)\n */\nexport function getNotesForStaff(measure: Measure, filter: { staff: number }): NoteEntry[] {\n  return measure.entries.filter((entry): entry is NoteEntry => {\n    if (entry.type !== 'note') return false;\n    return (entry.staff ?? 1) === filter.staff;\n  });\n}\n\n/**\n * Group notes by voice (and staff)\n */\nexport function groupByVoice(measure: Measure): VoiceGroup[] {\n  const groups = new Map<string, VoiceGroup>();\n\n  for (const entry of measure.entries) {\n    if (entry.type !== 'note') continue;\n\n    const staff = entry.staff ?? 1;\n    const voice = entry.voice;\n    const key = `${staff}-${voice}`;\n\n    if (!groups.has(key)) {\n      groups.set(key, { staff, voice, notes: [] });\n    }\n\n    groups.get(key)!.notes.push(entry);\n  }\n\n  // Sort by staff, then by voice\n  return Array.from(groups.values()).sort((a, b) => {\n    if (a.staff !== b.staff) return a.staff - b.staff;\n    return a.voice - b.voice;\n  });\n}\n\n/**\n * Group notes by staff\n */\nexport function groupByStaff(measure: Measure): StaffGroup[] {\n  const groups = new Map<number, StaffGroup>();\n\n  for (const entry of measure.entries) {\n    if (entry.type !== 'note') continue;\n\n    const staff = entry.staff ?? 1;\n\n    if (!groups.has(staff)) {\n      groups.set(staff, { staff, notes: [] });\n    }\n\n    groups.get(staff)!.notes.push(entry);\n  }\n\n  return Array.from(groups.values()).sort((a, b) => a.staff - b.staff);\n}\n\n/**\n * Calculate absolute position of a note within a measure\n * Position is in divisions from the start of the measure\n */\nexport function getAbsolutePosition(note: NoteEntry, measure: Measure): number {\n  return getAbsolutePositionForNote(note, measure);\n}\n\n/**\n * Add absolute position to all notes in a measure\n */\nexport function withAbsolutePositions(measure: Measure): NoteWithPosition[] {\n  const result: NoteWithPosition[] = [];\n  const state = createPositionState();\n\n  for (const entry of measure.entries) {\n    if (entry.type === 'note') {\n      const notePosition = entry.chord ? state.lastNonChordPosition : state.position;\n      result.push({\n        ...entry,\n        absolutePosition: notePosition,\n      });\n    }\n    updatePositionForEntry(state, entry);\n  }\n\n  return result;\n}\n\n/**\n * Get chords (groups of simultaneously sounding notes)\n */\nexport function getChords(measure: Measure, filter?: VoiceFilter): Chord[] {\n  const notesWithPos = withAbsolutePositions(measure);\n\n  // Filter by voice/staff if specified\n  const filteredNotes = filter\n    ? notesWithPos.filter((note) => {\n        if (filter.voice !== undefined && note.voice !== filter.voice) return false;\n        if (filter.staff !== undefined && (note.staff ?? 1) !== filter.staff) return false;\n        return true;\n      })\n    : notesWithPos;\n\n  // Group by position\n  const chordMap = new Map<number, NoteWithPosition[]>();\n\n  for (const note of filteredNotes) {\n    const pos = note.absolutePosition;\n    if (!chordMap.has(pos)) {\n      chordMap.set(pos, []);\n    }\n    chordMap.get(pos)!.push(note);\n  }\n\n  // Convert to Chord array\n  const chords: Chord[] = [];\n\n  for (const [position, notes] of chordMap.entries()) {\n    // All notes in a chord should have the same duration (using first note's duration)\n    const duration = notes[0].duration;\n\n    chords.push({\n      position,\n      duration,\n      notes: notes.map(({ absolutePosition, ...note }) => note),\n    });\n  }\n\n  // Sort by position\n  return chords.sort((a, b) => a.position - b.position);\n}\n\n/**\n * Iterate over all notes in a score\n */\nexport function* iterateNotes(score: Score): Generator<NoteIteratorItem> {\n  for (const part of score.parts) {\n    for (const measure of part.measures) {\n      const state = createPositionState();\n\n      for (const entry of measure.entries) {\n        if (entry.type === 'note') {\n          const notePosition = entry.chord ? state.lastNonChordPosition : state.position;\n          yield {\n            part,\n            measure,\n            note: entry,\n            position: notePosition,\n          };\n        }\n        updatePositionForEntry(state, entry);\n      }\n    }\n  }\n}\n\n/**\n * Get all notes from a score as an array\n */\nexport function getAllNotes(score: Score): NoteIteratorItem[] {\n  return Array.from(iterateNotes(score));\n}\n\n/**\n * Get unique voices used in a measure\n */\nexport function getVoices(measure: Measure): number[] {\n  const voices = new Set<number>();\n\n  for (const entry of measure.entries) {\n    if (entry.type === 'note') {\n      voices.add(entry.voice);\n    }\n  }\n\n  return Array.from(voices).sort((a, b) => a - b);\n}\n\n/**\n * Get unique staves used in a measure\n */\nexport function getStaves(measure: Measure): number[] {\n  const staves = new Set<number>();\n\n  for (const entry of measure.entries) {\n    if (entry.type === 'note') {\n      staves.add(entry.staff ?? 1);\n    }\n  }\n\n  return Array.from(staves).sort((a, b) => a - b);\n}\n\n/**\n * Check if a measure contains any notes\n */\nexport function hasNotes(measure: Measure): boolean {\n  return measure.entries.some((entry) => entry.type === 'note');\n}\n\n/**\n * Check if a measure is a rest (no pitched notes)\n */\nexport function isRestMeasure(measure: Measure): boolean {\n  const notes = measure.entries.filter((entry): entry is NoteEntry => entry.type === 'note');\n  return notes.length === 0 || notes.every((note) => !note.pitch);\n}\n\n/**\n * Options for normalized position calculation\n */\nexport interface NormalizedPositionOptions {\n  baseDivisions: number;\n  currentDivisions?: number;\n}\n\n/**\n * Get a normalized position of a note using a common base divisions\n * This is useful when comparing positions across measures with different divisions\n */\nexport function getNormalizedPosition(\n  note: NoteEntry,\n  measure: Measure,\n  options: NormalizedPositionOptions\n): number {\n  const absolutePosition = getAbsolutePosition(note, measure);\n  const currentDivisions = options.currentDivisions ?? measure.attributes?.divisions ?? 1;\n\n  // Convert from current divisions to base divisions\n  return (absolutePosition * options.baseDivisions) / currentDivisions;\n}\n\n/**\n * Get normalized duration of a note using a common base divisions\n */\nexport function getNormalizedDuration(\n  note: NoteEntry,\n  options: NormalizedPositionOptions\n): number {\n  const currentDivisions = options.currentDivisions ?? 1;\n  return (note.duration * options.baseDivisions) / currentDivisions;\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.mts

@@ -0,0 +1,285 @@
+import { S as Score, M as Measure, T as TimeSignature, P as Part, a as Pitch } from './types-DC_TnJu_.mjs';
+export { A as Accidental, i as AccidentalInfo, B as BackupEntry, p as Barline, k as BeamInfo, s as Chord, C as Clef, w as Credit, v as Defaults, D as DirectionEntry, m as DirectionType, n as DynamicsValue, F as ForwardEntry, K as KeySignature, L as Lyric, f as MeasureAttributes, g as MeasureEntry, l as Notation, N as NoteEntry, t as NoteIteratorItem, h as NoteType, r as NoteWithPosition, d as PartGroup, c as PartInfo, e as PartListEntry, u as Print, b as ScoreMetadata, q as StaffGroup, j as TieInfo, o as Transpose, V as VoiceGroup } from './types-DC_TnJu_.mjs';
+export { NormalizedPositionOptions, VoiceFilter, getAbsolutePosition, getAllNotes, getChords, getNormalizedDuration, getNormalizedPosition, getNotesForStaff, getNotesForVoice, getStaves, getVoices, groupByStaff, groupByVoice, hasNotes, isRestMeasure, iterateNotes, withAbsolutePositions } from './accessors/index.mjs';
+export { FindNotesFilter, PitchRange, RoundtripMetrics, countNotes, findNotes, getAttributesAtMeasure, getDivisions, getDuration, getMeasure, getMeasureByIndex, getMeasureCount, getPartById, getPartIndex, getStaveCount, hasMultipleStaves, measureRoundtrip, scoresEqual } from './query/index.mjs';
+export { AddNoteOptions, addChordNote, addNote, changeKey, changeTime, deleteMeasure, deleteNote, insertMeasure, modifyNoteDuration, modifyNotePitch, setDivisions, transpose } from './operations/index.mjs';
+
+declare function parse(xmlString: string): Score;
+
+/**
+ * Parse a compressed MusicXML (.mxl) file
+ * @param data - The compressed file data as Uint8Array or Buffer
+ * @returns The parsed Score
+ */
+declare function parseCompressed(data: Uint8Array): Score;
+/**
+ * Check if data is a compressed MusicXML file
+ * @param data - The file data
+ * @returns true if the data appears to be a ZIP file
+ */
+declare function isCompressed(data: Uint8Array): boolean;
+/**
+ * Parse either compressed (.mxl) or uncompressed (.xml/.musicxml) MusicXML
+ * Automatically detects the format
+ * @param data - The file data as Uint8Array or string
+ * @returns The parsed Score
+ */
+declare function parseAuto(data: Uint8Array | string): Score;
+
+type ValidationErrorCode = 'MISSING_DIVISIONS' | 'INVALID_DIVISIONS' | 'MEASURE_DURATION_MISMATCH' | 'MEASURE_DURATION_OVERFLOW' | 'MEASURE_DURATION_UNDERFLOW' | 'NEGATIVE_POSITION' | 'BACKUP_EXCEEDS_POSITION' | 'TIE_START_WITHOUT_STOP' | 'TIE_STOP_WITHOUT_START' | 'TIE_PITCH_MISMATCH' | 'BEAM_BEGIN_WITHOUT_END' | 'BEAM_END_WITHOUT_BEGIN' | 'SLUR_START_WITHOUT_STOP' | 'SLUR_STOP_WITHOUT_START' | 'TUPLET_START_WITHOUT_STOP' | 'TUPLET_STOP_WITHOUT_START' | 'PART_ID_NOT_IN_PART_LIST' | 'PART_LIST_ID_NOT_IN_PARTS' | 'PART_MEASURE_COUNT_MISMATCH' | 'PART_MEASURE_NUMBER_MISMATCH' | 'PART_GROUP_START_WITHOUT_STOP' | 'PART_GROUP_STOP_WITHOUT_START' | 'DUPLICATE_PART_ID' | 'INVALID_VOICE_NUMBER' | 'INVALID_STAFF_NUMBER' | 'STAFF_EXCEEDS_STAVES' | 'MISSING_STAVES_DECLARATION' | 'STAVES_DECLARATION_MISMATCH' | 'MISSING_CLEF_FOR_STAFF' | 'CLEF_STAFF_EXCEEDS_STAVES' | 'INVALID_DURATION' | 'EMPTY_MEASURE';
+type ValidationLevel = 'error' | 'warning' | 'info';
+interface ValidationLocation {
+    partIndex?: number;
+    partId?: string;
+    measureIndex?: number;
+    measureNumber?: string;
+    entryIndex?: number;
+    voice?: number;
+    staff?: number;
+}
+interface ValidationError {
+    code: ValidationErrorCode;
+    level: ValidationLevel;
+    message: string;
+    location: ValidationLocation;
+    details?: Record<string, unknown>;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationError[];
+    infos: ValidationError[];
+}
+interface ValidateOptions {
+    /** Check divisions consistency (default: true) */
+    checkDivisions?: boolean;
+    /** Check measure durations match time signature (default: true) */
+    checkMeasureDuration?: boolean;
+    /** Check backup/forward position consistency (default: true) */
+    checkPosition?: boolean;
+    /** Check tie start/stop pairing (default: true) */
+    checkTies?: boolean;
+    /** Check beam begin/end pairing (default: true) */
+    checkBeams?: boolean;
+    /** Check slur start/stop pairing (default: true) */
+    checkSlurs?: boolean;
+    /** Check tuplet start/stop pairing (default: true) */
+    checkTuplets?: boolean;
+    /** Check part ID references (default: true) */
+    checkPartReferences?: boolean;
+    /** Check part structure (measure count, numbers) (default: true) */
+    checkPartStructure?: boolean;
+    /** Check voice/staff numbers (default: true) */
+    checkVoiceStaff?: boolean;
+    /** Check staff structure (staves declaration, clefs) (default: true) */
+    checkStaffStructure?: boolean;
+    /** Tolerance for measure duration (in divisions, default: 0) */
+    durationTolerance?: number;
+}
+/**
+ * Validate a Score for internal consistency
+ */
+declare function validate(score: Score, options?: ValidateOptions): ValidationResult;
+/**
+ * Validate that divisions are defined and consistent
+ */
+declare function validateDivisions(score: Score): ValidationError[];
+/**
+ * Validate measure duration matches time signature
+ */
+declare function validateMeasureDuration(measure: Measure, divisions: number, time: TimeSignature, location: ValidationLocation, tolerance?: number): ValidationError[];
+/**
+ * Validate backup/forward position consistency
+ */
+declare function validateBackupForward(measure: Measure, location: ValidationLocation): ValidationError[];
+/**
+ * Validate tie start/stop pairing
+ */
+declare function validateTies(measure: Measure, location: ValidationLocation): ValidationError[];
+/**
+ * Validate beam begin/end pairing
+ */
+declare function validateBeams(measure: Measure, location: ValidationLocation): ValidationError[];
+/**
+ * Validate slur start/stop pairing
+ */
+declare function validateSlurs(measure: Measure, _location: ValidationLocation): ValidationError[];
+/**
+ * Validate tuplet start/stop pairing
+ */
+declare function validateTuplets(measure: Measure, location: ValidationLocation): ValidationError[];
+/**
+ * Validate part ID references between partList and parts
+ */
+declare function validatePartReferences(score: Score): ValidationError[];
+/**
+ * Validate voice and staff numbers
+ */
+declare function validateVoiceStaff(measure: Measure, staves: number, location: ValidationLocation): ValidationError[];
+/**
+ * Validate part structure (measure counts and numbers match across parts)
+ */
+declare function validatePartStructure(score: Score): ValidationError[];
+/**
+ * Validate staff structure within a part
+ */
+declare function validateStaffStructure(part: Part, partIndex: number): ValidationError[];
+/**
+ * Context needed to validate a single measure
+ */
+interface MeasureValidationContext {
+    /** Current divisions value (from previous attributes) */
+    divisions: number;
+    /** Current time signature */
+    time?: TimeSignature;
+    /** Current staves count */
+    staves: number;
+    /** Part index (for error location) */
+    partIndex: number;
+    /** Part ID (for error location) */
+    partId: string;
+    /** Measure index (for error location) */
+    measureIndex: number;
+}
+/**
+ * Options for local measure validation
+ */
+interface LocalValidateOptions {
+    checkMeasureDuration?: boolean;
+    checkPosition?: boolean;
+    checkBeams?: boolean;
+    checkTuplets?: boolean;
+    checkVoiceStaff?: boolean;
+    durationTolerance?: number;
+}
+/**
+ * Validate a single measure with provided context.
+ * This is useful for validating after local operations like addNote, deleteNote.
+ *
+ * @example
+ * ```typescript
+ * const context = getMeasureContext(score, partIndex, measureIndex);
+ * const errors = validateMeasureLocal(measure, context);
+ * if (errors.length > 0) {
+ *   throw new Error('Operation created invalid state');
+ * }
+ * ```
+ */
+declare function validateMeasureLocal(measure: Measure, context: MeasureValidationContext, options?: LocalValidateOptions): ValidationError[];
+/**
+ * Get the validation context for a measure by traversing previous attributes.
+ * This collects divisions, time, and staves from measure 0 to the target measure.
+ */
+declare function getMeasureContext(score: Score, partIndex: number, measureIndex: number): MeasureValidationContext;
+/**
+ * Validate a measure after an operation, throwing if invalid.
+ * Convenience wrapper around validateMeasureLocal.
+ */
+declare function assertMeasureValid(score: Score, partIndex: number, measureIndex: number, options?: LocalValidateOptions): void;
+/**
+ * Check if a score is valid (no errors)
+ */
+declare function isValid(score: Score, options?: ValidateOptions): boolean;
+/**
+ * Validate and throw if invalid
+ */
+declare function assertValid(score: Score, options?: ValidateOptions): void;
+/**
+ * Format a validation location for display
+ */
+declare function formatLocation(location: ValidationLocation): string;
+/**
+ * Validation exception with structured error information
+ */
+declare class ValidationException extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[], message: string);
+}
+/**
+ * Validate ties across measures
+ * This is more complex as ties can span multiple measures
+ */
+declare function validateTiesAcrossMeasures(part: Part): ValidationError[];
+/**
+ * Validate slurs across measures
+ */
+declare function validateSlursAcrossMeasures(part: Part): ValidationError[];
+
+interface SerializeOptions {
+    version?: '3.1' | '4.0';
+    indent?: string;
+    /** Validate score before serializing (default: false) */
+    validate?: boolean;
+    /** Options for validation (if validate is true) */
+    validateOptions?: ValidateOptions;
+    /** Throw error if validation fails (default: false, will only warn) */
+    throwOnValidationError?: boolean;
+    /** Callback to receive validation result */
+    onValidation?: (result: ValidationResult) => void;
+}
+declare function serialize(score: Score, options?: SerializeOptions): string;
+
+/**
+ * Serialize a Score to compressed MusicXML (.mxl) format
+ * @param score - The Score to serialize
+ * @param options - Serialization options
+ * @returns The compressed file data as Uint8Array
+ */
+declare function serializeCompressed(score: Score, options?: SerializeOptions): Uint8Array;
+
+/**
+ * MIDI export options
+ */
+interface MidiExportOptions {
+    /** Ticks per quarter note (default: 480) */
+    ticksPerQuarterNote?: number;
+    /** Default tempo in BPM (default: 120) */
+    defaultTempo?: number;
+    /** Default velocity for notes (default: 80) */
+    defaultVelocity?: number;
+}
+/**
+ * Export a Score to Standard MIDI File format (SMF Type 1)
+ * @param score - The Score to export
+ * @param options - Export options
+ * @returns The MIDI file data as Uint8Array
+ */
+declare function exportMidi(score: Score, options?: MidiExportOptions): Uint8Array;
+
+/**
+ * Parse a MusicXML file from disk
+ * Automatically handles both .xml/.musicxml and .mxl formats
+ * @param filePath - Path to the file
+ * @returns The parsed Score
+ */
+declare function parseFile(filePath: string): Promise<Score>;
+/**
+ * Detect encoding from BOM and decode buffer to string
+ * Supports UTF-8, UTF-16BE, UTF-16LE
+ */
+declare function decodeBuffer(buffer: Buffer): string;
+/**
+ * Export options combining all format options
+ */
+interface ExportOptions extends SerializeOptions, MidiExportOptions {
+}
+/**
+ * Serialize a Score to a file
+ * Format is determined by file extension:
+ * - .mxl: Compressed MusicXML
+ * - .xml/.musicxml: Uncompressed MusicXML
+ * - .mid/.midi: Standard MIDI File
+ * @param score - The Score to serialize
+ * @param filePath - Path to write the file
+ * @param options - Serialization options
+ */
+declare function serializeToFile(score: Score, filePath: string, options?: ExportOptions): Promise<void>;
+
+declare const STEPS: Pitch['step'][];
+declare const STEP_SEMITONES: Record<Pitch['step'], number>;
+/** Convert pitch to semitone value (MIDI-like) */
+declare function pitchToSemitone(pitch: Pitch): number;
+/** Get position at end of measure */
+declare function getMeasureEndPosition(measure: Measure): number;
+
+export { type LocalValidateOptions, Measure, type MeasureValidationContext, type MidiExportOptions, Part, Pitch, STEPS, STEP_SEMITONES, Score, type SerializeOptions, TimeSignature, type ValidateOptions, type ValidationError, type ValidationErrorCode, ValidationException, type ValidationLevel, type ValidationLocation, type ValidationResult, assertMeasureValid, assertValid, decodeBuffer, exportMidi, formatLocation, getMeasureContext, getMeasureEndPosition, isCompressed, isValid, parse, parseAuto, parseCompressed, parseFile, pitchToSemitone, serialize, serializeCompressed, serializeToFile, validate, validateBackupForward, validateBeams, validateDivisions, validateMeasureDuration, validateMeasureLocal, validatePartReferences, validatePartStructure, validateSlurs, validateSlursAcrossMeasures, validateStaffStructure, validateTies, validateTiesAcrossMeasures, validateTuplets, validateVoiceStaff };