musicxml-io 0.2.5 → 0.2.8

package/dist/index.d.ts

@@ -1,9 +1,8 @@
-import { S as Score, P as Pitch, M as Measure } from './types-D3LhKCDK.js';
-export { A as Accidental, i as AccidentalInfo, O as AdjacentNotes, a4 as AssembledLyrics, B as BackupEntry, p as Barline, a5 as BarlineWithContext, a0 as BeamGroup, j as BeamInfo, s as Chord, C as Clef, aa as ClefChangeInfo, w as Credit, v as Defaults, D as DirectionEntry, Q as DirectionKind, l as DirectionType, z as DirectionWithContext, R as DynamicWithContext, m as DynamicsValue, a7 as EndingInfo, E as EntryWithContext, F as ForwardEntry, a2 as HarmonyWithContext, a8 as KeyChangeInfo, K as KeySignature, L as Lyric, a3 as LyricWithContext, f as MeasureAttributes, g as MeasureEntry, k as Notation, a1 as NotationType, N as NoteEntry, t as NoteIteratorItem, h as NoteType, y as NoteWithContext, r as NoteWithPosition, Y as OctaveShiftWithContext, e as Part, c as PartGroup, b as PartInfo, d as PartListEntry, W as PedalWithContext, H as PositionQueryOptions, u as Print, a6 as RepeatInfo, a as ScoreMetadata, _ as SlurSpan, q as StaffGroup, G as StaffRange, ab as StructuralChanges, U as TempoWithContext, T as TieInfo, Z as TiedNoteGroup, a9 as TimeChangeInfo, n as TimeSignature, o as Transpose, $ as TupletGroup, I as VerticalSlice, V as VoiceGroup, J as VoiceLine, x as VoiceToStaffMap, X as WedgeWithContext } from './types-D3LhKCDK.js';
-import { V as ValidateOptions, a as ValidationResult } from './index-CJUkJI2P.js';
-export { L as LocalValidateOptions, M as MeasureValidationContext, G as ValidationError, I as ValidationErrorCode, C as ValidationException, J as ValidationLevel, H as ValidationLocation, g as addChordNote, b as addNote, F as assertMeasureValid, k as assertValid, c as changeKey, e as changeTime, f as deleteMeasure, d as deleteNote, B as formatLocation, E as getMeasureContext, i as insertMeasure, j as isValid, h as modifyNoteDuration, m as modifyNotePitch, t as transpose, v as validate, o as validateBackupForward, q as validateBeams, l as validateDivisions, n as validateMeasureDuration, D as validateMeasureLocal, u as validatePartReferences, w as validatePartStructure, r as validateSlurs, A as validateSlursAcrossMeasures, x as validateStaffStructure, p as validateTies, z as validateTiesAcrossMeasures, s as validateTuplets, y as validateVoiceStaff } from './index-CJUkJI2P.js';
-export { NormalizedPositionOptions, VoiceFilter, buildVoiceToStaffMap, buildVoiceToStaffMapForPart, findBarlines, findDirectionsByType, findNotesWithNotation, getAbsolutePosition, getAdjacentNotes, getAllNotes, getBeamGroups, getChordProgression, getChords, getClefChanges, getClefForStaff, getDirections, getDirectionsAtPosition, getDynamics, getEffectiveStaff, getEndings, getEntriesAtPosition, getEntriesForStaff, getEntriesInRange, getHarmonies, getHarmonyAtPosition, getKeyChanges, getLyricText, getLyrics, getNextNote, getNormalizedDuration, getNormalizedPosition, getNotesAtPosition, getNotesForStaff, getNotesForVoice, getNotesInRange, getOctaveShifts, getPartByIndex, getPartCount, getPartIds, getPedalMarkings, getPrevNote, getRepeatStructure, getSlurSpans, getStaffRange, getStaves, getStructuralChanges, getTempoMarkings, getTiedNoteGroups, getTimeChanges, getTupletGroups, getVerseCount, getVerticalSlice, getVoiceLine, getVoiceLineInRange, getVoices, getVoicesForStaff, getWedges, groupByStaff, groupByVoice, hasNotes, inferStaff, isRestMeasure, iterateEntries, iterateNotes, withAbsolutePositions } from './accessors/index.js';
-export { FindNotesFilter, PitchRange, RoundtripMetrics, countNotes, findNotes, getAttributesAtMeasure, getDivisions, getDuration, getMeasure, getMeasureByIndex, getMeasureCount, getPartById, getPartIndex, getStaveCount, hasMultipleStaves, measureRoundtrip, scoresEqual } from './query/index.js';
+import { S as Score, P as Pitch, M as Measure, D as DirectionType, a as DirectionEntry, N as NoteEntry, b as PartListEntry, c as PartInfo } from './types-Bpq2o5JS.js';
+export { A as Accidental, j as AccidentalInfo, O as AdjacentNotes, a4 as AssembledLyrics, B as BackupEntry, p as Barline, a5 as BarlineWithContext, a0 as BeamGroup, k as BeamInfo, s as Chord, C as Clef, aa as ClefChangeInfo, w as Credit, v as Defaults, Q as DirectionKind, z as DirectionWithContext, R as DynamicWithContext, m as DynamicsValue, a7 as EndingInfo, E as EntryWithContext, F as ForwardEntry, a2 as HarmonyWithContext, a8 as KeyChangeInfo, K as KeySignature, L as Lyric, a3 as LyricWithContext, g as MeasureAttributes, h as MeasureEntry, l as Notation, a1 as NotationType, t as NoteIteratorItem, i as NoteType, y as NoteWithContext, r as NoteWithPosition, Y as OctaveShiftWithContext, f as Part, e as PartGroup, W as PedalWithContext, H as PositionQueryOptions, u as Print, a6 as RepeatInfo, d as ScoreMetadata, _ as SlurSpan, q as StaffGroup, G as StaffRange, ab as StructuralChanges, U as TempoWithContext, T as TieInfo, Z as TiedNoteGroup, a9 as TimeChangeInfo, n as TimeSignature, o as Transpose, $ as TupletGroup, I as VerticalSlice, V as VoiceGroup, J as VoiceLine, x as VoiceToStaffMap, X as WedgeWithContext } from './types-Bpq2o5JS.js';
+import { V as ValidateOptions, a as ValidationResult } from './index-B-GcfEfL.js';
+export { L as LocalValidateOptions, M as MeasureValidationContext, G as ValidationError, I as ValidationErrorCode, C as ValidationException, J as ValidationLevel, H as ValidationLocation, g as addChordNote, b as addNote, F as assertMeasureValid, k as assertValid, c as changeKey, e as changeTime, f as deleteMeasure, d as deleteNote, B as formatLocation, E as getMeasureContext, i as insertMeasure, j as isValid, h as modifyNoteDuration, m as modifyNotePitch, t as transpose, v as validate, o as validateBackupForward, q as validateBeams, l as validateDivisions, n as validateMeasureDuration, D as validateMeasureLocal, u as validatePartReferences, w as validatePartStructure, r as validateSlurs, A as validateSlursAcrossMeasures, x as validateStaffStructure, p as validateTies, z as validateTiesAcrossMeasures, s as validateTuplets, y as validateVoiceStaff } from './index-B-GcfEfL.js';
+export { FindNotesFilter, NormalizedPositionOptions, PitchRange, RoundtripMetrics, VoiceFilter, buildVoiceToStaffMap, buildVoiceToStaffMapForPart, countNotes, findBarlines, findDirectionsByType, findNotes, findNotesWithNotation, getAbsolutePosition, getAdjacentNotes, getAllNotes, getAttributesAtMeasure, getBeamGroups, getChordProgression, getChords, getClefChanges, getClefForStaff, getDirections, getDirectionsAtPosition, getDivisions, getDuration, getDynamics, getEffectiveStaff, getEndings, getEntriesAtPosition, getEntriesForStaff, getEntriesInRange, getHarmonies, getHarmonyAtPosition, getKeyChanges, getLyricText, getLyrics, getMeasure, getMeasureByIndex, getMeasureCount, getNextNote, getNormalizedDuration, getNormalizedPosition, getNotesAtPosition, getNotesForStaff, getNotesForVoice, getNotesInRange, getOctaveShifts, getPartById, getPartByIndex, getPartCount, getPartIds, getPartIndex, getPedalMarkings, getPrevNote, getRepeatStructure, getSlurSpans, getStaffRange, getStaveCount, getStaves, getStructuralChanges, getTempoMarkings, getTiedNoteGroups, getTimeChanges, getTupletGroups, getVerseCount, getVerticalSlice, getVoiceLine, getVoiceLineInRange, getVoices, getVoicesForStaff, getWedges, groupByStaff, groupByVoice, hasMultipleStaves, hasNotes, inferStaff, isRestMeasure, iterateEntries, iterateNotes, measureRoundtrip, scoresEqual, withAbsolutePositions } from './query/index.js';
 
 declare function parse(xmlString: string): Score;
 
@@ -104,4 +103,199 @@ declare function pitchToSemitone(pitch: Pitch): number;
 /** Get position at end of measure */
 declare function getMeasureEndPosition(measure: Measure): number;
 
-export { Measure, type MidiExportOptions, Pitch, STEPS, STEP_SEMITONES, Score, type SerializeOptions, ValidateOptions, ValidationResult, decodeBuffer, exportMidi, getMeasureEndPosition, isCompressed, parse, parseAuto, parseCompressed, parseFile, pitchToSemitone, serialize, serializeCompressed, serializeToFile };
+/**
+ * Entry-level accessors for DirectionEntry, NoteEntry, and PartInfo
+ *
+ * These are simple helper functions for working with individual entries,
+ * complementing the score-level query functions in ./query.
+ */
+
+/**
+ * Extracts a specific DirectionType union member by its kind
+ */
+type DirectionTypeOfKind<K extends DirectionType['kind']> = Extract<DirectionType, {
+    kind: K;
+}>;
+/**
+ * Get the first direction type of a specific kind from a DirectionEntry
+ *
+ * @example
+ * const dynamics = getDirectionOfKind(entry, 'dynamics');
+ * if (dynamics) {
+ *   console.log(dynamics.value); // 'ff', 'pp', etc.
+ * }
+ */
+declare function getDirectionOfKind<K extends DirectionType['kind']>(entry: DirectionEntry, kind: K): DirectionTypeOfKind<K> | undefined;
+/**
+ * Get all direction types of a specific kind from a DirectionEntry
+ *
+ * @example
+ * const allWords = getDirectionsOfKind(entry, 'words');
+ * allWords.forEach(w => console.log(w.text));
+ */
+declare function getDirectionsOfKind<K extends DirectionType['kind']>(entry: DirectionEntry, kind: K): DirectionTypeOfKind<K>[];
+/**
+ * Check if a DirectionEntry contains a specific direction type
+ *
+ * @example
+ * if (hasDirectionOfKind(entry, 'metronome')) {
+ *   // Handle tempo marking
+ * }
+ */
+declare function hasDirectionOfKind(entry: DirectionEntry, kind: DirectionType['kind']): boolean;
+/**
+ * Get tempo from DirectionEntry.sound
+ *
+ * @example
+ * const tempo = getSoundTempo(entry); // 120
+ */
+declare function getSoundTempo(entry: DirectionEntry): number | undefined;
+/**
+ * Get dynamics value from DirectionEntry.sound (MIDI velocity 0-127)
+ *
+ * @example
+ * const dynamics = getSoundDynamics(entry); // 80
+ */
+declare function getSoundDynamics(entry: DirectionEntry): number | undefined;
+/**
+ * Get damper pedal state from DirectionEntry.sound
+ */
+declare function getSoundDamperPedal(entry: DirectionEntry): 'yes' | 'no' | undefined;
+/**
+ * Get soft pedal state from DirectionEntry.sound
+ */
+declare function getSoundSoftPedal(entry: DirectionEntry): 'yes' | 'no' | undefined;
+/**
+ * Get sostenuto pedal state from DirectionEntry.sound
+ */
+declare function getSoundSostenutoPedal(entry: DirectionEntry): 'yes' | 'no' | undefined;
+/**
+ * Check if a NoteEntry is a rest
+ *
+ * @example
+ * if (isRest(note)) {
+ *   console.log('This is a rest');
+ * }
+ */
+declare function isRest(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is a pitched note (has pitch information)
+ *
+ * @example
+ * if (isPitchedNote(note)) {
+ *   console.log(`Note: ${note.pitch!.step}${note.pitch!.octave}`);
+ * }
+ */
+declare function isPitchedNote(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is an unpitched note (percussion)
+ */
+declare function isUnpitchedNote(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is part of a chord (shares onset with previous note)
+ *
+ * @example
+ * const chordNotes = notes.filter(isChordNote);
+ */
+declare function isChordNote(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is a grace note
+ *
+ * @example
+ * if (isGraceNote(note)) {
+ *   console.log('Grace note with slash:', note.grace?.slash);
+ * }
+ */
+declare function isGraceNote(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has any tie (start, stop, or continue)
+ *
+ * @example
+ * if (hasTie(note)) {
+ *   // Note is tied to another note
+ * }
+ */
+declare function hasTie(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has a tie start
+ */
+declare function hasTieStart(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has a tie stop
+ */
+declare function hasTieStop(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is a cue note
+ */
+declare function isCueNote(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has any beams
+ */
+declare function hasBeam(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has any lyrics
+ */
+declare function hasLyrics(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry has any notations (articulations, slurs, ornaments, etc.)
+ */
+declare function hasNotations(entry: NoteEntry): boolean;
+/**
+ * Check if a NoteEntry is part of a tuplet
+ */
+declare function hasTuplet(entry: NoteEntry): boolean;
+/**
+ * Check if a PartListEntry is a PartInfo (score-part)
+ */
+declare function isPartInfo(entry: PartListEntry): entry is PartInfo;
+/**
+ * Get PartInfo by part ID
+ *
+ * @example
+ * const partInfo = getPartInfo(score, 'P1');
+ * if (partInfo) {
+ *   console.log(partInfo.name); // 'Piano'
+ * }
+ */
+declare function getPartInfo(score: Score, partId: string): PartInfo | undefined;
+/**
+ * Get part name by part ID
+ *
+ * @example
+ * const name = getPartName(score, 'P1'); // 'Piano'
+ */
+declare function getPartName(score: Score, partId: string): string | undefined;
+/**
+ * Get part abbreviation by part ID
+ *
+ * @example
+ * const abbr = getPartAbbreviation(score, 'P1'); // 'Pno.'
+ */
+declare function getPartAbbreviation(score: Score, partId: string): string | undefined;
+/**
+ * Get all PartInfo entries from a score
+ */
+declare function getAllPartInfos(score: Score): PartInfo[];
+/**
+ * Get a map of part ID to part name
+ *
+ * @example
+ * const names = getPartNameMap(score);
+ * // { 'P1': 'Piano', 'P2': 'Violin' }
+ */
+declare function getPartNameMap(score: Score): Record<string, string | undefined>;
+
+/**
+ * Generates a unique ID for elements in the Score structure.
+ *
+ * The ID format is "i" + nanoid(10), where:
+ * - "i" prefix ensures XML ID compatibility (XML IDs must start with a letter or underscore)
+ * - nanoid(10) generates a 10-character URL-safe unique identifier
+ *
+ * Example: "iV1StGXR8_"
+ *
+ * @returns A unique 11-character ID string
+ */
+declare function generateId(): string;
+
+export { DirectionEntry, DirectionType, type DirectionTypeOfKind, Measure, type MidiExportOptions, NoteEntry, PartInfo, PartListEntry, Pitch, STEPS, STEP_SEMITONES, Score, type SerializeOptions, ValidateOptions, ValidationResult, decodeBuffer, exportMidi, generateId, getAllPartInfos, getDirectionOfKind, getDirectionsOfKind, getMeasureEndPosition, getPartAbbreviation, getPartInfo, getPartName, getPartNameMap, getSoundDamperPedal, getSoundDynamics, getSoundSoftPedal, getSoundSostenutoPedal, getSoundTempo, hasBeam, hasDirectionOfKind, hasLyrics, hasNotations, hasTie, hasTieStart, hasTieStop, hasTuplet, isChordNote, isCompressed, isCueNote, isGraceNote, isPartInfo, isPitchedNote, isRest, isUnpitchedNote, parse, parseAuto, parseCompressed, parseFile, pitchToSemitone, serialize, serializeCompressed, serializeToFile };

package/dist/index.js

@@ -41,17 +41,21 @@ __export(src_exports, {
   findNotes: () => findNotes,
   findNotesWithNotation: () => findNotesWithNotation,
   formatLocation: () => formatLocation,
+  generateId: () => generateId,
   getAbsolutePosition: () => getAbsolutePosition,
   getAdjacentNotes: () => getAdjacentNotes,
   getAllNotes: () => getAllNotes,
+  getAllPartInfos: () => getAllPartInfos,
   getAttributesAtMeasure: () => getAttributesAtMeasure,
   getBeamGroups: () => getBeamGroups,
   getChordProgression: () => getChordProgression,
   getChords: () => getChords,
   getClefChanges: () => getClefChanges,
   getClefForStaff: () => getClefForStaff,
+  getDirectionOfKind: () => getDirectionOfKind,
   getDirections: () => getDirections,
   getDirectionsAtPosition: () => getDirectionsAtPosition,
+  getDirectionsOfKind: () => getDirectionsOfKind,
   getDivisions: () => getDivisions,
   getDuration: () => getDuration,
   getDynamics: () => getDynamics,
@@ -78,15 +82,24 @@ __export(src_exports, {
   getNotesForVoice: () => getNotesForVoice,
   getNotesInRange: () => getNotesInRange,
   getOctaveShifts: () => getOctaveShifts,
+  getPartAbbreviation: () => getPartAbbreviation,
   getPartById: () => getPartById,
   getPartByIndex: () => getPartByIndex,
   getPartCount: () => getPartCount,
   getPartIds: () => getPartIds,
   getPartIndex: () => getPartIndex,
+  getPartInfo: () => getPartInfo,
+  getPartName: () => getPartName,
+  getPartNameMap: () => getPartNameMap,
   getPedalMarkings: () => getPedalMarkings,
   getPrevNote: () => getPrevNote,
   getRepeatStructure: () => getRepeatStructure,
   getSlurSpans: () => getSlurSpans,
+  getSoundDamperPedal: () => getSoundDamperPedal,
+  getSoundDynamics: () => getSoundDynamics,
+  getSoundSoftPedal: () => getSoundSoftPedal,
+  getSoundSostenutoPedal: () => getSoundSostenutoPedal,
+  getSoundTempo: () => getSoundTempo,
   getStaffRange: () => getStaffRange,
   getStaveCount: () => getStaveCount,
   getStaves: () => getStaves,
@@ -104,12 +117,27 @@ __export(src_exports, {
   getWedges: () => getWedges,
   groupByStaff: () => groupByStaff,
   groupByVoice: () => groupByVoice,
+  hasBeam: () => hasBeam,
+  hasDirectionOfKind: () => hasDirectionOfKind,
+  hasLyrics: () => hasLyrics,
   hasMultipleStaves: () => hasMultipleStaves,
+  hasNotations: () => hasNotations,
   hasNotes: () => hasNotes,
+  hasTie: () => hasTie,
+  hasTieStart: () => hasTieStart,
+  hasTieStop: () => hasTieStop,
+  hasTuplet: () => hasTuplet,
   inferStaff: () => inferStaff,
   insertMeasure: () => insertMeasure,
+  isChordNote: () => isChordNote,
   isCompressed: () => isCompressed,
+  isCueNote: () => isCueNote,
+  isGraceNote: () => isGraceNote,
+  isPartInfo: () => isPartInfo,
+  isPitchedNote: () => isPitchedNote,
+  isRest: () => isRest,
   isRestMeasure: () => isRestMeasure,
+  isUnpitchedNote: () => isUnpitchedNote,
   isValid: () => isValid,
   iterateEntries: () => iterateEntries,
   iterateNotes: () => iterateNotes,
@@ -147,6 +175,14 @@ module.exports = __toCommonJS(src_exports);
 
 // src/importers/musicxml.ts
 var import_fast_xml_parser = require("fast-xml-parser");
+
+// src/id.ts
+var import_nanoid = require("nanoid");
+function generateId() {
+  return "i" + (0, import_nanoid.nanoid)(10);
+}
+
+// src/importers/musicxml.ts
 var xmlParser = new import_fast_xml_parser.XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
@@ -233,6 +269,7 @@ function parseScorePartwise(elements) {
   const defaults = parseDefaults(elements);
   const credits = parseCredits(elements);
   return {
+    _id: generateId(),
     metadata,
     partList,
     parts,
@@ -434,7 +471,7 @@ function parseSystemLayout(elements) {
 }
 function parseCredits(elements) {
   const credits = collectElements(elements, "credit", (content, attrs) => {
-    const credit = {};
+    const credit = { _id: generateId() };
     if (attrs["page"]) credit.page = parseInt(attrs["page"], 10);
     const types = collectElements(content, "credit-type", (c) => extractText(c));
     const words = collectElements(content, "credit-words", (c, a) => {
@@ -476,6 +513,7 @@ function parsePartList(elements) {
       const attrs = getAttributes(el);
       const content = el["score-part"];
       const partInfo = {
+        _id: generateId(),
         type: "score-part",
         id: attrs["id"] || ""
       };
@@ -568,6 +606,7 @@ function parsePartList(elements) {
       const attrs = getAttributes(el);
       const content = el["part-group"];
       const group = {
+        _id: generateId(),
         type: "part-group",
         groupType: attrs["type"] === "stop" ? "stop" : "start"
       };
@@ -603,6 +642,7 @@ function parseParts(elements) {
       const attrs = getAttributes(el);
       const content = el["part"];
       const part = {
+        _id: generateId(),
         id: attrs["id"] || "",
         measures: []
       };
@@ -620,6 +660,7 @@ function parseParts(elements) {
 }
 function parseMeasure(elements, attrs) {
   const measure = {
+    _id: generateId(),
     number: attrs["number"] || "0",
     // Keep as string per MusicXML spec (token type)
     entries: []
@@ -636,6 +677,7 @@ function parseMeasure(elements, attrs) {
         isFirstAttributes = false;
       } else {
         const attrEntry = {
+          _id: generateId(),
           type: "attributes",
           attributes: parsedAttrs
         };
@@ -861,6 +903,7 @@ function parseTranspose(elements) {
 }
 function parseNote(elements, attrs) {
   const note = {
+    _id: generateId(),
     type: "note",
     duration: getElementTextAsInt(elements, "duration", 0),
     voice: getElementTextAsInt(elements, "voice", 1)
@@ -1515,12 +1558,14 @@ function parseLyric(elements, attrs) {
 }
 function parseBackup(elements) {
   return {
+    _id: generateId(),
     type: "backup",
     duration: parseInt(getElementText(elements, "duration") || "0", 10)
   };
 }
 function parseForward(elements) {
   const forward = {
+    _id: generateId(),
     type: "forward",
     duration: parseInt(getElementText(elements, "duration") || "0", 10)
   };
@@ -1532,6 +1577,7 @@ function parseForward(elements) {
 }
 function parseDirection(elements, attrs) {
   const direction = {
+    _id: generateId(),
     type: "direction",
     directionTypes: []
   };
@@ -1907,7 +1953,7 @@ function parseDirectionType(elements) {
 }
 function parseBarline(elements, attrs) {
   const location = attrs["location"] || "right";
-  const barline = { location };
+  const barline = { _id: generateId(), location };
   const barStyle = getElementText(elements, "bar-style");
   if (barStyle && isValidBarStyle(barStyle)) {
     barline.barStyle = barStyle;
@@ -2123,6 +2169,7 @@ function parseMeasureStyle(elements, attrs) {
 }
 function parseHarmony(elements, attrs) {
   const harmony = {
+    _id: generateId(),
     type: "harmony",
     root: { rootStep: "C" },
     kind: "major"
@@ -2246,6 +2293,7 @@ function parseHarmony(elements, attrs) {
 }
 function parseFiguredBass(elements, attrs) {
   const fb = {
+    _id: generateId(),
     type: "figured-bass",
     figures: []
   };
@@ -2292,6 +2340,7 @@ function parseFiguredBass(elements, attrs) {
 }
 function parseSound(elements, attrs) {
   const sound = {
+    _id: generateId(),
     type: "sound"
   };
   if (attrs["tempo"]) sound.tempo = parseFloat(attrs["tempo"]);
@@ -5509,7 +5558,7 @@ function getMeasureEndPosition(measure) {
   return state.position;
 }
 
-// src/accessors/index.ts
+// src/query/index.ts
 function getNotesForVoice(measure, filter) {
   return measure.entries.filter((entry) => {
     if (entry.type !== "note") return false;
@@ -6250,17 +6299,17 @@ function getTiedNoteGroups(score, options) {
             measureIndex,
             position
           };
-          const hasTieStart = entry.tie?.type === "start" || entry.ties?.some((t) => t.type === "start") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "start");
-          const hasTieStop = entry.tie?.type === "stop" || entry.ties?.some((t) => t.type === "stop") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "stop");
-          if (hasTieStop && pendingTies.has(pitchKey)) {
+          const hasTieStart2 = entry.tie?.type === "start" || entry.ties?.some((t) => t.type === "start") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "start");
+          const hasTieStop2 = entry.tie?.type === "stop" || entry.ties?.some((t) => t.type === "stop") || entry.notations?.some((n) => n.type === "tied" && n.tiedType === "stop");
+          if (hasTieStop2 && pendingTies.has(pitchKey)) {
             const group = pendingTies.get(pitchKey);
             group.push(context);
-            if (!hasTieStart) {
+            if (!hasTieStart2) {
               const totalDuration = group.reduce((sum, nc) => sum + nc.note.duration, 0);
               results.push({ notes: group, totalDuration });
               pendingTies.delete(pitchKey);
             }
-          } else if (hasTieStart) {
+          } else if (hasTieStart2) {
             pendingTies.set(pitchKey, [context]);
           }
         }
@@ -6856,8 +6905,6 @@ function getPartCount(score) {
 function getPartIds(score) {
   return score.parts.map((part) => part.id);
 }
-
-// src/query/index.ts
 function getMeasure(score, options) {
   const part = score.parts[options.part];
   if (!part) return void 0;
@@ -6935,8 +6982,8 @@ function findNotes(score, filter) {
         if (filter.staff !== void 0 && (entry.staff ?? 1) !== filter.staff) continue;
         if (filter.noteType !== void 0 && entry.noteType !== filter.noteType) continue;
         if (filter.hasTie !== void 0) {
-          const hasTie = entry.tie !== void 0;
-          if (filter.hasTie !== hasTie) continue;
+          const hasTie2 = entry.tie !== void 0;
+          if (filter.hasTie !== hasTie2) continue;
         }
         results.push(entry);
       }
@@ -7140,6 +7187,7 @@ function hasNotesInRange(voiceEntries, startPos, endPos) {
 }
 function createRest(duration, voice, staff) {
   return {
+    _id: generateId(),
     type: "note",
     rest: { displayStep: void 0, displayOctave: void 0 },
     duration,
@@ -7201,10 +7249,11 @@ function rebuildMeasureWithVoice(measure, voice, newEntries, measureDuration, st
   for (const { position: targetPos, entry } of allEntries) {
     const diff = targetPos - currentPosition;
     if (diff < 0) {
-      result.push({ type: "backup", duration: -diff });
+      result.push({ _id: generateId(), type: "backup", duration: -diff });
       currentPosition = targetPos;
     } else if (diff > 0) {
       result.push({
+        _id: generateId(),
         type: "forward",
         duration: diff,
         voice: entry.type === "note" ? entry.voice : 1,
@@ -7259,6 +7308,7 @@ function insertNote(score, options) {
     )]);
   }
   const newNote = {
+    _id: generateId(),
     type: "note",
     pitch: options.pitch,
     duration: options.duration,
@@ -7365,6 +7415,7 @@ function addChord(score, options) {
     return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
   }
   const chordNote = {
+    _id: generateId(),
     type: "note",
     pitch: options.pitch,
     duration: targetEntry.duration,
@@ -7588,7 +7639,7 @@ function insertMeasure(score, options) {
     if (insertIndex === -1) continue;
     const numericPart = parseInt(targetMeasure, 10);
     const newMeasureNumber = String(isNaN(numericPart) ? insertIndex + 2 : numericPart + 1);
-    const newMeasure = { number: newMeasureNumber, entries: [] };
+    const newMeasure = { _id: generateId(), number: newMeasureNumber, entries: [] };
     if (options.copyAttributes && part.measures[insertIndex].attributes) {
       newMeasure.attributes = { ...part.measures[insertIndex].attributes };
     }
@@ -7684,6 +7735,97 @@ async function serializeToFile(score, filePath, options = {}) {
     await (0, import_promises.writeFile)(filePath, xmlString, "utf-8");
   }
 }
+
+// src/entry-accessors.ts
+function getDirectionOfKind(entry, kind) {
+  return entry.directionTypes.find((d) => d.kind === kind);
+}
+function getDirectionsOfKind(entry, kind) {
+  return entry.directionTypes.filter((d) => d.kind === kind);
+}
+function hasDirectionOfKind(entry, kind) {
+  return entry.directionTypes.some((d) => d.kind === kind);
+}
+function getSoundTempo(entry) {
+  return entry.sound?.tempo;
+}
+function getSoundDynamics(entry) {
+  return entry.sound?.dynamics;
+}
+function getSoundDamperPedal(entry) {
+  return entry.sound?.damperPedal;
+}
+function getSoundSoftPedal(entry) {
+  return entry.sound?.softPedal;
+}
+function getSoundSostenutoPedal(entry) {
+  return entry.sound?.sostenutoPedal;
+}
+function isRest(entry) {
+  return entry.rest !== void 0 || !entry.pitch && !entry.unpitched;
+}
+function isPitchedNote(entry) {
+  return entry.pitch !== void 0;
+}
+function isUnpitchedNote(entry) {
+  return entry.unpitched !== void 0;
+}
+function isChordNote(entry) {
+  return entry.chord === true;
+}
+function isGraceNote(entry) {
+  return entry.grace !== void 0;
+}
+function hasTie(entry) {
+  return entry.tie !== void 0 || entry.ties !== void 0 && entry.ties.length > 0;
+}
+function hasTieStart(entry) {
+  if (entry.tie?.type === "start") return true;
+  return entry.ties?.some((t) => t.type === "start") ?? false;
+}
+function hasTieStop(entry) {
+  if (entry.tie?.type === "stop") return true;
+  return entry.ties?.some((t) => t.type === "stop") ?? false;
+}
+function isCueNote(entry) {
+  return entry.cue === true;
+}
+function hasBeam(entry) {
+  return entry.beam !== void 0 && entry.beam.length > 0;
+}
+function hasLyrics(entry) {
+  return entry.lyrics !== void 0 && entry.lyrics.length > 0;
+}
+function hasNotations(entry) {
+  return entry.notations !== void 0 && entry.notations.length > 0;
+}
+function hasTuplet(entry) {
+  return entry.timeModification !== void 0;
+}
+function isPartInfo(entry) {
+  return entry.type === "score-part";
+}
+function getPartInfo(score, partId) {
+  return score.partList.find((entry) => {
+    return entry.type === "score-part" && entry.id === partId;
+  });
+}
+function getPartName(score, partId) {
+  return getPartInfo(score, partId)?.name;
+}
+function getPartAbbreviation(score, partId) {
+  return getPartInfo(score, partId)?.abbreviation;
+}
+function getAllPartInfos(score) {
+  return score.partList.filter(isPartInfo);
+}
+function getPartNameMap(score) {
+  const map = {};
+  for (const part of getAllPartInfos(score)) {
+    map[part.id] = part.name;
+  }
+  return map;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   STEPS,
@@ -7707,17 +7849,21 @@ async function serializeToFile(score, filePath, options = {}) {
   findNotes,
   findNotesWithNotation,
   formatLocation,
+  generateId,
   getAbsolutePosition,
   getAdjacentNotes,
   getAllNotes,
+  getAllPartInfos,
   getAttributesAtMeasure,
   getBeamGroups,
   getChordProgression,
   getChords,
   getClefChanges,
   getClefForStaff,
+  getDirectionOfKind,
   getDirections,
   getDirectionsAtPosition,
+  getDirectionsOfKind,
   getDivisions,
   getDuration,
   getDynamics,
@@ -7744,15 +7890,24 @@ async function serializeToFile(score, filePath, options = {}) {
   getNotesForVoice,
   getNotesInRange,
   getOctaveShifts,
+  getPartAbbreviation,
   getPartById,
   getPartByIndex,
   getPartCount,
   getPartIds,
   getPartIndex,
+  getPartInfo,
+  getPartName,
+  getPartNameMap,
   getPedalMarkings,
   getPrevNote,
   getRepeatStructure,
   getSlurSpans,
+  getSoundDamperPedal,
+  getSoundDynamics,
+  getSoundSoftPedal,
+  getSoundSostenutoPedal,
+  getSoundTempo,
   getStaffRange,
   getStaveCount,
   getStaves,
@@ -7770,12 +7925,27 @@ async function serializeToFile(score, filePath, options = {}) {
   getWedges,
   groupByStaff,
   groupByVoice,
+  hasBeam,
+  hasDirectionOfKind,
+  hasLyrics,
   hasMultipleStaves,
+  hasNotations,
   hasNotes,
+  hasTie,
+  hasTieStart,
+  hasTieStop,
+  hasTuplet,
   inferStaff,
   insertMeasure,
+  isChordNote,
   isCompressed,
+  isCueNote,
+  isGraceNote,
+  isPartInfo,
+  isPitchedNote,
+  isRest,
   isRestMeasure,
+  isUnpitchedNote,
   isValid,
   iterateEntries,
   iterateNotes,