musicxml-io 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -378,8 +378,10 @@ function parsePartList(elements) {
           const sound = getElementText(instContent, "instrument-sound");
           if (sound) inst.sound = sound;
           if (hasElement(instContent, "solo")) inst.solo = true;
-          const ens = getElementText(instContent, "ensemble");
-          if (ens) inst.ensemble = parseInt(ens, 10);
+          if (hasElement(instContent, "ensemble")) {
+            const ensText = getElementText(instContent, "ensemble");
+            inst.ensemble = ensText ? parseInt(ensText, 10) : 0;
+          }
           instruments.push(inst);
         }
       }
@@ -562,6 +564,8 @@ function parseAttributes(elements) {
   if (divisions !== void 0) attrs.divisions = divisions;
   const staves = getElementTextAsInt(elements, "staves");
   if (staves !== void 0) attrs.staves = staves;
+  const instruments = getElementTextAsInt(elements, "instruments");
+  if (instruments !== void 0) attrs.instruments = instruments;
   const time = getElementContent(elements, "time");
   if (time) {
     attrs.time = parseTimeSignature(time, elements);
@@ -658,7 +662,7 @@ function parseKeySignature(elements) {
   const key = {
     fifths: parseInt(fifths || "0", 10)
   };
-  const validModes = ["major", "minor", "dorian", "phrygian", "lydian", "mixolydian", "aeolian", "ionian", "locrian"];
+  const validModes = ["major", "minor", "dorian", "phrygian", "lydian", "mixolydian", "aeolian", "ionian", "locrian", "none"];
   if (mode && validModes.includes(mode)) {
     key.mode = mode;
   }
@@ -689,6 +693,12 @@ function parseClef(elements, attrs) {
   if (octaveChange !== void 0) {
     clef.clefOctaveChange = octaveChange;
   }
+  if (attrs["print-object"] === "no") {
+    clef.printObject = false;
+  }
+  if (attrs["after-barline"] === "yes") {
+    clef.afterBarline = true;
+  }
   return clef;
 }
 function parseTranspose(elements) {
@@ -898,6 +908,7 @@ function parseNotations(elements, notationsIndex = 0) {
         slurType: attrs["type"] || "start",
         number: attrs["number"] ? parseInt(attrs["number"], 10) : void 0,
         lineType: attrs["line-type"],
+        orientation: attrs["orientation"],
         defaultX: attrs["default-x"] ? parseFloat(attrs["default-x"]) : void 0,
         defaultY: attrs["default-y"] ? parseFloat(attrs["default-y"]) : void 0,
         bezierX: attrs["bezier-x"] ? parseFloat(attrs["bezier-x"]) : void 0,
@@ -1410,6 +1421,9 @@ function parseDirection(elements, attrs) {
       direction.sound = {};
       if (soundAttrs["tempo"]) direction.sound.tempo = parseFloat(soundAttrs["tempo"]);
       if (soundAttrs["dynamics"]) direction.sound.dynamics = parseFloat(soundAttrs["dynamics"]);
+      if (soundAttrs["damper-pedal"]) direction.sound.damperPedal = soundAttrs["damper-pedal"];
+      if (soundAttrs["soft-pedal"]) direction.sound.softPedal = soundAttrs["soft-pedal"];
+      if (soundAttrs["sostenuto-pedal"]) direction.sound.sostenutoPedal = soundAttrs["sostenuto-pedal"];
       for (const soundEl of soundContent) {
         if (soundEl["midi-instrument"]) {
           const midiAttrs = getAttributes(soundEl);
@@ -1570,6 +1584,8 @@ function parseDirectionType(elements) {
         if (bracketAttrs["number"]) result.number = parseInt(bracketAttrs["number"], 10);
         if (bracketAttrs["line-end"]) result.lineEnd = bracketAttrs["line-end"];
         if (bracketAttrs["line-type"]) result.lineType = bracketAttrs["line-type"];
+        if (bracketAttrs["default-y"]) result.defaultY = parseFloat(bracketAttrs["default-y"]);
+        if (bracketAttrs["relative-x"]) result.relativeX = parseFloat(bracketAttrs["relative-x"]);
         return result;
       }
     }
@@ -1869,6 +1885,8 @@ var VALID_BAR_STYLES = /* @__PURE__ */ new Set([
   "light-heavy",
   "heavy-light",
   "heavy-heavy",
+  "tick",
+  "short",
   "none"
 ]);
 function isValidNoteType(value) {
@@ -2138,6 +2156,9 @@ function parseSound(elements, attrs) {
   if (attrs["tocoda"]) sound.tocoda = attrs["tocoda"];
   if (attrs["fine"] === "yes") sound.fine = true;
   if (attrs["forward-repeat"] === "yes") sound.forwardRepeat = true;
+  if (attrs["damper-pedal"]) sound.damperPedal = attrs["damper-pedal"];
+  if (attrs["soft-pedal"]) sound.softPedal = attrs["soft-pedal"];
+  if (attrs["sostenuto-pedal"]) sound.sostenutoPedal = attrs["sostenuto-pedal"];
   for (const el of elements) {
     if (el["swing"]) {
       const swingContent = el["swing"];
@@ -2234,6 +2255,8 @@ function parseAuto(data) {
 var DEFAULT_OPTIONS = {
   checkDivisions: true,
   checkMeasureDuration: true,
+  checkMeasureFullness: false,
+  // Piano Roll semantics - opt-in
   checkPosition: true,
   checkTies: true,
   checkBeams: true,
@@ -2290,6 +2313,14 @@ function validate(score, options = {}) {
           opts.durationTolerance
         ));
       }
+      if (opts.checkMeasureFullness && currentTime) {
+        allErrors.push(...validateMeasureFullness(
+          measure,
+          currentDivisions,
+          currentTime,
+          location
+        ));
+      }
       if (opts.checkPosition) {
         allErrors.push(...validateBackupForward(measure, location));
       }
@@ -2438,6 +2469,92 @@ function calculateVoiceDurations(measure) {
   }
   return voiceDurations;
 }
+function validateMeasureFullness(measure, divisions, time, location) {
+  const errors = [];
+  if (time.senzaMisura) {
+    return errors;
+  }
+  const beats = parseInt(time.beats, 10);
+  if (isNaN(beats)) {
+    return errors;
+  }
+  const expectedDuration = beats / time.beatType * 4 * divisions;
+  const voiceCoverage = /* @__PURE__ */ new Map();
+  let currentPosition = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      const staff = entry.staff ?? 1;
+      const voice = entry.voice;
+      const key = `${staff}-${voice}`;
+      if (!entry.chord) {
+        if (!voiceCoverage.has(key)) {
+          voiceCoverage.set(key, { segments: [] });
+        }
+        voiceCoverage.get(key).segments.push({
+          start: currentPosition,
+          end: currentPosition + entry.duration
+        });
+        currentPosition += entry.duration;
+      }
+    } else if (entry.type === "backup") {
+      currentPosition -= entry.duration;
+    } else if (entry.type === "forward") {
+      const staff = entry.staff ?? 1;
+      const voice = entry.voice ?? 1;
+      const key = `${staff}-${voice}`;
+      if (!voiceCoverage.has(key)) {
+        voiceCoverage.set(key, { segments: [] });
+      }
+      voiceCoverage.get(key).segments.push({
+        start: currentPosition,
+        end: currentPosition + entry.duration
+      });
+      currentPosition += entry.duration;
+    }
+  }
+  for (const [voiceKey, { segments }] of voiceCoverage.entries()) {
+    const [staff, voice] = voiceKey.split("-").map(Number);
+    const sorted = [...segments].sort((a, b) => a.start - b.start);
+    let lastEnd = 0;
+    const gaps = [];
+    for (const seg of sorted) {
+      if (seg.start > lastEnd) {
+        gaps.push({ start: lastEnd, end: seg.start });
+      }
+      lastEnd = Math.max(lastEnd, seg.end);
+    }
+    if (lastEnd < expectedDuration) {
+      gaps.push({ start: lastEnd, end: expectedDuration });
+    }
+    for (const gap of gaps) {
+      errors.push({
+        code: "VOICE_GAP",
+        level: "warning",
+        message: `Voice ${voice} (staff ${staff}) has gap from position ${gap.start} to ${gap.end}`,
+        location: { ...location, voice, staff },
+        details: {
+          gapStart: gap.start,
+          gapEnd: gap.end,
+          gapDuration: gap.end - gap.start
+        }
+      });
+    }
+    if (lastEnd < expectedDuration) {
+      errors.push({
+        code: "VOICE_INCOMPLETE",
+        level: "warning",
+        message: `Voice ${voice} (staff ${staff}) ends at ${lastEnd}, expected ${expectedDuration}`,
+        location: { ...location, voice, staff },
+        details: {
+          actualEnd: lastEnd,
+          expectedDuration,
+          missing: expectedDuration - lastEnd
+        }
+      });
+    }
+  }
+  return errors;
+}
 function validateBackupForward(measure, location) {
   const errors = [];
   let position = 0;
@@ -2904,6 +3021,8 @@ function validateStaffStructure(part, partIndex) {
 }
 var DEFAULT_LOCAL_OPTIONS = {
   checkMeasureDuration: true,
+  checkMeasureFullness: false,
+  // Piano Roll semantics - opt-in
   checkPosition: true,
   checkBeams: true,
   checkTuplets: true,
@@ -2928,6 +3047,14 @@ function validateMeasureLocal(measure, context, options = {}) {
       opts.durationTolerance
     ));
   }
+  if (opts.checkMeasureFullness && context.time) {
+    errors.push(...validateMeasureFullness(
+      measure,
+      context.divisions,
+      context.time,
+      location
+    ));
+  }
   if (opts.checkPosition) {
     errors.push(...validateBackupForward(measure, location));
   }
@@ -3494,7 +3621,11 @@ function serializeScorePart(part, indent) {
         lines.push(`${indent}    <solo/>`);
       }
       if (inst.ensemble !== void 0) {
-        lines.push(`${indent}    <ensemble>${inst.ensemble}</ensemble>`);
+        if (inst.ensemble === 0) {
+          lines.push(`${indent}    <ensemble/>`);
+        } else {
+          lines.push(`${indent}    <ensemble>${inst.ensemble}</ensemble>`);
+        }
       }
       lines.push(`${indent}  </score-instrument>`);
     }
@@ -3674,6 +3805,9 @@ function serializeAttributes(attrs, indent) {
   if (attrs.staves !== void 0) {
     lines.push(`${indent}  <staves>${attrs.staves}</staves>`);
   }
+  if (attrs.instruments !== void 0) {
+    lines.push(`${indent}  <instruments>${attrs.instruments}</instruments>`);
+  }
   if (attrs.clef) {
     for (const clef of attrs.clef) {
       lines.push(...serializeClef(clef, indent + "  "));
@@ -3762,8 +3896,10 @@ function serializeTime(time, indent) {
 }
 function serializeClef(clef, indent) {
   const lines = [];
-  const numberAttr = clef.staff ? ` number="${clef.staff}"` : "";
-  lines.push(`${indent}<clef${numberAttr}>`);
+  let attrs = clef.staff ? ` number="${clef.staff}"` : "";
+  if (clef.printObject === false) attrs += ' print-object="no"';
+  if (clef.afterBarline) attrs += ' after-barline="yes"';
+  lines.push(`${indent}<clef${attrs}>`);
   lines.push(`${indent}  <sign>${clef.sign}</sign>`);
   lines.push(`${indent}  <line>${clef.line}</line>`);
   if (clef.clefOctaveChange !== void 0) {
@@ -4012,6 +4148,7 @@ function serializeNotationsGroup(notations, indent) {
       if (notation.number !== void 0) attrs += ` number="${notation.number}"`;
       attrs += ` type="${notation.slurType}"`;
       if (notation.lineType) attrs += ` line-type="${notation.lineType}"`;
+      if (notation.orientation) attrs += ` orientation="${notation.orientation}"`;
       if (notation.defaultX !== void 0) attrs += ` default-x="${notation.defaultX}"`;
       if (notation.defaultY !== void 0) attrs += ` default-y="${notation.defaultY}"`;
       if (notation.bezierX !== void 0) attrs += ` bezier-x="${notation.bezierX}"`;
@@ -4325,6 +4462,15 @@ function serializeDirection(direction, indent) {
     if (direction.sound.dynamics !== void 0) {
       attrs2.push(`dynamics="${direction.sound.dynamics}"`);
     }
+    if (direction.sound.damperPedal) {
+      attrs2.push(`damper-pedal="${direction.sound.damperPedal}"`);
+    }
+    if (direction.sound.softPedal) {
+      attrs2.push(`soft-pedal="${direction.sound.softPedal}"`);
+    }
+    if (direction.sound.sostenutoPedal) {
+      attrs2.push(`sostenuto-pedal="${direction.sound.sostenutoPedal}"`);
+    }
     const attrStr = attrs2.length > 0 ? ` ${attrs2.join(" ")}` : "";
     if (direction.sound.midiInstrument) {
       lines.push(`${indent}  <sound${attrStr}>`);
@@ -4429,6 +4575,8 @@ function serializeDirectionType(dirType, indent) {
       if (dirType.number !== void 0) bracketAttrs += ` number="${dirType.number}"`;
       if (dirType.lineEnd) bracketAttrs += ` line-end="${dirType.lineEnd}"`;
       if (dirType.lineType) bracketAttrs += ` line-type="${dirType.lineType}"`;
+      if (dirType.defaultY !== void 0) bracketAttrs += ` default-y="${dirType.defaultY}"`;
+      if (dirType.relativeX !== void 0) bracketAttrs += ` relative-x="${dirType.relativeX}"`;
       lines.push(`${indent}  <bracket${bracketAttrs}/>`);
       break;
     }
@@ -4763,6 +4911,9 @@ function serializeSound(sound, indent) {
   if (sound.tocoda) attrs.push(`tocoda="${escapeXml(sound.tocoda)}"`);
   if (sound.fine) attrs.push('fine="yes"');
   if (sound.forwardRepeat) attrs.push('forward-repeat="yes"');
+  if (sound.damperPedal) attrs.push(`damper-pedal="${sound.damperPedal === true ? "yes" : sound.damperPedal}"`);
+  if (sound.softPedal) attrs.push(`soft-pedal="${sound.softPedal === true ? "yes" : sound.softPedal}"`);
+  if (sound.sostenutoPedal) attrs.push(`sostenuto-pedal="${sound.sostenutoPedal === true ? "yes" : sound.sostenutoPedal}"`);
   const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
   if (sound.swing) {
     lines.push(`${indent}<sound${attrStr}>`);
@@ -5355,178 +5506,1381 @@ function getNormalizedDuration(note, options) {
   const currentDivisions = options.currentDivisions ?? 1;
   return note.duration * options.baseDivisions / currentDivisions;
 }
-
-// src/query/index.ts
-function getMeasure(score, options) {
-  const part = score.parts[options.part];
-  if (!part) return void 0;
-  const targetMeasure = String(options.measure);
-  return part.measures.find((m) => m.number === targetMeasure);
-}
-function getMeasureByIndex(score, options) {
-  const part = score.parts[options.part];
-  if (!part) return void 0;
-  return part.measures[options.measureIndex];
-}
-function getMeasureCount(score) {
-  if (score.parts.length === 0) return 0;
-  return score.parts[0].measures.length;
-}
-function getDivisions(score, options) {
-  const part = score.parts[options.part];
-  if (!part) return 1;
-  const targetMeasure = parseInt(String(options.measure), 10);
-  if (isNaN(targetMeasure)) return 1;
-  for (let i = 0; i < part.measures.length; i++) {
-    const m = part.measures[i];
-    const mNum = parseInt(m.number, 10);
-    if (!isNaN(mNum) && mNum > targetMeasure) break;
-    if (m.attributes?.divisions !== void 0) {
+function getEntriesForStaff(measure, staff) {
+  return measure.entries.filter((entry) => {
+    if (entry.type === "note") {
+      return (entry.staff ?? 1) === staff;
     }
-  }
-  let divisions = 1;
-  for (const m of part.measures) {
-    const mNum = parseInt(m.number, 10);
-    if (!isNaN(mNum) && mNum > targetMeasure) break;
-    if (m.attributes?.divisions !== void 0) {
-      divisions = m.attributes.divisions;
+    if (entry.type === "forward") {
+      return (entry.staff ?? 1) === staff;
     }
-  }
-  return divisions;
+    if (entry.type === "direction") {
+      return (entry.staff ?? 1) === staff;
+    }
+    if (entry.type === "backup") {
+      return false;
+    }
+    return false;
+  });
 }
-function getAttributesAtMeasure(score, options) {
-  const part = score.parts[options.part];
-  if (!part) return {};
-  const targetMeasure = parseInt(String(options.measure), 10);
-  const result = {};
-  for (const m of part.measures) {
-    const mNum = parseInt(m.number, 10);
-    if (!isNaN(targetMeasure) && !isNaN(mNum) && mNum > targetMeasure) break;
-    if (m.attributes) {
-      if (m.attributes.divisions !== void 0) result.divisions = m.attributes.divisions;
-      if (m.attributes.time !== void 0) result.time = m.attributes.time;
-      if (m.attributes.key !== void 0) result.key = m.attributes.key;
-      if (m.attributes.clef !== void 0) result.clef = m.attributes.clef;
-      if (m.attributes.staves !== void 0) result.staves = m.attributes.staves;
-      if (m.attributes.transpose !== void 0) result.transpose = m.attributes.transpose;
+function buildVoiceToStaffMap(measure) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && entry.staff !== void 0) {
+      const voice = entry.voice;
+      const staff = entry.staff;
+      if (!map.has(voice)) {
+        map.set(voice, staff);
+      }
     }
   }
-  return result;
+  return {
+    get: (voice) => map.get(voice),
+    has: (voice) => map.has(voice),
+    entries: () => map.entries(),
+    size: map.size
+  };
 }
-function findNotes(score, filter) {
-  const results = [];
-  for (const part of score.parts) {
-    for (const measure of part.measures) {
-      for (const entry of measure.entries) {
-        if (entry.type !== "note") continue;
-        if (filter.pitchRange && entry.pitch) {
-          const noteValue = pitchToSemitone(entry.pitch);
-          if (filter.pitchRange.min) {
-            const minValue = pitchToSemitone(filter.pitchRange.min);
-            if (noteValue < minValue) continue;
-          }
-          if (filter.pitchRange.max) {
-            const maxValue = pitchToSemitone(filter.pitchRange.max);
-            if (noteValue > maxValue) continue;
-          }
-        }
-        if (filter.voice !== void 0 && entry.voice !== filter.voice) continue;
-        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;
+function buildVoiceToStaffMapForPart(part) {
+  const map = /* @__PURE__ */ new Map();
+  for (const measure of part.measures) {
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && entry.staff !== void 0) {
+        const voice = entry.voice;
+        const staff = entry.staff;
+        if (!map.has(voice)) {
+          map.set(voice, staff);
         }
-        results.push(entry);
       }
     }
   }
-  return results;
+  return {
+    get: (voice) => map.get(voice),
+    has: (voice) => map.has(voice),
+    entries: () => map.entries(),
+    size: map.size
+  };
 }
-function getDuration(score) {
-  if (score.parts.length === 0) return 0;
-  const part = score.parts[0];
-  let totalDuration = 0;
-  let divisions = 1;
-  for (const measure of part.measures) {
-    if (measure.attributes?.divisions !== void 0) {
-      divisions = measure.attributes.divisions;
-    }
-    let measureDuration = 0;
+function inferStaff(entry, voiceToStaffMap) {
+  if (entry.staff !== void 0) {
+    return entry.staff;
+  }
+  const inferredStaff = voiceToStaffMap.get(entry.voice);
+  if (inferredStaff !== void 0) {
+    return inferredStaff;
+  }
+  return 1;
+}
+function getEffectiveStaff(entry, measure) {
+  if (entry.staff !== void 0) {
+    return entry.staff;
+  }
+  const map = buildVoiceToStaffMap(measure);
+  return inferStaff(entry, map);
+}
+function getClefForStaff(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) return void 0;
+  for (let i = options.measureIndex; i >= 0; i--) {
+    const measure = part.measures[i];
     for (const entry of measure.entries) {
-      if (entry.type === "note" && !entry.chord) {
-        measureDuration = Math.max(measureDuration, entry.duration);
+      if (entry.type === "attributes" && entry.attributes.clef) {
+        for (const clef of entry.attributes.clef) {
+          if ((clef.staff ?? 1) === options.staff) {
+            return clef;
+          }
+        }
       }
     }
-    const attrs = getAttributesAtMeasure(score, { part: 0, measure: measure.number });
-    if (attrs.time) {
-      const beats = parseInt(attrs.time.beats, 10) || 4;
-      const expectedDuration = beats / attrs.time.beatType * 4 * divisions;
-      measureDuration = Math.max(measureDuration, expectedDuration);
+    if (measure.attributes?.clef) {
+      for (const clef of measure.attributes.clef) {
+        if ((clef.staff ?? 1) === options.staff) {
+          return clef;
+        }
+      }
     }
-    totalDuration += measureDuration;
   }
-  return totalDuration;
-}
-function getPartById(score, id) {
-  return score.parts.find((p) => p.id === id);
-}
-function getPartIndex(score, id) {
-  return score.parts.findIndex((p) => p.id === id);
+  return void 0;
 }
-function hasMultipleStaves(score, partIndex = 0) {
-  const part = score.parts[partIndex];
-  if (!part) return false;
-  for (const measure of part.measures) {
-    if (measure.attributes?.staves !== void 0 && measure.attributes.staves > 1) {
-      return true;
+function getVoicesForStaff(measure, staff) {
+  const voices = /* @__PURE__ */ new Set();
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      const entryStaff = entry.staff ?? 1;
+      if (entryStaff === staff) {
+        voices.add(entry.voice);
+      }
     }
   }
-  return false;
+  return Array.from(voices).sort((a, b) => a - b);
 }
-function getStaveCount(score, partIndex = 0) {
+function getStaffRange(score, partIndex) {
   const part = score.parts[partIndex];
-  if (!part) return 1;
+  if (!part) return { min: 1, max: 1 };
+  let min = 1;
+  let max = 1;
   for (const measure of part.measures) {
     if (measure.attributes?.staves !== void 0) {
-      return measure.attributes.staves;
+      max = Math.max(max, measure.attributes.staves);
+    }
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && entry.staff !== void 0) {
+        max = Math.max(max, entry.staff);
+      }
     }
   }
-  return 1;
-}
-function measureRoundtrip(original, exported) {
-  const notesOriginal = countNotes(original);
-  const notesExported = countNotes(exported);
-  const notesPreserved = Math.min(notesOriginal, notesExported);
-  const measuresOriginal = getMeasureCount(original);
-  const measuresExported = getMeasureCount(exported);
-  const measuresPreserved = Math.min(measuresOriginal, measuresExported);
-  const partsOriginal = original.parts.length;
-  const partsExported = exported.parts.length;
-  const partsPreserved = Math.min(partsOriginal, partsExported);
-  const preservationRate = notesOriginal > 0 ? notesPreserved / notesOriginal : 1;
-  return {
-    notesOriginal,
-    notesPreserved,
-    measuresOriginal,
-    measuresPreserved,
-    partsOriginal,
-    partsPreserved,
-    preservationRate
-  };
+  return { min, max };
 }
-function countNotes(score) {
-  let count = 0;
-  for (const part of score.parts) {
-    for (const measure of part.measures) {
-      for (const entry of measure.entries) {
-        if (entry.type === "note") {
-          count++;
+function getEntriesAtPosition(measure, position, options) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    const currentPosition = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+    if (currentPosition === position) {
+      if (entry.type === "note") {
+        if (options?.staff !== void 0 && (entry.staff ?? 1) !== options.staff) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.voice !== void 0 && entry.voice !== options.voice) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.includeChordNotes === false && entry.chord) {
+          updatePositionForEntry(state, entry);
+          continue;
         }
       }
+      result.push(entry);
     }
+    updatePositionForEntry(state, entry);
   }
-  return count;
+  return result;
+}
+function getNotesAtPosition(measure, position, options) {
+  return getEntriesAtPosition(measure, position, options).filter(
+    (entry) => entry.type === "note"
+  );
+}
+function getEntriesInRange(measure, range, options) {
+  const result = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    const currentPosition = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+    if (currentPosition >= range.start && currentPosition < range.end) {
+      if (entry.type === "note") {
+        if (options?.staff !== void 0 && (entry.staff ?? 1) !== options.staff) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.voice !== void 0 && entry.voice !== options.voice) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (options?.includeChordNotes === false && entry.chord) {
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+      }
+      result.push(entry);
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return result;
+}
+function getNotesInRange(measure, range, options) {
+  return getEntriesInRange(measure, range, options).filter(
+    (entry) => entry.type === "note"
+  );
+}
+function getVerticalSlice(score, options) {
+  const parts = /* @__PURE__ */ new Map();
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    const measure = part.measures[options.measureIndex];
+    if (!measure) continue;
+    const notes = getNotesAtPosition(measure, options.position);
+    if (notes.length > 0) {
+      parts.set(partIndex, notes);
+    }
+  }
+  return {
+    measureIndex: options.measureIndex,
+    position: options.position,
+    parts
+  };
+}
+function getVoiceLine(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) {
+    return { partIndex: options.partIndex, voice: options.voice, staff: options.staff, notes: [] };
+  }
+  const notes = [];
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryStaff = entry.staff ?? 1;
+        const matchesVoice = entry.voice === options.voice;
+        const matchesStaff = options.staff === void 0 || entryStaff === options.staff;
+        if (matchesVoice && matchesStaff) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          notes.push({
+            note: entry,
+            part,
+            partIndex: options.partIndex,
+            measure,
+            measureIndex,
+            position
+          });
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return {
+    partIndex: options.partIndex,
+    voice: options.voice,
+    staff: options.staff,
+    notes
+  };
+}
+function getVoiceLineInRange(score, options) {
+  const part = score.parts[options.partIndex];
+  if (!part) {
+    return { partIndex: options.partIndex, voice: options.voice, staff: options.staff, notes: [] };
+  }
+  const notes = [];
+  for (let measureIndex = options.startMeasure; measureIndex <= options.endMeasure && measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryStaff = entry.staff ?? 1;
+        const matchesVoice = entry.voice === options.voice;
+        const matchesStaff = options.staff === void 0 || entryStaff === options.staff;
+        if (matchesVoice && matchesStaff) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          notes.push({
+            note: entry,
+            part,
+            partIndex: options.partIndex,
+            measure,
+            measureIndex,
+            position
+          });
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return {
+    partIndex: options.partIndex,
+    voice: options.voice,
+    staff: options.staff,
+    notes
+  };
+}
+function* iterateEntries(score) {
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        const position = entry.type === "note" && entry.chord ? state.lastNonChordPosition : state.position;
+        yield {
+          entry,
+          part,
+          partIndex,
+          measure,
+          measureIndex,
+          position
+        };
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+}
+function getNextNote(score, context) {
+  const part = score.parts[context.partIndex];
+  if (!part) return null;
+  let foundCurrent = false;
+  for (let measureIndex = context.measureIndex; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryPosition = entry.chord ? state.lastNonChordPosition : state.position;
+        if (measureIndex === context.measureIndex && entry === context.note) {
+          foundCurrent = true;
+          updatePositionForEntry(state, entry);
+          continue;
+        }
+        if (foundCurrent && entry.voice === context.note.voice && !entry.chord) {
+          if (context.note.staff !== void 0) {
+            if ((entry.staff ?? 1) !== context.note.staff) {
+              updatePositionForEntry(state, entry);
+              continue;
+            }
+          }
+          return {
+            note: entry,
+            part,
+            partIndex: context.partIndex,
+            measure,
+            measureIndex,
+            position: entryPosition
+          };
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return null;
+}
+function getPrevNote(score, context) {
+  const part = score.parts[context.partIndex];
+  if (!part) return null;
+  let lastCandidate = null;
+  for (let measureIndex = 0; measureIndex <= context.measureIndex; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const state = createPositionState();
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        const entryPosition = entry.chord ? state.lastNonChordPosition : state.position;
+        if (measureIndex === context.measureIndex && entry === context.note) {
+          return lastCandidate;
+        }
+        if (entry.voice === context.note.voice && !entry.chord) {
+          if (context.note.staff !== void 0) {
+            if ((entry.staff ?? 1) !== context.note.staff) {
+              updatePositionForEntry(state, entry);
+              continue;
+            }
+          }
+          lastCandidate = {
+            note: entry,
+            part,
+            partIndex: context.partIndex,
+            measure,
+            measureIndex,
+            position: entryPosition
+          };
+        }
+      }
+      updatePositionForEntry(state, entry);
+    }
+  }
+  return null;
+}
+function getAdjacentNotes(score, context) {
+  return {
+    prev: getPrevNote(score, context),
+    next: getNextNote(score, context)
+  };
+}
+function getDirections(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const startMeasure = options?.measureIndex ?? 0;
+    const endMeasure = options?.measureIndex !== void 0 ? options.measureIndex + 1 : part.measures.length;
+    for (let measureIndex = startMeasure; measureIndex < endMeasure; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      if (!measure) continue;
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          results.push({
+            direction: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position: state.position
+          });
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getDirectionsAtPosition(measure, position) {
+  const results = [];
+  const state = createPositionState();
+  for (const entry of measure.entries) {
+    if (entry.type === "direction" && state.position === position) {
+      results.push(entry);
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return results;
+}
+function findDirectionsByType(score, kind) {
+  const allDirections = getDirections(score);
+  return allDirections.filter(
+    (d) => d.direction.directionTypes.some((dt) => dt.kind === kind)
+  );
+}
+function getDynamics(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "dynamics") {
+              results.push({
+                dynamic: dirType.value,
+                direction: entry,
+                part,
+                partIndex,
+                measure,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTempoMarkings(score) {
+  const results = [];
+  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
+    const part = score.parts[partIndex];
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "metronome") {
+              results.push({
+                beatUnit: dirType.beatUnit,
+                perMinute: dirType.perMinute,
+                beatUnitDot: dirType.beatUnitDot,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getPedalMarkings(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "pedal") {
+              results.push({
+                pedalType: dirType.type,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getWedges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "wedge") {
+              results.push({
+                wedgeType: dirType.type,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getOctaveShifts(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "direction") {
+          for (const dirType of entry.directionTypes) {
+            if (dirType.kind === "octave-shift") {
+              results.push({
+                shiftType: dirType.type,
+                size: dirType.size,
+                direction: entry,
+                partIndex,
+                measureIndex,
+                position: state.position
+              });
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTiedNoteGroups(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingTies = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.pitch) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const pitchKey = `${entry.pitch.step}${entry.pitch.octave}-${entry.voice}`;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            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 group = pendingTies.get(pitchKey);
+            group.push(context);
+            if (!hasTieStart) {
+              const totalDuration = group.reduce((sum, nc) => sum + nc.note.duration, 0);
+              results.push({ notes: group, totalDuration });
+              pendingTies.delete(pitchKey);
+            }
+          } else if (hasTieStart) {
+            pendingTies.set(pitchKey, [context]);
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getSlurSpans(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingSlurs = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position
+          };
+          if (entry.notations) {
+            for (const notation of entry.notations) {
+              if (notation.type === "slur") {
+                const slurNumber = notation.number ?? 1;
+                if (notation.slurType === "start") {
+                  pendingSlurs.set(slurNumber, { startNote: context, notes: [context] });
+                } else if (notation.slurType === "stop" && pendingSlurs.has(slurNumber)) {
+                  const pending = pendingSlurs.get(slurNumber);
+                  pending.notes.push(context);
+                  results.push({
+                    number: slurNumber,
+                    startNote: pending.startNote,
+                    endNote: context,
+                    notes: pending.notes
+                  });
+                  pendingSlurs.delete(slurNumber);
+                } else if (notation.slurType === "continue" && pendingSlurs.has(slurNumber)) {
+                  pendingSlurs.get(slurNumber).notes.push(context);
+                }
+              }
+            }
+          }
+          for (const [, pending] of pendingSlurs) {
+            const lastNote = pending.notes[pending.notes.length - 1];
+            if (lastNote !== context) {
+              pending.notes.push(context);
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTupletGroups(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const pendingTuplets = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          const context = {
+            note: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position
+          };
+          if (entry.notations) {
+            for (const notation of entry.notations) {
+              if (notation.type === "tuplet") {
+                const tupletNumber = notation.number ?? 1;
+                if (notation.tupletType === "start") {
+                  const actualNotes = entry.timeModification?.actualNotes ?? 3;
+                  const normalNotes = entry.timeModification?.normalNotes ?? 2;
+                  pendingTuplets.set(tupletNumber, {
+                    notes: [context],
+                    actualNotes,
+                    normalNotes
+                  });
+                } else if (notation.tupletType === "stop" && pendingTuplets.has(tupletNumber)) {
+                  const pending = pendingTuplets.get(tupletNumber);
+                  pending.notes.push(context);
+                  results.push({
+                    number: tupletNumber,
+                    notes: pending.notes,
+                    actualNotes: pending.actualNotes,
+                    normalNotes: pending.normalNotes
+                  });
+                  pendingTuplets.delete(tupletNumber);
+                }
+              }
+            }
+          }
+          if (entry.timeModification && !entry.notations?.some((n) => n.type === "tuplet")) {
+            for (const [, pending] of pendingTuplets) {
+              if (entry.timeModification.actualNotes === pending.actualNotes && entry.timeModification.normalNotes === pending.normalNotes) {
+                pending.notes.push(context);
+              }
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getBeamGroups(measure) {
+  const results = [];
+  const state = createPositionState();
+  const pendingBeams = /* @__PURE__ */ new Map();
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && entry.beam) {
+      const position = entry.chord ? state.lastNonChordPosition : state.position;
+      const context = {
+        note: entry,
+        part: {},
+        // Will be set by caller if needed
+        partIndex: 0,
+        measure,
+        measureIndex: 0,
+        position
+      };
+      for (const beam of entry.beam) {
+        const beamNumber = beam.number;
+        if (beam.type === "begin") {
+          pendingBeams.set(beamNumber, [context]);
+        } else if (beam.type === "continue" && pendingBeams.has(beamNumber)) {
+          pendingBeams.get(beamNumber).push(context);
+        } else if (beam.type === "end" && pendingBeams.has(beamNumber)) {
+          const group = pendingBeams.get(beamNumber);
+          group.push(context);
+          results.push({
+            notes: group,
+            beamLevel: beamNumber
+          });
+          pendingBeams.delete(beamNumber);
+        }
+      }
+    }
+    updatePositionForEntry(state, entry);
+  }
+  return results;
+}
+function findNotesWithNotation(score, notationType, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          if (entry.notations?.some((n) => n.type === notationType)) {
+            results.push({
+              note: entry,
+              part,
+              partIndex,
+              measure,
+              measureIndex,
+              position
+            });
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getHarmonies(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "harmony") {
+          results.push({
+            harmony: entry,
+            part,
+            partIndex,
+            measure,
+            measureIndex,
+            position: state.position
+          });
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getHarmonyAtPosition(measure, position) {
+  const state = createPositionState();
+  let lastHarmony;
+  for (const entry of measure.entries) {
+    if (entry.type === "harmony") {
+      if (state.position <= position) {
+        lastHarmony = entry;
+      }
+    }
+    updatePositionForEntry(state, entry);
+    if (state.position > position && lastHarmony) {
+      break;
+    }
+  }
+  return lastHarmony;
+}
+function getChordProgression(score, options) {
+  const harmonies = getHarmonies(score, options);
+  return harmonies.map((h) => {
+    const rootAlter = h.harmony.root.rootAlter ?? 0;
+    const rootAccidental = rootAlter > 0 ? "#".repeat(rootAlter) : "b".repeat(-rootAlter);
+    const root = h.harmony.root.rootStep + rootAccidental;
+    let bass;
+    if (h.harmony.bass) {
+      const bassAlter = h.harmony.bass.bassAlter ?? 0;
+      const bassAccidental = bassAlter > 0 ? "#".repeat(bassAlter) : "b".repeat(-bassAlter);
+      bass = h.harmony.bass.bassStep + bassAccidental;
+    }
+    return {
+      root,
+      kind: h.harmony.kind,
+      bass,
+      measureIndex: h.measureIndex,
+      position: h.position
+    };
+  });
+}
+function getLyrics(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const state = createPositionState();
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.lyrics) {
+          const position = entry.chord ? state.lastNonChordPosition : state.position;
+          for (const lyric of entry.lyrics) {
+            const verse = lyric.number ?? 1;
+            if (options?.verse !== void 0 && verse !== options.verse) {
+              continue;
+            }
+            results.push({
+              lyric,
+              note: entry,
+              part,
+              partIndex,
+              measure,
+              measureIndex,
+              position,
+              verse
+            });
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getLyricText(score, options) {
+  const lyrics = getLyrics(score, options);
+  const verseMap = /* @__PURE__ */ new Map();
+  for (const lyric of lyrics) {
+    if (!verseMap.has(lyric.verse)) {
+      verseMap.set(lyric.verse, []);
+    }
+    verseMap.get(lyric.verse).push(lyric);
+  }
+  const results = [];
+  for (const [verse, verseLyrics] of verseMap) {
+    const syllables = [];
+    const textParts = [];
+    for (const lyric of verseLyrics) {
+      const text = lyric.lyric.text;
+      syllables.push({
+        text,
+        position: lyric.position,
+        measureIndex: lyric.measureIndex
+      });
+      const syllabic = lyric.lyric.syllabic;
+      if (syllabic === "begin" || syllabic === "middle") {
+        textParts.push(text + "-");
+      } else if (syllabic === "end") {
+        textParts.push(text + " ");
+      } else {
+        textParts.push(text + " ");
+      }
+    }
+    results.push({
+      verse,
+      text: textParts.join("").trim(),
+      syllables
+    });
+  }
+  return results.sort((a, b) => a.verse - b.verse);
+}
+function getVerseCount(score, options) {
+  const verses = /* @__PURE__ */ new Set();
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type === "note" && entry.lyrics) {
+          for (const lyric of entry.lyrics) {
+            verses.add(lyric.number ?? 1);
+          }
+        }
+      }
+    }
+  }
+  return verses.size;
+}
+function getRepeatStructure(score, options) {
+  const results = [];
+  const partIndex = options?.partIndex ?? 0;
+  const part = score.parts[partIndex];
+  if (!part) return results;
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const measureNumber = measure.number ?? String(measureIndex + 1);
+    if (measure.barlines) {
+      for (const barline of measure.barlines) {
+        if (barline.repeat) {
+          results.push({
+            type: barline.repeat.direction,
+            times: barline.repeat.times,
+            measureIndex,
+            measureNumber
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function findBarlines(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.barlines) {
+        for (const barline of measure.barlines) {
+          if (options?.style !== void 0 && barline.barStyle !== options.style) {
+            continue;
+          }
+          if (options?.repeat !== void 0) {
+            const hasRepeat = barline.repeat !== void 0;
+            if (hasRepeat !== options.repeat) {
+              continue;
+            }
+          }
+          results.push({
+            barline,
+            partIndex,
+            measureIndex,
+            measureNumber
+          });
+        }
+      }
+    }
+  }
+  return results;
+}
+function getEndings(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.barlines) {
+        for (const barline of measure.barlines) {
+          if (barline.ending) {
+            results.push({
+              number: barline.ending.number,
+              type: barline.ending.type,
+              partIndex,
+              measureIndex,
+              measureNumber
+            });
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function getKeyChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    let lastKey;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      const state = createPositionState();
+      if (measure.attributes?.key) {
+        const key = measure.attributes.key;
+        if (!lastKey || lastKey.fifths !== key.fifths || lastKey.mode !== key.mode) {
+          results.push({
+            key,
+            partIndex,
+            measureIndex,
+            measureNumber,
+            position: 0
+          });
+          lastKey = key;
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.key) {
+          const key = entry.attributes.key;
+          if (!lastKey || lastKey.fifths !== key.fifths || lastKey.mode !== key.mode) {
+            results.push({
+              key,
+              partIndex,
+              measureIndex,
+              measureNumber,
+              position: state.position
+            });
+            lastKey = key;
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getTimeChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    let lastTime;
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      if (measure.attributes?.time) {
+        const time = measure.attributes.time;
+        if (!lastTime || lastTime.beats !== time.beats || lastTime.beatType !== time.beatType) {
+          results.push({
+            time,
+            partIndex,
+            measureIndex,
+            measureNumber
+          });
+          lastTime = time;
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.time) {
+          const time = entry.attributes.time;
+          if (!lastTime || lastTime.beats !== time.beats || lastTime.beatType !== time.beatType) {
+            results.push({
+              time,
+              partIndex,
+              measureIndex,
+              measureNumber
+            });
+            lastTime = time;
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function getClefChanges(score, options) {
+  const results = [];
+  const startPart = options?.partIndex ?? 0;
+  const endPart = options?.partIndex !== void 0 ? options.partIndex + 1 : score.parts.length;
+  for (let partIndex = startPart; partIndex < endPart; partIndex++) {
+    const part = score.parts[partIndex];
+    if (!part) continue;
+    const lastClefs = /* @__PURE__ */ new Map();
+    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+      const measure = part.measures[measureIndex];
+      const measureNumber = measure.number ?? String(measureIndex + 1);
+      const state = createPositionState();
+      if (measure.attributes?.clef) {
+        for (const clef of measure.attributes.clef) {
+          const staff = clef.staff ?? 1;
+          if (options?.staff !== void 0 && staff !== options.staff) {
+            continue;
+          }
+          const lastClef = lastClefs.get(staff);
+          if (!lastClef || lastClef.sign !== clef.sign || lastClef.line !== clef.line || lastClef.clefOctaveChange !== clef.clefOctaveChange) {
+            results.push({
+              clef,
+              staff,
+              partIndex,
+              measureIndex,
+              measureNumber,
+              position: 0
+            });
+            lastClefs.set(staff, clef);
+          }
+        }
+      }
+      for (const entry of measure.entries) {
+        if (entry.type === "attributes" && entry.attributes.clef) {
+          for (const clef of entry.attributes.clef) {
+            const staff = clef.staff ?? 1;
+            if (options?.staff !== void 0 && staff !== options.staff) {
+              continue;
+            }
+            const lastClef = lastClefs.get(staff);
+            if (!lastClef || lastClef.sign !== clef.sign || lastClef.line !== clef.line || lastClef.clefOctaveChange !== clef.clefOctaveChange) {
+              results.push({
+                clef,
+                staff,
+                partIndex,
+                measureIndex,
+                measureNumber,
+                position: state.position
+              });
+              lastClefs.set(staff, clef);
+            }
+          }
+        }
+        updatePositionForEntry(state, entry);
+      }
+    }
+  }
+  return results;
+}
+function getStructuralChanges(score, options) {
+  return {
+    keyChanges: getKeyChanges(score, options),
+    timeChanges: getTimeChanges(score, options),
+    clefChanges: getClefChanges(score, options)
+  };
+}
+function getPartByIndex(score, index) {
+  return score.parts[index];
+}
+function getPartCount(score) {
+  return score.parts.length;
+}
+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;
+  const targetMeasure = String(options.measure);
+  return part.measures.find((m) => m.number === targetMeasure);
+}
+function getMeasureByIndex(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return void 0;
+  return part.measures[options.measureIndex];
+}
+function getMeasureCount(score) {
+  if (score.parts.length === 0) return 0;
+  return score.parts[0].measures.length;
+}
+function getDivisions(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return 1;
+  const targetMeasure = parseInt(String(options.measure), 10);
+  if (isNaN(targetMeasure)) return 1;
+  for (let i = 0; i < part.measures.length; i++) {
+    const m = part.measures[i];
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes?.divisions !== void 0) {
+    }
+  }
+  let divisions = 1;
+  for (const m of part.measures) {
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes?.divisions !== void 0) {
+      divisions = m.attributes.divisions;
+    }
+  }
+  return divisions;
+}
+function getAttributesAtMeasure(score, options) {
+  const part = score.parts[options.part];
+  if (!part) return {};
+  const targetMeasure = parseInt(String(options.measure), 10);
+  const result = {};
+  for (const m of part.measures) {
+    const mNum = parseInt(m.number, 10);
+    if (!isNaN(targetMeasure) && !isNaN(mNum) && mNum > targetMeasure) break;
+    if (m.attributes) {
+      if (m.attributes.divisions !== void 0) result.divisions = m.attributes.divisions;
+      if (m.attributes.time !== void 0) result.time = m.attributes.time;
+      if (m.attributes.key !== void 0) result.key = m.attributes.key;
+      if (m.attributes.clef !== void 0) result.clef = m.attributes.clef;
+      if (m.attributes.staves !== void 0) result.staves = m.attributes.staves;
+      if (m.attributes.transpose !== void 0) result.transpose = m.attributes.transpose;
+    }
+  }
+  return result;
+}
+function findNotes(score, filter) {
+  const results = [];
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type !== "note") continue;
+        if (filter.pitchRange && entry.pitch) {
+          const noteValue = pitchToSemitone(entry.pitch);
+          if (filter.pitchRange.min) {
+            const minValue = pitchToSemitone(filter.pitchRange.min);
+            if (noteValue < minValue) continue;
+          }
+          if (filter.pitchRange.max) {
+            const maxValue = pitchToSemitone(filter.pitchRange.max);
+            if (noteValue > maxValue) continue;
+          }
+        }
+        if (filter.voice !== void 0 && entry.voice !== filter.voice) continue;
+        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;
+        }
+        results.push(entry);
+      }
+    }
+  }
+  return results;
+}
+function getDuration(score) {
+  if (score.parts.length === 0) return 0;
+  const part = score.parts[0];
+  let totalDuration = 0;
+  let divisions = 1;
+  for (const measure of part.measures) {
+    if (measure.attributes?.divisions !== void 0) {
+      divisions = measure.attributes.divisions;
+    }
+    let measureDuration = 0;
+    for (const entry of measure.entries) {
+      if (entry.type === "note" && !entry.chord) {
+        measureDuration = Math.max(measureDuration, entry.duration);
+      }
+    }
+    const attrs = getAttributesAtMeasure(score, { part: 0, measure: measure.number });
+    if (attrs.time) {
+      const beats = parseInt(attrs.time.beats, 10) || 4;
+      const expectedDuration = beats / attrs.time.beatType * 4 * divisions;
+      measureDuration = Math.max(measureDuration, expectedDuration);
+    }
+    totalDuration += measureDuration;
+  }
+  return totalDuration;
+}
+function getPartById(score, id) {
+  return score.parts.find((p) => p.id === id);
+}
+function getPartIndex(score, id) {
+  return score.parts.findIndex((p) => p.id === id);
+}
+function hasMultipleStaves(score, partIndex = 0) {
+  const part = score.parts[partIndex];
+  if (!part) return false;
+  for (const measure of part.measures) {
+    if (measure.attributes?.staves !== void 0 && measure.attributes.staves > 1) {
+      return true;
+    }
+  }
+  return false;
+}
+function getStaveCount(score, partIndex = 0) {
+  const part = score.parts[partIndex];
+  if (!part) return 1;
+  for (const measure of part.measures) {
+    if (measure.attributes?.staves !== void 0) {
+      return measure.attributes.staves;
+    }
+  }
+  return 1;
+}
+function measureRoundtrip(original, exported) {
+  const notesOriginal = countNotes(original);
+  const notesExported = countNotes(exported);
+  const notesPreserved = Math.min(notesOriginal, notesExported);
+  const measuresOriginal = getMeasureCount(original);
+  const measuresExported = getMeasureCount(exported);
+  const measuresPreserved = Math.min(measuresOriginal, measuresExported);
+  const partsOriginal = original.parts.length;
+  const partsExported = exported.parts.length;
+  const partsPreserved = Math.min(partsOriginal, partsExported);
+  const preservationRate = notesOriginal > 0 ? notesPreserved / notesOriginal : 1;
+  return {
+    notesOriginal,
+    notesPreserved,
+    measuresOriginal,
+    measuresPreserved,
+    partsOriginal,
+    partsPreserved,
+    preservationRate
+  };
+}
+function countNotes(score) {
+  let count = 0;
+  for (const part of score.parts) {
+    for (const measure of part.measures) {
+      for (const entry of measure.entries) {
+        if (entry.type === "note") {
+          count++;
+        }
+      }
+    }
+  }
+  return count;
 }
 function scoresEqual(a, b) {
   if (a.parts.length !== b.parts.length) return false;
@@ -5559,9 +6913,461 @@ function pitchesEqual(a, b) {
 }
 
 // src/operations/index.ts
+function success(data, warnings) {
+  return { success: true, data, warnings };
+}
+function failure(errors) {
+  return { success: false, errors };
+}
+function operationError(code, message, location = {}, details) {
+  return {
+    code,
+    level: "error",
+    message,
+    location,
+    details
+  };
+}
 function cloneScore(score) {
   return JSON.parse(JSON.stringify(score));
 }
+function getMeasureDuration(divisions, time) {
+  const beats = parseInt(time.beats, 10);
+  if (isNaN(beats)) return divisions * 4;
+  return beats / time.beatType * 4 * divisions;
+}
+function getVoiceEntries(measure, voice, staff) {
+  const result = [];
+  let position = 0;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note") {
+      const noteStaff = entry.staff ?? 1;
+      if (entry.voice === voice && (staff === void 0 || noteStaff === staff)) {
+        if (!entry.chord) {
+          result.push({
+            entry,
+            entryIndex: i,
+            position,
+            endPosition: position + entry.duration
+          });
+          position += entry.duration;
+        } else {
+          if (result.length > 0) {
+            const prev = result[result.length - 1];
+            result.push({
+              entry,
+              entryIndex: i,
+              position: prev.position,
+              endPosition: prev.endPosition
+            });
+          }
+        }
+      } else if (!entry.chord) {
+        position += entry.duration;
+      }
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      if (entry.voice === voice) {
+        result.push({
+          entry,
+          entryIndex: i,
+          position,
+          endPosition: position + entry.duration
+        });
+      }
+      position += entry.duration;
+    }
+  }
+  return result;
+}
+function hasNotesInRange(voiceEntries, startPos, endPos) {
+  const conflicting = voiceEntries.filter((e) => {
+    if (e.entry.type !== "note") return false;
+    const note = e.entry;
+    if (note.rest) return false;
+    return e.position < endPos && e.endPosition > startPos;
+  });
+  return { hasNotes: conflicting.length > 0, conflictingNotes: conflicting };
+}
+function createRest(duration, voice, staff) {
+  return {
+    type: "note",
+    rest: { displayStep: void 0, displayOctave: void 0 },
+    duration,
+    voice,
+    staff
+  };
+}
+function rebuildMeasureWithVoice(measure, voice, newEntries, measureDuration, staff) {
+  const otherEntries = [];
+  let position = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      if (entry.voice !== voice || staff !== void 0 && (entry.staff ?? 1) !== staff) {
+        if (!entry.chord) {
+          otherEntries.push({ position, entry });
+          position += entry.duration;
+        } else {
+          otherEntries.push({ position, entry });
+        }
+      } else if (!entry.chord) {
+        position += entry.duration;
+      }
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      if (entry.voice !== voice) {
+        otherEntries.push({ position, entry });
+      }
+      position += entry.duration;
+    } else {
+      otherEntries.push({ position, entry });
+    }
+  }
+  const filledNewEntries = [];
+  let currentPos = 0;
+  const sortedNew = [...newEntries].sort((a, b) => a.position - b.position);
+  for (const { position: notePos, entry } of sortedNew) {
+    if (notePos > currentPos) {
+      filledNewEntries.push({
+        position: currentPos,
+        entry: createRest(notePos - currentPos, voice, staff)
+      });
+    }
+    filledNewEntries.push({ position: notePos, entry });
+    if (!entry.chord) {
+      currentPos = notePos + entry.duration;
+    }
+  }
+  if (currentPos < measureDuration) {
+    filledNewEntries.push({
+      position: currentPos,
+      entry: createRest(measureDuration - currentPos, voice, staff)
+    });
+  }
+  const allEntries = [...otherEntries, ...filledNewEntries];
+  allEntries.sort((a, b) => a.position - b.position);
+  const result = [];
+  let currentPosition = 0;
+  for (const { position: targetPos, entry } of allEntries) {
+    const diff = targetPos - currentPosition;
+    if (diff < 0) {
+      result.push({ type: "backup", duration: -diff });
+      currentPosition = targetPos;
+    } else if (diff > 0) {
+      result.push({
+        type: "forward",
+        duration: diff,
+        voice: entry.type === "note" ? entry.voice : 1,
+        staff: entry.type === "note" ? entry.staff : void 0
+      });
+      currentPosition = targetPos;
+    }
+    result.push(entry);
+    if (entry.type === "note" && !entry.chord) {
+      currentPosition += entry.duration;
+    } else if (entry.type === "forward") {
+      currentPosition += entry.duration;
+    }
+  }
+  return result;
+}
+function insertNote(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.duration <= 0) {
+    return failure([operationError("INVALID_DURATION", `Duration must be positive`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.position < 0) {
+    return failure([operationError("INVALID_POSITION", `Position cannot be negative`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
+  const noteEnd = options.position + options.duration;
+  if (noteEnd > measureDuration) {
+    return failure([operationError(
+      "EXCEEDS_MEASURE",
+      `Note ending at ${noteEnd} exceeds measure duration ${measureDuration}`,
+      { partIndex: options.partIndex, measureIndex: options.measureIndex },
+      { noteEnd, measureDuration }
+    )]);
+  }
+  const voiceEntries = getVoiceEntries(measure, options.voice, options.staff);
+  const { hasNotes: hasNotes2, conflictingNotes } = hasNotesInRange(voiceEntries, options.position, noteEnd);
+  if (hasNotes2) {
+    return failure([operationError(
+      "NOTE_CONFLICT",
+      `Position ${options.position}-${noteEnd} conflicts with existing note(s)`,
+      { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: options.voice },
+      { conflictingPositions: conflictingNotes.map((n) => ({ start: n.position, end: n.endPosition })) }
+    )]);
+  }
+  const newNote = {
+    type: "note",
+    pitch: options.pitch,
+    duration: options.duration,
+    voice: options.voice,
+    staff: options.staff,
+    noteType: options.noteType,
+    dots: options.dots
+  };
+  const existingNotes = voiceEntries.filter((e) => {
+    if (e.entry.type !== "note") return true;
+    const note = e.entry;
+    if (note.rest) {
+      return !(e.position < noteEnd && e.endPosition > options.position);
+    }
+    return true;
+  }).map((e) => ({ position: e.position, entry: e.entry }));
+  existingNotes.push({ position: options.position, entry: newNote });
+  measure.entries = rebuildMeasureWithVoice(
+    measure,
+    options.voice,
+    existingNotes,
+    measureDuration,
+    options.staff
+  );
+  const errors = validateMeasureLocal(measure, context, {
+    checkMeasureDuration: true,
+    checkPosition: true,
+    checkVoiceStaff: true
+  });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, errors.filter((e) => e.level !== "error"));
+}
+function removeNote(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  let targetEntry = null;
+  let targetIndex = -1;
+  for (let i2 = 0; i2 < measure.entries.length; i2++) {
+    const entry = measure.entries[i2];
+    if (entry.type === "note" && !entry.rest) {
+      if (noteCount === options.noteIndex) {
+        targetEntry = entry;
+        targetIndex = i2;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (!targetEntry || targetIndex === -1) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  measure.entries[targetIndex] = createRest(
+    targetEntry.duration,
+    targetEntry.voice,
+    targetEntry.staff
+  );
+  let i = targetIndex + 1;
+  while (i < measure.entries.length) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && entry.chord) {
+      measure.entries.splice(i, 1);
+    } else {
+      break;
+    }
+  }
+  return success(result);
+}
+function addChord(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  let targetEntry = null;
+  let targetIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.rest && !entry.chord) {
+      if (noteCount === options.noteIndex) {
+        targetEntry = entry;
+        targetIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (!targetEntry || targetIndex === -1) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const chordNote = {
+    type: "note",
+    pitch: options.pitch,
+    duration: targetEntry.duration,
+    voice: targetEntry.voice,
+    staff: targetEntry.staff,
+    chord: true,
+    noteType: targetEntry.noteType,
+    dots: targetEntry.dots
+  };
+  let insertIndex = targetIndex + 1;
+  while (insertIndex < measure.entries.length) {
+    const entry = measure.entries[insertIndex];
+    if (entry.type === "note" && entry.chord) {
+      insertIndex++;
+    } else {
+      break;
+    }
+  }
+  measure.entries.splice(insertIndex, 0, chordNote);
+  return success(result);
+}
+function changeNoteDuration(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.newDuration <= 0) {
+    return failure([operationError("INVALID_DURATION", `Duration must be positive`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
+  let noteCount = 0;
+  let targetEntry = null;
+  let targetPosition = 0;
+  let position = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      if (!entry.rest && !entry.chord) {
+        if (noteCount === options.noteIndex) {
+          targetEntry = entry;
+          targetPosition = position;
+          break;
+        }
+        noteCount++;
+      }
+      if (!entry.chord) {
+        position += entry.duration;
+      }
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      position += entry.duration;
+    }
+  }
+  if (!targetEntry) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const oldDuration = targetEntry.duration;
+  const newEnd = targetPosition + options.newDuration;
+  if (newEnd > measureDuration) {
+    return failure([operationError(
+      "EXCEEDS_MEASURE",
+      `New duration would exceed measure (ends at ${newEnd}, measure is ${measureDuration})`,
+      { partIndex: options.partIndex, measureIndex: options.measureIndex },
+      { newEnd, measureDuration }
+    )]);
+  }
+  const voiceEntries = getVoiceEntries(measure, targetEntry.voice, targetEntry.staff);
+  if (options.newDuration > oldDuration) {
+    const { hasNotes: hasNotes2, conflictingNotes } = hasNotesInRange(
+      voiceEntries.filter((e) => e.position !== targetPosition),
+      // Exclude current note
+      targetPosition + oldDuration,
+      newEnd
+    );
+    if (hasNotes2) {
+      return failure([operationError(
+        "NOTE_CONFLICT",
+        `Cannot extend note: conflicts with existing note(s)`,
+        { partIndex: options.partIndex, measureIndex: options.measureIndex },
+        { conflictingPositions: conflictingNotes.map((n) => ({ start: n.position, end: n.endPosition })) }
+      )]);
+    }
+  }
+  targetEntry.duration = options.newDuration;
+  if (options.noteType !== void 0) {
+    targetEntry.noteType = options.noteType;
+  }
+  if (options.dots !== void 0) {
+    targetEntry.dots = options.dots;
+  }
+  const existingNotes = voiceEntries.filter((e) => {
+    if (e.position === targetPosition) return true;
+    const note = e.entry;
+    if (note.rest) {
+      if (options.newDuration > oldDuration) {
+        return !(e.position >= targetPosition + oldDuration && e.position < newEnd);
+      }
+    }
+    return true;
+  }).map((e) => ({ position: e.position, entry: e.entry }));
+  const modifiedIdx = existingNotes.findIndex((e) => e.position === targetPosition);
+  if (modifiedIdx >= 0) {
+    existingNotes[modifiedIdx].entry = targetEntry;
+  }
+  measure.entries = rebuildMeasureWithVoice(
+    measure,
+    targetEntry.voice,
+    existingNotes,
+    measureDuration,
+    targetEntry.staff
+  );
+  const errors = validateMeasureLocal(measure, context, {
+    checkMeasureDuration: true,
+    checkPosition: true,
+    checkVoiceStaff: true
+  });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, errors.filter((e) => e.level !== "error"));
+}
+function setNotePitch(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && !entry.rest) {
+      if (noteCount === options.noteIndex) {
+        entry.pitch = options.pitch;
+        return success(result);
+      }
+      noteCount++;
+    }
+  }
+  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+}
 function transposePitch(pitch, semitones) {
   const currentSemitone = STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0) + pitch.octave * 12;
   const targetSemitone = currentSemitone + semitones;
@@ -5588,7 +7394,7 @@ function transposePitch(pitch, semitones) {
   };
 }
 function transpose(score, semitones) {
-  if (semitones === 0) return score;
+  if (semitones === 0) return success(score);
   const result = cloneScore(score);
   for (const part of result.parts) {
     for (const measure of part.measures) {
@@ -5599,59 +7405,7 @@ function transpose(score, semitones) {
       }
     }
   }
-  return result;
-}
-function addNote(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  const newNote = {
-    type: "note",
-    voice: options.voice,
-    staff: options.staff,
-    ...options.note
-  };
-  const currentPosition = getMeasureEndPosition(measure);
-  const positionDiff = options.position - currentPosition;
-  if (positionDiff < 0) {
-    measure.entries.push({
-      type: "backup",
-      duration: -positionDiff
-    });
-  } else if (positionDiff > 0) {
-    measure.entries.push({
-      type: "forward",
-      duration: positionDiff,
-      voice: options.voice,
-      staff: options.staff
-    });
-  }
-  measure.entries.push(newNote);
-  return result;
-}
-function deleteNote(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  let noteCount = 0;
-  let entryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    if (measure.entries[i].type === "note") {
-      if (noteCount === options.noteIndex) {
-        entryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (entryIndex !== -1) {
-    measure.entries.splice(entryIndex, 1);
-  }
-  return result;
+  return success(result);
 }
 function changeKey(score, key, options) {
   const result = cloneScore(score);
@@ -5659,9 +7413,7 @@ function changeKey(score, key, options) {
   for (const part of result.parts) {
     for (const measure of part.measures) {
       if (measure.number === targetMeasure) {
-        if (!measure.attributes) {
-          measure.attributes = {};
-        }
+        if (!measure.attributes) measure.attributes = {};
         measure.attributes.key = key;
       }
     }
@@ -5674,9 +7426,7 @@ function changeTime(score, time, options) {
   for (const part of result.parts) {
     for (const measure of part.measures) {
       if (measure.number === targetMeasure) {
-        if (!measure.attributes) {
-          measure.attributes = {};
-        }
+        if (!measure.attributes) measure.attributes = {};
         measure.attributes.time = time;
       }
     }
@@ -5691,15 +7441,9 @@ 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: []
-    };
-    if (options.copyAttributes) {
-      const sourceMeasure = part.measures[insertIndex];
-      if (sourceMeasure.attributes) {
-        newMeasure.attributes = { ...sourceMeasure.attributes };
-      }
+    const newMeasure = { number: newMeasureNumber, entries: [] };
+    if (options.copyAttributes && part.measures[insertIndex].attributes) {
+      newMeasure.attributes = { ...part.measures[insertIndex].attributes };
     }
     part.measures.splice(insertIndex + 1, 0, newMeasure);
     for (let i = insertIndex + 2; i < part.measures.length; i++) {
@@ -5727,95 +7471,36 @@ function deleteMeasure(score, measureNumber) {
   }
   return result;
 }
-function setDivisions(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  if (!measure.attributes) {
-    measure.attributes = {};
-  }
-  measure.attributes.divisions = options.divisions;
-  return result;
-}
-function addChordNote(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  let noteCount = 0;
-  let entryIndex = -1;
-  let targetNote = null;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note") {
-      if (noteCount === options.afterNoteIndex) {
-        entryIndex = i;
-        targetNote = entry;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (entryIndex !== -1 && targetNote) {
-    const chordNote = {
-      type: "note",
-      pitch: options.pitch,
-      duration: targetNote.duration,
-      voice: targetNote.voice,
-      staff: targetNote.staff,
-      chord: true,
-      noteType: targetNote.noteType,
-      dots: targetNote.dots
-    };
-    measure.entries.splice(entryIndex + 1, 0, chordNote);
-  }
-  return result;
-}
-function modifyNotePitch(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note") {
-      if (noteCount === options.noteIndex) {
-        entry.pitch = options.pitch;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  return result;
-}
-function modifyNoteDuration(score, options) {
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  if (!part) return result;
-  const measure = part.measures[options.measureIndex];
-  if (!measure) return result;
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note") {
-      if (noteCount === options.noteIndex) {
-        entry.duration = options.duration;
-        if (options.noteType !== void 0) {
-          entry.noteType = options.noteType;
-        }
-        if (options.dots !== void 0) {
-          entry.dots = options.dots;
-        }
-        break;
-      }
-      noteCount++;
-    }
-  }
-  return result;
-}
+var addNote = (score, options) => {
+  const result = insertNote(score, {
+    partIndex: options.partIndex,
+    measureIndex: options.measureIndex,
+    voice: options.voice,
+    staff: options.staff,
+    position: options.position,
+    pitch: options.note.pitch ?? { step: "C", octave: 4 },
+    duration: options.note.duration,
+    noteType: options.note.noteType,
+    dots: options.note.dots
+  });
+  return result.success ? result.data : score;
+};
+var deleteNote = (score, options) => {
+  const result = removeNote(score, options);
+  return result.success ? result.data : score;
+};
+var addChordNote = (score, options) => {
+  const result = addChord(score, { ...options, noteIndex: options.afterNoteIndex });
+  return result.success ? result.data : score;
+};
+var modifyNotePitch = (score, options) => {
+  const result = setNotePitch(score, options);
+  return result.success ? result.data : score;
+};
+var modifyNoteDuration = (score, options) => {
+  const result = changeNoteDuration(score, { ...options, newDuration: options.duration });
+  return result.success ? result.data : score;
+};
 
 // src/file.ts
 import { readFile, writeFile } from "fs/promises";
@@ -5860,6 +7545,8 @@ export {
   addNote,
   assertMeasureValid,
   assertValid,
+  buildVoiceToStaffMap,
+  buildVoiceToStaffMapForPart,
   changeKey,
   changeTime,
   countNotes,
@@ -5867,36 +7554,82 @@ export {
   deleteMeasure,
   deleteNote,
   exportMidi,
+  findBarlines,
+  findDirectionsByType,
   findNotes,
+  findNotesWithNotation,
   formatLocation,
   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,
   getMeasureContext,
   getMeasureCount,
   getMeasureEndPosition,
+  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,
   insertMeasure,
   isCompressed,
   isRestMeasure,
   isValid,
+  iterateEntries,
   iterateNotes,
   measureRoundtrip,
   modifyNoteDuration,
@@ -5910,7 +7643,6 @@ export {
   serialize,
   serializeCompressed,
   serializeToFile,
-  setDivisions,
   transpose,
   validate,
   validateBackupForward,
@@ -5929,4 +7661,3 @@ export {
   validateVoiceStaff,
   withAbsolutePositions
 };
-//# sourceMappingURL=index.mjs.map