musicxml-io 0.3.3 → 0.3.4

package/dist/operations/index.mjs

@@ -1,4833 +1,112 @@
-// src/id.ts
-import { nanoid } from "nanoid";
-function generateId() {
-  return "i" + nanoid(10);
-}
-
-// src/utils/index.ts
-var STEPS = ["C", "D", "E", "F", "G", "A", "B"];
-var STEP_SEMITONES = {
-  "C": 0,
-  "D": 2,
-  "E": 4,
-  "F": 5,
-  "G": 7,
-  "A": 9,
-  "B": 11
-};
-var SHARP_ORDER = ["F", "C", "G", "D", "A", "E", "B"];
-var FLAT_ORDER = ["B", "E", "A", "D", "G", "C", "F"];
-function pitchToSemitone(pitch) {
-  return pitch.octave * 12 + STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0);
-}
-function getAlterForStepInKey(step, key) {
-  const fifths = key.fifths;
-  if (fifths > 0) {
-    const sharps = SHARP_ORDER.slice(0, fifths);
-    return sharps.includes(step) ? 1 : 0;
-  } else if (fifths < 0) {
-    const flats = FLAT_ORDER.slice(0, -fifths);
-    return flats.includes(step) ? -1 : 0;
-  }
-  return 0;
-}
-function getAlteredStepsInKey(key) {
-  const alterations = /* @__PURE__ */ new Map();
-  const fifths = key.fifths;
-  if (fifths > 0) {
-    SHARP_ORDER.slice(0, fifths).forEach((step) => alterations.set(step, 1));
-  } else if (fifths < 0) {
-    FLAT_ORDER.slice(0, -fifths).forEach((step) => alterations.set(step, -1));
-  }
-  return alterations;
-}
-function getAccidentalsInMeasure(measure, upToPosition, voice) {
-  const accidentals = /* @__PURE__ */ new Map();
-  let position = 0;
-  for (const entry of measure.entries) {
-    if (position >= upToPosition) break;
-    if (entry.type === "note") {
-      if (voice === void 0 || entry.voice === voice) {
-        if (entry.pitch && entry.accidental) {
-          const key = `${entry.pitch.step}${entry.pitch.octave}`;
-          accidentals.set(key, entry.pitch.alter ?? 0);
-        }
-      }
-      if (!entry.chord) {
-        position += entry.duration;
-      }
-    } else if (entry.type === "backup") {
-      position -= entry.duration;
-    } else if (entry.type === "forward") {
-      position += entry.duration;
-    }
-  }
-  return accidentals;
-}
-function semitoneToKeyAwarePitch(semitone, key, options) {
-  const octave = Math.floor(semitone / 12);
-  const pitchClass = (semitone % 12 + 12) % 12;
-  const keyPreferSharp = key.fifths >= 0;
-  const preferSharp = options?.preferSharp ?? keyPreferSharp;
-  for (const step of STEPS) {
-    const stepSemitone = STEP_SEMITONES[step];
-    if (stepSemitone === pitchClass) {
-      return { step, octave };
-    }
-  }
-  const keyAlterations = getAlteredStepsInKey(key);
-  for (const step of STEPS) {
-    const stepSemitone = STEP_SEMITONES[step];
-    const keyAlter = keyAlterations.get(step) ?? 0;
-    if ((stepSemitone + keyAlter) % 12 === pitchClass) {
-      return { step, octave, alter: keyAlter };
-    }
-  }
-  if (preferSharp) {
-    for (const step of STEPS) {
-      const stepSemitone = STEP_SEMITONES[step];
-      const diff = (pitchClass - stepSemitone + 12) % 12;
-      if (diff === 1) {
-        return { step, octave, alter: 1 };
-      }
-    }
-    for (const step of STEPS) {
-      const stepSemitone = STEP_SEMITONES[step];
-      const diff = (pitchClass - stepSemitone + 12) % 12;
-      if (diff === 2) {
-        return { step, octave, alter: 2 };
-      }
-    }
-  } else {
-    for (const step of STEPS) {
-      const stepSemitone = STEP_SEMITONES[step];
-      const diff = (stepSemitone - pitchClass + 12) % 12;
-      if (diff === 1) {
-        return { step, octave, alter: -1 };
-      }
-    }
-    for (const step of STEPS) {
-      const stepSemitone = STEP_SEMITONES[step];
-      const diff = (stepSemitone - pitchClass + 12) % 12;
-      if (diff === 2) {
-        return { step, octave, alter: -2 };
-      }
-    }
-  }
-  return { step: "C", octave, alter: pitchClass };
-}
-function determineAccidental(pitch, key, accidentalsInMeasure) {
-  const noteKey = `${pitch.step}${pitch.octave}`;
-  const alter = pitch.alter ?? 0;
-  const keyAlter = getAlterForStepInKey(pitch.step, key);
-  const previousAlter = accidentalsInMeasure.get(noteKey);
-  if (previousAlter !== void 0) {
-    if (alter === previousAlter) {
-      return void 0;
-    }
-  } else {
-    if (alter === keyAlter) {
-      return void 0;
-    }
-  }
-  if (alter === 0) return "natural";
-  if (alter === 1) return "sharp";
-  if (alter === -1) return "flat";
-  if (alter === 2) return "double-sharp";
-  if (alter === -2) return "double-flat";
-  return void 0;
-}
-function createPositionState() {
-  return { position: 0, lastNonChordPosition: 0 };
-}
-function updatePositionForEntry(state, entry) {
-  const pos = state.position;
-  switch (entry.type) {
-    case "note": {
-      const note = entry;
-      if (!note.chord) {
-        state.lastNonChordPosition = state.position;
-        state.position += note.duration;
-      }
-      return note.chord ? state.lastNonChordPosition : pos;
-    }
-    case "backup":
-      state.position -= entry.duration;
-      state.lastNonChordPosition = state.position;
-      return pos;
-    case "forward":
-      state.position += entry.duration;
-      state.lastNonChordPosition = state.position;
-      return pos;
-    default:
-      return pos;
-  }
-}
-function getAbsolutePositionForNote(note, measure) {
-  const state = createPositionState();
-  for (const entry of measure.entries) {
-    if (entry === note) return entry.chord ? state.lastNonChordPosition : state.position;
-    updatePositionForEntry(state, entry);
-  }
-  return state.position;
-}
-function getMeasureEndPosition(measure) {
-  const state = createPositionState();
-  for (const entry of measure.entries) updatePositionForEntry(state, entry);
-  return state.position;
-}
-
-// src/validator/index.ts
-var DEFAULT_OPTIONS = {
-  checkDivisions: true,
-  checkMeasureDuration: true,
-  checkMeasureFullness: false,
-  // Piano Roll semantics - opt-in
-  checkPosition: true,
-  checkTies: true,
-  checkBeams: true,
-  checkSlurs: true,
-  checkTuplets: true,
-  checkPartReferences: true,
-  checkPartStructure: true,
-  checkVoiceStaff: true,
-  checkStaffStructure: true,
-  durationTolerance: 0
-};
-function validate(score, options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const allErrors = [];
-  if (opts.checkPartReferences) {
-    allErrors.push(...validatePartReferences(score));
-  }
-  if (opts.checkPartStructure) {
-    allErrors.push(...validatePartStructure(score));
-  }
-  if (opts.checkDivisions) {
-    allErrors.push(...validateDivisions(score));
-  }
-  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
-    const part = score.parts[partIndex];
-    let currentDivisions = 1;
-    let currentTime;
-    let currentStaves = 1;
-    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
-      const measure = part.measures[measureIndex];
-      const location = {
-        partIndex,
-        partId: part.id,
-        measureIndex,
-        measureNumber: measure.number
-      };
-      if (measure.attributes) {
-        if (measure.attributes.divisions !== void 0) {
-          currentDivisions = measure.attributes.divisions;
-        }
-        if (measure.attributes.time !== void 0) {
-          currentTime = measure.attributes.time;
-        }
-        if (measure.attributes.staves !== void 0) {
-          currentStaves = measure.attributes.staves;
-        }
-      }
-      if (opts.checkMeasureDuration && currentTime) {
-        allErrors.push(...validateMeasureDuration(
-          measure,
-          currentDivisions,
-          currentTime,
-          location,
-          opts.durationTolerance
-        ));
-      }
-      if (opts.checkMeasureFullness && currentTime) {
-        allErrors.push(...validateMeasureFullness(
-          measure,
-          currentDivisions,
-          currentTime,
-          location
-        ));
-      }
-      if (opts.checkPosition) {
-        allErrors.push(...validateBackupForward(measure, location));
-      }
-      if (opts.checkTies) {
-        allErrors.push(...validateTies(measure, location));
-      }
-      if (opts.checkBeams) {
-        allErrors.push(...validateBeams(measure, location));
-      }
-      if (opts.checkSlurs) {
-        allErrors.push(...validateSlurs(measure, location));
-      }
-      if (opts.checkTuplets) {
-        allErrors.push(...validateTuplets(measure, location));
-      }
-      if (opts.checkVoiceStaff) {
-        allErrors.push(...validateVoiceStaff(measure, currentStaves, location));
-      }
-    }
-    if (opts.checkStaffStructure) {
-      allErrors.push(...validateStaffStructure(part, partIndex));
-    }
-  }
-  const errors = allErrors.filter((e) => e.level === "error");
-  const warnings = allErrors.filter((e) => e.level === "warning");
-  const infos = allErrors.filter((e) => e.level === "info");
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-    infos
-  };
-}
-function validateDivisions(score) {
-  const errors = [];
-  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
-    const part = score.parts[partIndex];
-    let hasDivisions = false;
-    for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
-      const measure = part.measures[measureIndex];
-      if (measure.attributes?.divisions !== void 0) {
-        hasDivisions = true;
-        if (measure.attributes.divisions <= 0) {
-          errors.push({
-            code: "INVALID_DIVISIONS",
-            level: "error",
-            message: `Invalid divisions value: ${measure.attributes.divisions}. Must be positive.`,
-            location: {
-              partIndex,
-              partId: part.id,
-              measureIndex,
-              measureNumber: measure.number
-            },
-            details: { divisions: measure.attributes.divisions }
-          });
-        }
-      }
-      if (!hasDivisions) {
-        const hasNotes = measure.entries.some((e) => e.type === "note");
-        if (hasNotes) {
-          errors.push({
-            code: "MISSING_DIVISIONS",
-            level: "error",
-            message: "Notes found before divisions are defined",
-            location: {
-              partIndex,
-              partId: part.id,
-              measureIndex,
-              measureNumber: measure.number
-            }
-          });
-          hasDivisions = true;
-        }
-      }
-    }
-  }
-  return errors;
-}
-function validateMeasureDuration(measure, divisions, time, location, tolerance = 0) {
-  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 voiceDurations = calculateVoiceDurations(measure);
-  for (const [voiceKey, actualDuration] of voiceDurations.entries()) {
-    const [staff, voice] = voiceKey.split("-").map(Number);
-    const diff = actualDuration - expectedDuration;
-    if (Math.abs(diff) > tolerance) {
-      if (diff > 0) {
-        errors.push({
-          code: "MEASURE_DURATION_OVERFLOW",
-          level: "error",
-          message: `Voice ${voice} (staff ${staff}) duration ${actualDuration} exceeds expected ${expectedDuration}`,
-          location: { ...location, voice, staff },
-          details: {
-            expected: expectedDuration,
-            actual: actualDuration,
-            difference: diff
-          }
-        });
-      } else {
-        errors.push({
-          code: "MEASURE_DURATION_UNDERFLOW",
-          level: "warning",
-          message: `Voice ${voice} (staff ${staff}) duration ${actualDuration} is less than expected ${expectedDuration}`,
-          location: { ...location, voice, staff },
-          details: {
-            expected: expectedDuration,
-            actual: actualDuration,
-            difference: diff
-          }
-        });
-      }
-    }
-  }
-  return errors;
-}
-function calculateVoiceDurations(measure) {
-  const voiceDurations = /* @__PURE__ */ new Map();
-  let currentPosition = 0;
-  const voiceMaxPositions = /* @__PURE__ */ new Map();
-  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) {
-        const endPosition = currentPosition + entry.duration;
-        const currentMax = voiceMaxPositions.get(key) ?? 0;
-        voiceMaxPositions.set(key, Math.max(currentMax, endPosition));
-        currentPosition = endPosition;
-      }
-    } else if (entry.type === "backup") {
-      currentPosition -= entry.duration;
-    } else if (entry.type === "forward") {
-      currentPosition += entry.duration;
-    }
-  }
-  for (const [key, maxPos] of voiceMaxPositions.entries()) {
-    voiceDurations.set(key, maxPos);
-  }
-  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;
-  let minPosition = 0;
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type === "note") {
-      if (!entry.chord) {
-        position += entry.duration;
-      }
-    } else if (entry.type === "backup") {
-      const newPosition = position - entry.duration;
-      if (newPosition < 0) {
-        errors.push({
-          code: "BACKUP_EXCEEDS_POSITION",
-          level: "error",
-          message: `Backup of ${entry.duration} at position ${position} results in negative position ${newPosition}`,
-          location: { ...location, entryIndex },
-          details: {
-            backupDuration: entry.duration,
-            positionBefore: position,
-            positionAfter: newPosition
-          }
-        });
-      }
-      position = newPosition;
-      minPosition = Math.min(minPosition, position);
-    } else if (entry.type === "forward") {
-      position += entry.duration;
-    }
-  }
-  if (minPosition < 0) {
-    errors.push({
-      code: "NEGATIVE_POSITION",
-      level: "error",
-      message: `Position went negative (min: ${minPosition}) in measure`,
-      location,
-      details: { minPosition }
-    });
-  }
-  return errors;
-}
-function validateTies(measure, location) {
-  const errors = [];
-  const openTies = /* @__PURE__ */ new Map();
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type !== "note" || !entry.pitch) continue;
-    const pitchKey = `${entry.pitch.step}${entry.pitch.octave}${entry.pitch.alter ?? 0}-${entry.voice}-${entry.staff ?? 1}`;
-    const ties = entry.ties ?? (entry.tie ? [entry.tie] : []);
-    for (const tie of ties) {
-      if (tie.type === "start") {
-        if (openTies.has(pitchKey)) {
-        }
-        openTies.set(pitchKey, { entryIndex, pitch: entry.pitch });
-      } else if (tie.type === "stop") {
-        if (!openTies.has(pitchKey)) {
-          errors.push({
-            code: "TIE_STOP_WITHOUT_START",
-            level: "warning",
-            message: `Tie stop without matching start for ${entry.pitch.step}${entry.pitch.octave}`,
-            location: { ...location, entryIndex, voice: entry.voice, staff: entry.staff ?? 1 },
-            details: { pitch: entry.pitch }
-          });
-        } else {
-          openTies.delete(pitchKey);
-        }
-      }
-    }
-  }
-  return errors;
-}
-function validateBeams(measure, location) {
-  const errors = [];
-  const openBeams = /* @__PURE__ */ new Map();
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type !== "note" || !entry.beam) continue;
-    for (const beam of entry.beam) {
-      const beamKey = `${beam.number}-${entry.voice}`;
-      if (beam.type === "begin") {
-        if (openBeams.has(beamKey)) {
-          errors.push({
-            code: "BEAM_BEGIN_WITHOUT_END",
-            level: "error",
-            message: `Beam ${beam.number} started again before previous beam ended`,
-            location: { ...location, entryIndex, voice: entry.voice, staff: entry.staff ?? 1 },
-            details: { beamNumber: beam.number }
-          });
-        }
-        openBeams.set(beamKey, { entryIndex, staff: entry.staff ?? 1 });
-      } else if (beam.type === "end") {
-        if (!openBeams.has(beamKey)) {
-          errors.push({
-            code: "BEAM_END_WITHOUT_BEGIN",
-            level: "error",
-            message: `Beam ${beam.number} end without matching begin`,
-            location: { ...location, entryIndex, voice: entry.voice, staff: entry.staff ?? 1 },
-            details: { beamNumber: beam.number }
-          });
-        } else {
-          openBeams.delete(beamKey);
-        }
-      }
-    }
-  }
-  for (const [beamKey, { entryIndex: startIndex, staff }] of openBeams.entries()) {
-    const [beamNumber, voice] = beamKey.split("-").map(Number);
-    errors.push({
-      code: "BEAM_BEGIN_WITHOUT_END",
-      level: "error",
-      message: `Beam ${beamNumber} started but never ended in measure`,
-      location: { ...location, entryIndex: startIndex, voice, staff },
-      details: { beamNumber }
-    });
-  }
-  return errors;
-}
-function validateSlurs(measure, _location) {
-  const errors = [];
-  const openSlurs = /* @__PURE__ */ new Map();
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type !== "note" || !entry.notations) continue;
-    for (const notation of entry.notations) {
-      if (notation.type !== "slur") continue;
-      const slurNumber = notation.number ?? 1;
-      const slurKey = `${slurNumber}-${entry.voice}-${entry.staff ?? 1}`;
-      if (notation.slurType === "start") {
-        if (openSlurs.has(slurKey)) {
-        }
-        openSlurs.set(slurKey, entryIndex);
-      } else if (notation.slurType === "stop") {
-        if (!openSlurs.has(slurKey)) {
-        } else {
-          openSlurs.delete(slurKey);
-        }
-      }
-    }
-  }
-  return errors;
-}
-function validateTuplets(measure, location) {
-  const errors = [];
-  const openTuplets = /* @__PURE__ */ new Map();
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type !== "note" || !entry.notations) continue;
-    for (const notation of entry.notations) {
-      if (notation.type !== "tuplet") continue;
-      const tupletNumber = notation.number ?? 1;
-      const tupletKey = `${tupletNumber}-${entry.voice}-${entry.staff ?? 1}`;
-      if (notation.tupletType === "start") {
-        if (openTuplets.has(tupletKey)) {
-          errors.push({
-            code: "TUPLET_START_WITHOUT_STOP",
-            level: "error",
-            message: `Tuplet ${tupletNumber} started again before previous tuplet ended`,
-            location: { ...location, entryIndex, voice: entry.voice, staff: entry.staff ?? 1 },
-            details: { tupletNumber }
-          });
-        }
-        openTuplets.set(tupletKey, entryIndex);
-      } else if (notation.tupletType === "stop") {
-        if (!openTuplets.has(tupletKey)) {
-          errors.push({
-            code: "TUPLET_STOP_WITHOUT_START",
-            level: "error",
-            message: `Tuplet ${tupletNumber} stop without matching start`,
-            location: { ...location, entryIndex, voice: entry.voice, staff: entry.staff ?? 1 },
-            details: { tupletNumber }
-          });
-        } else {
-          openTuplets.delete(tupletKey);
-        }
-      }
-    }
-  }
-  for (const [tupletKey, startIndex] of openTuplets.entries()) {
-    const [tupletNumber, voice, staff] = tupletKey.split("-").map(Number);
-    errors.push({
-      code: "TUPLET_START_WITHOUT_STOP",
-      level: "error",
-      message: `Tuplet ${tupletNumber} started but never ended in measure`,
-      location: { ...location, entryIndex: startIndex, voice, staff },
-      details: { tupletNumber }
-    });
-  }
-  return errors;
-}
-function validatePartReferences(score) {
-  const errors = [];
-  const partListIds = /* @__PURE__ */ new Set();
-  for (const entry of score.partList) {
-    if (entry.type === "score-part") {
-      partListIds.add(entry.id);
-    }
-  }
-  const partIds = /* @__PURE__ */ new Set();
-  for (const part of score.parts) {
-    partIds.add(part.id);
-  }
-  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
-    const part = score.parts[partIndex];
-    if (!partListIds.has(part.id)) {
-      errors.push({
-        code: "PART_ID_NOT_IN_PART_LIST",
-        level: "error",
-        message: `Part "${part.id}" is not defined in partList`,
-        location: { partIndex, partId: part.id }
-      });
-    }
-  }
-  for (const entry of score.partList) {
-    if (entry.type === "score-part" && !partIds.has(entry.id)) {
-      errors.push({
-        code: "PART_LIST_ID_NOT_IN_PARTS",
-        level: "error",
-        message: `PartList entry "${entry.id}" has no corresponding part`,
-        location: { partId: entry.id }
-      });
-    }
-  }
-  return errors;
-}
-function validateVoiceStaff(measure, staves, location) {
-  const errors = [];
-  for (let entryIndex = 0; entryIndex < measure.entries.length; entryIndex++) {
-    const entry = measure.entries[entryIndex];
-    if (entry.type !== "note") continue;
-    if (entry.voice !== void 0 && entry.voice <= 0) {
-      errors.push({
-        code: "INVALID_VOICE_NUMBER",
-        level: "error",
-        message: `Invalid voice number: ${entry.voice}. Must be positive.`,
-        location: { ...location, entryIndex, voice: entry.voice }
-      });
-    }
-    const staff = entry.staff ?? 1;
-    if (staff <= 0) {
-      errors.push({
-        code: "INVALID_STAFF_NUMBER",
-        level: "error",
-        message: `Invalid staff number: ${staff}. Must be positive.`,
-        location: { ...location, entryIndex, staff }
-      });
-    } else if (staff > staves) {
-      errors.push({
-        code: "STAFF_EXCEEDS_STAVES",
-        level: "error",
-        message: `Staff number ${staff} exceeds declared staves count ${staves}`,
-        location: { ...location, entryIndex, staff },
-        details: { declaredStaves: staves }
-      });
-    }
-    if (entry.duration < 0) {
-      errors.push({
-        code: "INVALID_DURATION",
-        level: "error",
-        message: `Invalid duration: ${entry.duration}. Must be non-negative.`,
-        location: { ...location, entryIndex },
-        details: { duration: entry.duration }
-      });
-    }
-  }
-  return errors;
-}
-function validatePartStructure(score) {
-  const errors = [];
-  if (score.parts.length === 0) {
-    return errors;
-  }
-  const partIds = /* @__PURE__ */ new Map();
-  for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
-    const part = score.parts[partIndex];
-    if (partIds.has(part.id)) {
-      errors.push({
-        code: "DUPLICATE_PART_ID",
-        level: "error",
-        message: `Duplicate part ID "${part.id}" found at index ${partIndex} (first at index ${partIds.get(part.id)})`,
-        location: { partIndex, partId: part.id },
-        details: { firstIndex: partIds.get(part.id) }
-      });
-    } else {
-      partIds.set(part.id, partIndex);
-    }
-  }
-  const referencePart = score.parts[0];
-  const referenceMeasureCount = referencePart.measures.length;
-  for (let partIndex = 1; partIndex < score.parts.length; partIndex++) {
-    const part = score.parts[partIndex];
-    if (part.measures.length !== referenceMeasureCount) {
-      errors.push({
-        code: "PART_MEASURE_COUNT_MISMATCH",
-        level: "error",
-        message: `Part "${part.id}" has ${part.measures.length} measures, expected ${referenceMeasureCount} (same as first part)`,
-        location: { partIndex, partId: part.id },
-        details: {
-          expected: referenceMeasureCount,
-          actual: part.measures.length
-        }
-      });
-    }
-    const minLength = Math.min(part.measures.length, referenceMeasureCount);
-    for (let measureIndex = 0; measureIndex < minLength; measureIndex++) {
-      const refMeasure = referencePart.measures[measureIndex];
-      const partMeasure = part.measures[measureIndex];
-      if (refMeasure.number !== partMeasure.number) {
-        errors.push({
-          code: "PART_MEASURE_NUMBER_MISMATCH",
-          level: "warning",
-          message: `Part "${part.id}" measure at index ${measureIndex} has number "${partMeasure.number}", expected "${refMeasure.number}"`,
-          location: {
-            partIndex,
-            partId: part.id,
-            measureIndex,
-            measureNumber: partMeasure.number
-          },
-          details: {
-            expected: refMeasure.number,
-            actual: partMeasure.number
-          }
-        });
-      }
-    }
-  }
-  const openGroups = /* @__PURE__ */ new Map();
-  for (let i = 0; i < score.partList.length; i++) {
-    const entry = score.partList[i];
-    if (entry.type !== "part-group") continue;
-    const groupNumber = entry.number ?? 1;
-    if (entry.groupType === "start") {
-      if (openGroups.has(groupNumber)) {
-        errors.push({
-          code: "PART_GROUP_START_WITHOUT_STOP",
-          level: "error",
-          message: `Part group ${groupNumber} started again at index ${i} before previous group ended`,
-          location: {},
-          details: { groupNumber, partListIndex: i }
-        });
-      }
-      openGroups.set(groupNumber, i);
-    } else if (entry.groupType === "stop") {
-      if (!openGroups.has(groupNumber)) {
-        errors.push({
-          code: "PART_GROUP_STOP_WITHOUT_START",
-          level: "error",
-          message: `Part group ${groupNumber} stop at index ${i} without matching start`,
-          location: {},
-          details: { groupNumber, partListIndex: i }
-        });
-      } else {
-        openGroups.delete(groupNumber);
-      }
-    }
-  }
-  for (const [groupNumber, startIndex] of openGroups.entries()) {
-    errors.push({
-      code: "PART_GROUP_START_WITHOUT_STOP",
-      level: "error",
-      message: `Part group ${groupNumber} started at index ${startIndex} but never stopped`,
-      location: {},
-      details: { groupNumber, partListIndex: startIndex }
-    });
-  }
-  return errors;
-}
-function validateStaffStructure(part, partIndex) {
-  const errors = [];
-  let currentStaves = void 0;
-  let stavesDeclarationMeasure = void 0;
-  const clefsDeclaredForStaves = /* @__PURE__ */ new Set();
-  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
-    const measure = part.measures[measureIndex];
-    const location = {
-      partIndex,
-      partId: part.id,
-      measureIndex,
-      measureNumber: measure.number
-    };
-    if (measure.attributes?.staves !== void 0) {
-      const newStaves = measure.attributes.staves;
-      if (currentStaves !== void 0 && newStaves !== currentStaves) {
-        errors.push({
-          code: "STAVES_DECLARATION_MISMATCH",
-          level: "info",
-          message: `Staves count changed from ${currentStaves} to ${newStaves}`,
-          location,
-          details: {
-            previous: currentStaves,
-            new: newStaves,
-            previousMeasure: stavesDeclarationMeasure
-          }
-        });
-        clefsDeclaredForStaves.clear();
-      }
-      currentStaves = newStaves;
-      stavesDeclarationMeasure = measure.number;
-    }
-    if (measure.attributes?.clef) {
-      for (const clef of measure.attributes.clef) {
-        const staffNum = clef.staff ?? 1;
-        clefsDeclaredForStaves.add(staffNum);
-        if (currentStaves !== void 0 && staffNum > currentStaves) {
-          errors.push({
-            code: "CLEF_STAFF_EXCEEDS_STAVES",
-            level: "error",
-            message: `Clef declared for staff ${staffNum}, but only ${currentStaves} staves declared`,
-            location,
-            details: {
-              clefStaff: staffNum,
-              declaredStaves: currentStaves
-            }
-          });
-        }
-      }
-    }
-    if (currentStaves !== void 0) {
-      const usedStaves = /* @__PURE__ */ new Set();
-      for (const entry of measure.entries) {
-        if (entry.type === "note") {
-          usedStaves.add(entry.staff ?? 1);
-        } else if (entry.type === "forward" && entry.staff) {
-          usedStaves.add(entry.staff);
-        }
-      }
-      for (const usedStaff of usedStaves) {
-        if (usedStaff > currentStaves) {
-        }
-      }
-    }
-  }
-  if (currentStaves !== void 0 && currentStaves > 1) {
-    for (let staff = 1; staff <= currentStaves; staff++) {
-      if (!clefsDeclaredForStaves.has(staff)) {
-        errors.push({
-          code: "MISSING_CLEF_FOR_STAFF",
-          level: "warning",
-          message: `No clef declared for staff ${staff} in part "${part.id}"`,
-          location: { partIndex, partId: part.id },
-          details: { staff, totalStaves: currentStaves }
-        });
-      }
-    }
-  }
-  const allUsedStaves = /* @__PURE__ */ new Set();
-  for (const measure of part.measures) {
-    for (const entry of measure.entries) {
-      if (entry.type === "note" && entry.staff !== void 0) {
-        allUsedStaves.add(entry.staff);
-      }
-    }
-  }
-  if (allUsedStaves.size > 1 && currentStaves === void 0) {
-    errors.push({
-      code: "MISSING_STAVES_DECLARATION",
-      level: "warning",
-      message: `Part "${part.id}" uses staff numbers ${Array.from(allUsedStaves).sort().join(", ")} but has no staves declaration`,
-      location: { partIndex, partId: part.id },
-      details: { usedStaves: Array.from(allUsedStaves).sort() }
-    });
-  }
-  return errors;
-}
-var DEFAULT_LOCAL_OPTIONS = {
-  checkMeasureDuration: true,
-  checkMeasureFullness: false,
-  // Piano Roll semantics - opt-in
-  checkPosition: true,
-  checkBeams: true,
-  checkTuplets: true,
-  checkVoiceStaff: true,
-  durationTolerance: 0
-};
-function validateMeasureLocal(measure, context, options = {}) {
-  const opts = { ...DEFAULT_LOCAL_OPTIONS, ...options };
-  const errors = [];
-  const location = {
-    partIndex: context.partIndex,
-    partId: context.partId,
-    measureIndex: context.measureIndex,
-    measureNumber: measure.number
-  };
-  if (opts.checkMeasureDuration && context.time) {
-    errors.push(...validateMeasureDuration(
-      measure,
-      context.divisions,
-      context.time,
-      location,
-      opts.durationTolerance
-    ));
-  }
-  if (opts.checkMeasureFullness && context.time) {
-    errors.push(...validateMeasureFullness(
-      measure,
-      context.divisions,
-      context.time,
-      location
-    ));
-  }
-  if (opts.checkPosition) {
-    errors.push(...validateBackupForward(measure, location));
-  }
-  if (opts.checkBeams) {
-    errors.push(...validateBeams(measure, location));
-  }
-  if (opts.checkTuplets) {
-    errors.push(...validateTuplets(measure, location));
-  }
-  if (opts.checkVoiceStaff) {
-    errors.push(...validateVoiceStaff(measure, context.staves, location));
-  }
-  return errors;
-}
-function getMeasureContext(score, partIndex, measureIndex) {
-  const part = score.parts[partIndex];
-  if (!part) {
-    throw new Error(`Part index ${partIndex} out of bounds`);
-  }
-  let divisions = 1;
-  let time;
-  let staves = 1;
-  for (let i = 0; i <= measureIndex && i < part.measures.length; i++) {
-    const measure = part.measures[i];
-    if (measure.attributes) {
-      if (measure.attributes.divisions !== void 0) {
-        divisions = measure.attributes.divisions;
-      }
-      if (measure.attributes.time !== void 0) {
-        time = measure.attributes.time;
-      }
-      if (measure.attributes.staves !== void 0) {
-        staves = measure.attributes.staves;
-      }
-    }
-    for (const entry of measure.entries) {
-      if (entry.type === "attributes") {
-        if (entry.attributes.divisions !== void 0) {
-          divisions = entry.attributes.divisions;
-        }
-        if (entry.attributes.time !== void 0) {
-          time = entry.attributes.time;
-        }
-        if (entry.attributes.staves !== void 0) {
-          staves = entry.attributes.staves;
-        }
-      }
-    }
-  }
-  return {
-    divisions,
-    time,
-    staves,
-    partIndex,
-    partId: part.id,
-    measureIndex
-  };
-}
-
-// src/query/index.ts
-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;
-}
-
-// 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 cloneNoteWithNewId(note) {
-  const cloned = JSON.parse(JSON.stringify(note));
-  cloned._id = generateId();
-  return cloned;
-}
-function cloneEntryWithNewId(entry) {
-  const cloned = JSON.parse(JSON.stringify(entry));
-  cloned._id = generateId();
-  return cloned;
-}
-function cloneMeasureWithNewIds(measure) {
-  const cloned = JSON.parse(JSON.stringify(measure));
-  cloned._id = generateId();
-  cloned.entries = cloned.entries.map((entry) => cloneEntryWithNewId(entry));
-  if (cloned.barlines) {
-    cloned.barlines = cloned.barlines.map((barline) => ({
-      ...barline,
-      _id: generateId()
-    }));
-  }
-  return cloned;
-}
-function clonePartWithNewIds(part) {
-  const cloned = JSON.parse(JSON.stringify(part));
-  cloned._id = generateId();
-  cloned.measures = cloned.measures.map((measure) => cloneMeasureWithNewIds(measure));
-  return cloned;
-}
-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) {
-  const note = {
-    _id: generateId(),
-    type: "note",
-    rest: { displayStep: void 0, displayOctave: void 0 },
-    duration,
-    staff
-  };
-  if (voice !== void 0) {
-    note.voice = voice;
-  }
-  return note;
-}
-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({ _id: generateId(), type: "backup", duration: -diff });
-      currentPosition = targetPos;
-    } else if (diff > 0) {
-      result.push({
-        _id: generateId(),
-        type: "forward",
-        duration: diff,
-        voice: entry.type === "note" ? entry.voice : 1,
-        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, conflictingNotes } = hasNotesInRange(voiceEntries, options.position, noteEnd);
-  if (hasNotes) {
-    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 = {
-    _id: generateId(),
-    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 = {
-    _id: generateId(),
-    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, conflictingNotes } = hasNotesInRange(
-      voiceEntries.filter((e) => e.position !== targetPosition),
-      // Exclude current note
-      targetPosition + oldDuration,
-      newEnd
-    );
-    if (hasNotes) {
-      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 setNotePitchBySemitone(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];
-  const measureNumber = measure.number ?? String(options.measureIndex + 1);
-  const attrs = getAttributesAtMeasure(result, { part: options.partIndex, measure: measureNumber });
-  const keySignature = attrs.key ?? { fifths: 0 };
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        const notePosition = getAbsolutePositionForNote(entry, measure);
-        const accidentalsInMeasure = getAccidentalsInMeasure(measure, notePosition, entry.voice);
-        const newPitch = semitoneToKeyAwarePitch(options.semitone, keySignature, {
-          preferSharp: options.preferSharp
-        });
-        const accidental = determineAccidental(newPitch, keySignature, accidentalsInMeasure);
-        entry.pitch = newPitch;
-        if (accidental) {
-          entry.accidental = { value: accidental };
-        } else {
-          delete entry.accidental;
-        }
-        return success(result);
-      }
-      noteCount++;
-    }
-  }
-  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-}
-function shiftNotePitch(score, options) {
-  if (options.semitones === 0) {
-    return success(score);
-  }
-  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 measure = part.measures[options.measureIndex];
-  let noteCount = 0;
-  let currentSemitone = null;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        if (!entry.pitch) {
-          return failure([operationError("NOTE_NOT_FOUND", "Note has no pitch", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-        }
-        currentSemitone = pitchToSemitone(entry.pitch);
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (currentSemitone === null) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  return setNotePitchBySemitone(score, {
-    partIndex: options.partIndex,
-    measureIndex: options.measureIndex,
-    noteIndex: options.noteIndex,
-    semitone: currentSemitone + options.semitones,
-    preferSharp: options.preferSharp
-  });
-}
-function raiseAccidental(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];
-  const measureNumber = measure.number ?? String(options.measureIndex + 1);
-  const attrs = getAttributesAtMeasure(result, { part: options.partIndex, measure: measureNumber });
-  const keySignature = attrs.key ?? { fifths: 0 };
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        if (!entry.pitch) {
-          return failure([operationError("NOTE_NOT_FOUND", "Note has no pitch", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-        }
-        const currentAlter = entry.pitch.alter ?? 0;
-        const newAlter = currentAlter + 1;
-        if (newAlter > 2) {
-          return failure([operationError("ACCIDENTAL_OUT_OF_BOUNDS", `Cannot raise accidental beyond double-sharp (current: ${currentAlter})`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-        }
-        entry.pitch.alter = newAlter === 0 ? void 0 : newAlter;
-        const notePosition = getAbsolutePositionForNote(entry, measure);
-        const accidentalsInMeasure = getAccidentalsInMeasure(measure, notePosition, entry.voice);
-        const accidental = determineAccidental(entry.pitch, keySignature, accidentalsInMeasure);
-        if (accidental) {
-          entry.accidental = { value: accidental };
-        } else {
-          delete entry.accidental;
-        }
-        return success(result);
-      }
-      noteCount++;
-    }
-  }
-  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-}
-function lowerAccidental(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];
-  const measureNumber = measure.number ?? String(options.measureIndex + 1);
-  const attrs = getAttributesAtMeasure(result, { part: options.partIndex, measure: measureNumber });
-  const keySignature = attrs.key ?? { fifths: 0 };
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        if (!entry.pitch) {
-          return failure([operationError("NOTE_NOT_FOUND", "Note has no pitch", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-        }
-        const currentAlter = entry.pitch.alter ?? 0;
-        const newAlter = currentAlter - 1;
-        if (newAlter < -2) {
-          return failure([operationError("ACCIDENTAL_OUT_OF_BOUNDS", `Cannot lower accidental beyond double-flat (current: ${currentAlter})`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-        }
-        entry.pitch.alter = newAlter === 0 ? void 0 : newAlter;
-        const notePosition = getAbsolutePositionForNote(entry, measure);
-        const accidentalsInMeasure = getAccidentalsInMeasure(measure, notePosition, entry.voice);
-        const accidental = determineAccidental(entry.pitch, keySignature, accidentalsInMeasure);
-        if (accidental) {
-          entry.accidental = { value: accidental };
-        } else {
-          delete entry.accidental;
-        }
-        return success(result);
-      }
-      noteCount++;
-    }
-  }
-  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-}
-function addVoice(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];
-  const existingVoiceEntries = getVoiceEntries(measure, options.voice, options.staff);
-  if (existingVoiceEntries.length > 0) {
-    return failure([operationError(
-      "NOTE_CONFLICT",
-      `Voice ${options.voice} already exists in this measure`,
-      { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: options.voice }
-    )]);
-  }
-  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
-  const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
-  const rest = createRest(measureDuration, options.voice, options.staff);
-  const currentEnd = getMeasureEndPosition(measure);
-  if (currentEnd > 0) {
-    measure.entries.push({ _id: generateId(), type: "backup", duration: currentEnd });
-  }
-  measure.entries.push(rest);
-  return success(result);
-}
-function transposePitch(pitch, semitones) {
-  const currentSemitone = STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0) + pitch.octave * 12;
-  const targetSemitone = currentSemitone + semitones;
-  const targetOctave = Math.floor(targetSemitone / 12);
-  const targetPitchClass = (targetSemitone % 12 + 12) % 12;
-  let bestStep = "C";
-  let bestAlter = 99;
-  for (const step of STEPS) {
-    const stepSemitone = STEP_SEMITONES[step];
-    let diff = targetPitchClass - stepSemitone;
-    if (diff > 6) diff -= 12;
-    if (diff < -6) diff += 12;
-    if (diff >= -2 && diff <= 2) {
-      if (Math.abs(diff) < Math.abs(bestAlter)) {
-        bestStep = step;
-        bestAlter = diff;
-      }
-    }
-  }
-  return {
-    step: bestStep,
-    octave: targetOctave,
-    alter: bestAlter !== 0 ? bestAlter : void 0
-  };
-}
-function transpose(score, semitones) {
-  if (semitones === 0) return success(score);
-  const result = cloneScore(score);
-  for (const part of result.parts) {
-    for (const measure of part.measures) {
-      for (const entry of measure.entries) {
-        if (entry.type === "note" && entry.pitch) {
-          entry.pitch = transposePitch(entry.pitch, semitones);
-        }
-      }
-    }
-  }
-  return success(result);
-}
-function addPart(score, options) {
-  if (score.parts.find((p) => p.id === options.id)) {
-    return failure([operationError("DUPLICATE_PART_ID", `Part ID "${options.id}" already exists`, { partId: options.id })]);
-  }
-  const result = cloneScore(score);
-  const insertIndex = options.insertIndex ?? result.parts.length;
-  const partInfo = {
-    _id: generateId(),
-    type: "score-part",
-    id: options.id,
-    name: options.name,
-    abbreviation: options.abbreviation
-  };
-  let partListInsertIndex = result.partList.length;
-  let partCount = 0;
-  for (let i = 0; i < result.partList.length; i++) {
-    if (result.partList[i].type === "score-part") {
-      if (partCount === insertIndex) {
-        partListInsertIndex = i;
-        break;
-      }
-      partCount++;
-    }
-  }
-  result.partList.splice(partListInsertIndex, 0, partInfo);
-  const measureCount = result.parts.length > 0 ? result.parts[0].measures.length : 1;
-  const newPart = { _id: generateId(), id: options.id, measures: [] };
-  for (let i = 0; i < measureCount; i++) {
-    const measureNumber = result.parts.length > 0 ? result.parts[0].measures[i]?.number ?? String(i + 1) : String(i + 1);
-    const measure = { _id: generateId(), number: measureNumber, entries: [] };
-    if (i === 0) {
-      measure.attributes = {
-        divisions: options.divisions ?? 4,
-        time: options.time ?? { beats: "4", beatType: 4 },
-        key: options.key ?? { fifths: 0 },
-        clef: options.clef ? [options.clef] : [{ sign: "G", line: 2 }]
-      };
-    }
-    newPart.measures.push(measure);
-  }
-  result.parts.splice(insertIndex, 0, newPart);
-  const validationResult = validate(result, { checkPartReferences: true, checkPartStructure: true });
-  if (!validationResult.valid) {
-    return failure(validationResult.errors);
-  }
-  return success(result, validationResult.warnings);
-}
-function removePart(score, partId) {
-  const partIndex = score.parts.findIndex((p) => p.id === partId);
-  if (partIndex === -1) {
-    return failure([operationError("PART_NOT_FOUND", `Part "${partId}" not found`, { partId })]);
-  }
-  if (score.parts.length <= 1) {
-    return failure([operationError("PART_NOT_FOUND", "Cannot remove the only remaining part", { partId })]);
-  }
-  const result = cloneScore(score);
-  result.parts.splice(partIndex, 1);
-  const partListIndex = result.partList.findIndex((e) => e.type === "score-part" && e.id === partId);
-  if (partListIndex !== -1) {
-    result.partList.splice(partListIndex, 1);
-  }
-  return success(result);
-}
-function duplicatePart(score, options) {
-  const sourceIndex = score.parts.findIndex((p) => p.id === options.sourcePartId);
-  if (sourceIndex === -1) {
-    return failure([operationError("PART_NOT_FOUND", `Source part "${options.sourcePartId}" not found`, { partId: options.sourcePartId })]);
-  }
-  if (score.parts.find((p) => p.id === options.newPartId)) {
-    return failure([operationError("DUPLICATE_PART_ID", `Part ID "${options.newPartId}" already exists`, { partId: options.newPartId })]);
-  }
-  const result = cloneScore(score);
-  const sourcePart = result.parts[sourceIndex];
-  const newPart = clonePartWithNewIds(sourcePart);
-  newPart.id = options.newPartId;
-  const sourcePartInfo = result.partList.find((e) => e.type === "score-part" && e.id === options.sourcePartId);
-  const newPartInfo = {
-    _id: generateId(),
-    type: "score-part",
-    id: options.newPartId,
-    name: options.newPartName ?? sourcePartInfo?.name,
-    abbreviation: sourcePartInfo?.abbreviation
-  };
-  result.parts.splice(sourceIndex + 1, 0, newPart);
-  const partListSourceIndex = result.partList.findIndex((e) => e.type === "score-part" && e.id === options.sourcePartId);
-  if (partListSourceIndex !== -1) {
-    result.partList.splice(partListSourceIndex + 1, 0, newPartInfo);
-  } else {
-    result.partList.push(newPartInfo);
-  }
-  return success(result);
-}
-function setStaves(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 })]);
-  }
-  if (options.staves < 1) {
-    return failure([operationError("INVALID_STAFF", `Staves count must be at least 1`, { partIndex: options.partIndex })]);
-  }
-  const result = cloneScore(score);
-  const part = result.parts[options.partIndex];
-  const fromMeasureIndex = options.fromMeasure ?? 0;
-  const measure = part.measures[fromMeasureIndex];
-  if (!measure) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${fromMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: fromMeasureIndex })]);
-  }
-  if (!measure.attributes) {
-    measure.attributes = {};
-  }
-  measure.attributes.staves = options.staves;
-  if (options.clefs) {
-    measure.attributes.clef = options.clefs;
-  } else {
-    const existingClefs = measure.attributes.clef ?? [];
-    const newClefs = [...existingClefs];
-    for (let staff = existingClefs.length + 1; staff <= options.staves; staff++) {
-      newClefs.push(staff === 2 ? { sign: "F", line: 4, staff } : { sign: "G", line: 2, staff });
-    }
-    measure.attributes.clef = newClefs;
-  }
-  const validationResult = validate(result, { checkVoiceStaff: true, checkStaffStructure: true });
-  if (!validationResult.valid) {
-    return failure(validationResult.errors);
-  }
-  return success(result, validationResult.warnings);
-}
-function moveNoteToStaff(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.targetStaff < 1) {
-    return failure([operationError("INVALID_STAFF", `Target staff must be at least 1`, { 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.staff = options.targetStaff;
-        const context = getMeasureContext(result, options.partIndex, options.measureIndex);
-        const errors = validateMeasureLocal(measure, context, { 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"));
-      }
-      noteCount++;
-    }
-  }
-  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-}
-function changeKey(score, key, options) {
-  const result = cloneScore(score);
-  const targetMeasure = String(options.fromMeasure);
-  for (const part of result.parts) {
-    for (const measure of part.measures) {
-      if (measure.number === targetMeasure) {
-        if (!measure.attributes) measure.attributes = {};
-        measure.attributes.key = key;
-      }
-    }
-  }
-  return result;
-}
-function changeTime(score, time, options) {
-  const result = cloneScore(score);
-  const targetMeasure = String(options.fromMeasure);
-  for (const part of result.parts) {
-    for (const measure of part.measures) {
-      if (measure.number === targetMeasure) {
-        if (!measure.attributes) measure.attributes = {};
-        measure.attributes.time = time;
-      }
-    }
-  }
-  return result;
-}
-function insertMeasure(score, options) {
-  const result = cloneScore(score);
-  const targetMeasure = String(options.afterMeasure);
-  for (const part of result.parts) {
-    const insertIndex = part.measures.findIndex((m) => m.number === targetMeasure);
-    if (insertIndex === -1) continue;
-    const numericPart = parseInt(targetMeasure, 10);
-    const newMeasureNumber = String(isNaN(numericPart) ? insertIndex + 2 : numericPart + 1);
-    const newMeasure = { _id: generateId(), 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++) {
-      const currentNum = parseInt(part.measures[i].number, 10);
-      if (!isNaN(currentNum)) {
-        part.measures[i].number = String(currentNum + 1);
-      }
-    }
-  }
-  return result;
-}
-function deleteMeasure(score, measureNumber) {
-  const result = cloneScore(score);
-  const targetMeasure = String(measureNumber);
-  for (const part of result.parts) {
-    const deleteIndex = part.measures.findIndex((m) => m.number === targetMeasure);
-    if (deleteIndex === -1) continue;
-    part.measures.splice(deleteIndex, 1);
-    for (let i = deleteIndex; i < part.measures.length; i++) {
-      const currentNum = parseInt(part.measures[i].number, 10);
-      if (!isNaN(currentNum)) {
-        part.measures[i].number = String(currentNum - 1);
-      }
-    }
-  }
-  return result;
-}
-function findNoteByIndex(measure, noteIndex) {
-  let noteCount = 0;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === noteIndex) {
-        return { note: entry, entryIndex: i };
-      }
-      noteCount++;
-    }
-  }
-  return null;
-}
-function pitchesEqual(p1, p2) {
-  return p1.step === p2.step && p1.octave === p2.octave && (p1.alter ?? 0) === (p2.alter ?? 0);
-}
-function addTie(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.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  if (options.endMeasureIndex < 0 || options.endMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  const result = cloneScore(score);
-  const startMeasure = result.parts[options.partIndex].measures[options.startMeasureIndex];
-  const endMeasure = result.parts[options.partIndex].measures[options.endMeasureIndex];
-  const startResult = findNoteByIndex(startMeasure, options.startNoteIndex);
-  if (!startResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Start note index ${options.startNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  const endResult = findNoteByIndex(endMeasure, options.endNoteIndex);
-  if (!endResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `End note index ${options.endNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  const startNote = startResult.note;
-  const endNote = endResult.note;
-  if (!startNote.pitch || !endNote.pitch) {
-    return failure([operationError("TIE_INVALID_TARGET", "Cannot tie notes without pitch", { partIndex: options.partIndex })]);
-  }
-  if (!pitchesEqual(startNote.pitch, endNote.pitch)) {
-    return failure([operationError("TIE_PITCH_MISMATCH", "Tied notes must have the same pitch", { partIndex: options.partIndex }, { startPitch: startNote.pitch, endPitch: endNote.pitch })]);
-  }
-  if (startNote.tie?.type === "start" || startNote.tie?.type === "continue") {
-    return failure([operationError("TIE_ALREADY_EXISTS", "Start note already has a tie start", { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  startNote.tie = { type: "start" };
-  if (!startNote.notations) startNote.notations = [];
-  startNote.notations.push({ type: "tied", tiedType: "start" });
-  endNote.tie = { type: "stop" };
-  if (!endNote.notations) endNote.notations = [];
-  endNote.notations.push({ type: "tied", tiedType: "stop" });
-  const validationResult = validate(result, { checkTies: true });
-  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
-  if (criticalErrors.length > 0) {
-    return failure(criticalErrors);
-  }
-  return success(result, validationResult.warnings);
-}
-function removeTie(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];
-  const noteResult = findNoteByIndex(measure, options.noteIndex);
-  if (!noteResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = noteResult.note;
-  if (!note.tie) {
-    return failure([operationError("TIE_NOT_FOUND", "Note does not have a tie", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  delete note.tie;
-  delete note.ties;
-  if (note.notations) {
-    note.notations = note.notations.filter((n) => n.type !== "tied");
-    if (note.notations.length === 0) {
-      delete note.notations;
-    }
-  }
-  return success(result);
-}
-function addSlur(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.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  if (options.endMeasureIndex < 0 || options.endMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  const result = cloneScore(score);
-  const startMeasure = result.parts[options.partIndex].measures[options.startMeasureIndex];
-  const endMeasure = result.parts[options.partIndex].measures[options.endMeasureIndex];
-  const startResult = findNoteByIndex(startMeasure, options.startNoteIndex);
-  if (!startResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Start note index ${options.startNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  const endResult = findNoteByIndex(endMeasure, options.endNoteIndex);
-  if (!endResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `End note index ${options.endNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  const startNote = startResult.note;
-  const endNote = endResult.note;
-  const slurNumber = options.number ?? 1;
-  if (startNote.notations?.some((n) => n.type === "slur" && n.slurType === "start" && (n.number ?? 1) === slurNumber)) {
-    return failure([operationError("SLUR_ALREADY_EXISTS", `Slur ${slurNumber} already starts on this note`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  if (!startNote.notations) startNote.notations = [];
-  startNote.notations.push({
-    type: "slur",
-    slurType: "start",
-    number: slurNumber,
-    placement: options.placement
-  });
-  if (!endNote.notations) endNote.notations = [];
-  endNote.notations.push({
-    type: "slur",
-    slurType: "stop",
-    number: slurNumber
-  });
-  const validationResult = validate(result, { checkSlurs: true });
-  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
-  if (criticalErrors.length > 0) {
-    return failure(criticalErrors);
-  }
-  return success(result, validationResult.warnings);
-}
-function removeSlur(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];
-  const noteResult = findNoteByIndex(measure, options.noteIndex);
-  if (!noteResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = noteResult.note;
-  const slurNumber = options.number ?? 1;
-  if (!note.notations?.some((n) => n.type === "slur" && (n.number ?? 1) === slurNumber)) {
-    return failure([operationError("SLUR_NOT_FOUND", `Slur ${slurNumber} not found on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  note.notations = note.notations.filter((n) => !(n.type === "slur" && (n.number ?? 1) === slurNumber));
-  if (note.notations.length === 0) {
-    delete note.notations;
-  }
-  return success(result);
-}
-function addArticulation(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];
-  const noteResult = findNoteByIndex(measure, options.noteIndex);
-  if (!noteResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = noteResult.note;
-  if (note.notations?.some((n) => n.type === "articulation" && n.articulation === options.articulation)) {
-    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Articulation ${options.articulation} already exists on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (!note.notations) note.notations = [];
-  note.notations.push({
-    type: "articulation",
-    articulation: options.articulation,
-    placement: options.placement
-  });
-  return success(result);
-}
-function removeArticulation(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];
-  const noteResult = findNoteByIndex(measure, options.noteIndex);
-  if (!noteResult) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = noteResult.note;
-  if (!note.notations?.some((n) => n.type === "articulation" && n.articulation === options.articulation)) {
-    return failure([operationError("ARTICULATION_NOT_FOUND", `Articulation ${options.articulation} not found on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  note.notations = note.notations.filter((n) => !(n.type === "articulation" && n.articulation === options.articulation));
-  if (note.notations.length === 0) {
-    delete note.notations;
-  }
-  return success(result);
-}
-function getInsertPositionForDirection(measure, targetPosition) {
-  let position = 0;
-  let insertIndex = 0;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (position >= targetPosition) {
-      return insertIndex;
-    }
-    if (entry.type === "note" && !entry.chord) {
-      position += entry.duration;
-    } else if (entry.type === "backup") {
-      position -= entry.duration;
-    } else if (entry.type === "forward") {
-      position += entry.duration;
-    }
-    insertIndex = i + 1;
-  }
-  return insertIndex;
-}
-function addDynamics(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.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 directionEntry = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "dynamics",
-      value: options.dynamics
-    }],
-    placement: options.placement ?? "below",
-    staff: options.staff
-  };
-  const insertIndex = getInsertPositionForDirection(measure, options.position);
-  measure.entries.splice(insertIndex, 0, directionEntry);
-  return success(result);
-}
-function removeDynamics(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 directionCount = 0;
-  let targetIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction") {
-      const hasDynamics = entry.directionTypes.some((dt) => dt.kind === "dynamics");
-      if (hasDynamics) {
-        if (directionCount === options.directionIndex) {
-          targetIndex = i;
-          break;
-        }
-        directionCount++;
-      }
-    }
-  }
-  if (targetIndex === -1) {
-    return failure([operationError("DYNAMICS_NOT_FOUND", `Dynamics direction index ${options.directionIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  measure.entries.splice(targetIndex, 1);
-  return success(result);
-}
-function modifyDynamics(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 dynamicsCount = 0;
-  let targetIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction") {
-      const hasDynamics = entry.directionTypes.some((dt) => dt.kind === "dynamics");
-      if (hasDynamics) {
-        if (dynamicsCount === options.directionIndex) {
-          targetIndex = i;
-          break;
-        }
-        dynamicsCount++;
-      }
-    }
-  }
-  if (targetIndex === -1) {
-    return failure([operationError("DYNAMICS_NOT_FOUND", `Dynamics direction index ${options.directionIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const direction = measure.entries[targetIndex];
-  const dynamicsType = direction.directionTypes.find((dt) => dt.kind === "dynamics");
-  if (dynamicsType && dynamicsType.kind === "dynamics") {
-    dynamicsType.value = options.dynamics;
-  }
-  if (options.placement !== void 0) {
-    direction.placement = options.placement;
-  }
-  return success(result);
-}
-function insertClefChange(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.position < 0) {
-    return failure([operationError("INVALID_POSITION", "Position cannot be negative", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const validSigns = ["G", "F", "C", "percussion", "TAB"];
-  if (!validSigns.includes(options.clef.sign)) {
-    return failure([operationError("INVALID_CLEF", `Invalid clef sign: ${options.clef.sign}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[options.partIndex].measures[options.measureIndex];
-  if (options.position === 0) {
-    if (!measure.attributes) {
-      measure.attributes = {};
-    }
-    const staff = options.clef.staff ?? 1;
-    if (!measure.attributes.clef) {
-      measure.attributes.clef = [];
-    }
-    const existingIndex = measure.attributes.clef.findIndex((c) => (c.staff ?? 1) === staff);
-    if (existingIndex >= 0) {
-      measure.attributes.clef[existingIndex] = options.clef;
-    } else {
-      measure.attributes.clef.push(options.clef);
-    }
-  } else {
-    const attributesEntry = {
-      _id: generateId(),
-      type: "attributes",
-      attributes: {
-        clef: [options.clef]
-      }
-    };
-    const insertIndex = getInsertPositionForDirection(measure, options.position);
-    measure.entries.splice(insertIndex, 0, attributesEntry);
-  }
-  const validationResult = validate(result, { checkStaffStructure: true });
-  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
-  if (criticalErrors.length > 0) {
-    return failure(criticalErrors);
-  }
-  return success(result, validationResult.warnings);
-}
-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;
-};
-var addNoteChecked = (score, options) => {
-  return 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
-  });
-};
-var deleteNoteChecked = removeNote;
-var addChordNoteChecked = (score, options) => {
-  return addChord(score, { ...options, noteIndex: options.afterNoteIndex });
-};
-var modifyNotePitchChecked = setNotePitch;
-var modifyNoteDurationChecked = (score, options) => {
-  return changeNoteDuration(score, { ...options, newDuration: options.duration });
-};
-var transposeChecked = transpose;
-function createTuplet(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.noteCount < 2) {
-    return failure([operationError("INVALID_DURATION", "Tuplet must contain at least 2 notes", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (options.actualNotes < 2 || options.normalNotes < 1) {
-    return failure([operationError("INVALID_DURATION", "Invalid tuplet ratio", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[options.partIndex].measures[options.measureIndex];
-  const notes = [];
-  let noteCount = 0;
-  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.startNoteIndex && noteCount < options.startNoteIndex + options.noteCount) {
-        notes.push({ note: entry, entryIndex: i });
-      }
-      noteCount++;
-    }
-  }
-  if (notes.length !== options.noteCount) {
-    return failure([operationError("NOTE_NOT_FOUND", `Could not find ${options.noteCount} notes starting at index ${options.startNoteIndex}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const voice = notes[0].note.voice;
-  const staff = notes[0].note.staff;
-  if (!notes.every((n) => n.note.voice === voice)) {
-    return failure([operationError("NOTE_CONFLICT", "All notes in a tuplet must be in the same voice", { partIndex: options.partIndex, measureIndex: options.measureIndex, voice })]);
-  }
-  if (!notes.every((n) => n.note.staff === staff)) {
-    return failure([operationError("NOTE_CONFLICT", "All notes in a tuplet must be on the same staff", { partIndex: options.partIndex, measureIndex: options.measureIndex, staff })]);
-  }
-  const tupletNumber = 1;
-  for (let i = 0; i < notes.length; i++) {
-    const { note } = notes[i];
-    note.timeModification = {
-      actualNotes: options.actualNotes,
-      normalNotes: options.normalNotes
-    };
-    if (!note.notations) note.notations = [];
-    if (i === 0) {
-      note.notations.push({
-        type: "tuplet",
-        tupletType: "start",
-        number: tupletNumber,
-        bracket: options.bracket ?? true,
-        showNumber: options.showNumber ?? "actual",
-        tupletActual: { tupletNumber: options.actualNotes },
-        tupletNormal: { tupletNumber: options.normalNotes }
-      });
-    } else if (i === notes.length - 1) {
-      note.notations.push({
-        type: "tuplet",
-        tupletType: "stop",
-        number: tupletNumber
-      });
-    }
-  }
-  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
-  const errors = validateMeasureLocal(measure, context, {
-    checkTuplets: true,
-    checkMeasureDuration: 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 removeTuplet(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 targetNote = null;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        targetNote = entry;
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (!targetNote || targetEntryIndex === -1) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (!targetNote.timeModification) {
-    return failure([operationError("NOTE_NOT_FOUND", "Note is not part of a tuplet", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const voice = targetNote.voice;
-  const staff = targetNote.staff;
-  const actualNotes = targetNote.timeModification.actualNotes;
-  const normalNotes = targetNote.timeModification.normalNotes;
-  const tupletNotes = [];
-  let inTuplet = false;
-  let currentTupletNumber;
-  for (const entry of measure.entries) {
-    if (entry.type !== "note" || entry.rest) continue;
-    if (entry.voice !== voice || entry.staff !== staff) continue;
-    const hasSameTimeModification = entry.timeModification?.actualNotes === actualNotes && entry.timeModification?.normalNotes === normalNotes;
-    const tupletStart = entry.notations?.find(
-      (n) => n.type === "tuplet" && n.tupletType === "start"
-    );
-    const tupletStop = entry.notations?.find(
-      (n) => n.type === "tuplet" && n.tupletType === "stop" && (currentTupletNumber === void 0 || n.number === currentTupletNumber)
-    );
-    if (tupletStart && tupletStart.type === "tuplet") {
-      inTuplet = true;
-      currentTupletNumber = tupletStart.number;
-    }
-    if (inTuplet && hasSameTimeModification) {
-      tupletNotes.push(entry);
-    }
-    if (tupletStop && inTuplet) {
-      if (tupletNotes.includes(targetNote)) {
-        break;
-      } else {
-        tupletNotes.length = 0;
-        inTuplet = false;
-        currentTupletNumber = void 0;
-      }
-    }
-  }
-  if (tupletNotes.length === 0) {
-    tupletNotes.push(targetNote);
-  }
-  for (const note of tupletNotes) {
-    delete note.timeModification;
-    if (note.notations) {
-      note.notations = note.notations.filter((n) => n.type !== "tuplet");
-      if (note.notations.length === 0) {
-        delete note.notations;
-      }
-    }
-  }
-  return success(result);
-}
-function addBeam(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.noteCount < 2) {
-    return failure([operationError("INVALID_DURATION", "Beam must contain at least 2 notes", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[options.partIndex].measures[options.measureIndex];
-  const beamLevel = options.beamLevel ?? 1;
-  const notes = [];
-  let noteCount = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest && !entry.chord) {
-      if (noteCount >= options.startNoteIndex && noteCount < options.startNoteIndex + options.noteCount) {
-        notes.push(entry);
-      }
-      noteCount++;
-    }
-  }
-  if (notes.length !== options.noteCount) {
-    return failure([operationError("NOTE_NOT_FOUND", `Could not find ${options.noteCount} notes starting at index ${options.startNoteIndex}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const voice = notes[0].voice;
-  if (!notes.every((n) => n.voice === voice)) {
-    return failure([operationError("NOTE_CONFLICT", "All beamed notes must be in the same voice", { partIndex: options.partIndex, measureIndex: options.measureIndex, voice })]);
-  }
-  for (let i = 0; i < notes.length; i++) {
-    const note = notes[i];
-    if (!note.beam) {
-      note.beam = [];
-    }
-    note.beam = note.beam.filter((b) => b.number !== beamLevel);
-    let beamType;
-    if (i === 0) {
-      beamType = "begin";
-    } else if (i === notes.length - 1) {
-      beamType = "end";
-    } else {
-      beamType = "continue";
-    }
-    note.beam.push({
-      number: beamLevel,
-      type: beamType
-    });
-  }
-  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
-  const errors = validateMeasureLocal(measure, context, { checkBeams: 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 removeBeam(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 targetNote = null;
-  for (const entry of measure.entries) {
-    if (entry.type === "note" && !entry.rest) {
-      if (noteCount === options.noteIndex) {
-        targetNote = entry;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (!targetNote) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (!targetNote.beam || targetNote.beam.length === 0) {
-    return failure([operationError("NOTE_NOT_FOUND", "Note is not part of a beam group", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const voice = targetNote.voice;
-  const staff = targetNote.staff;
-  const beamNotes = [];
-  let inBeam = false;
-  const targetBeamLevel = options.beamLevel ?? targetNote.beam[0]?.number ?? 1;
-  for (const entry of measure.entries) {
-    if (entry.type !== "note" || entry.rest) continue;
-    if (entry.voice !== voice || entry.staff !== staff) continue;
-    const beamInfo = entry.beam?.find((b) => b.number === targetBeamLevel);
-    if (!beamInfo) {
-      if (inBeam) {
-        break;
-      }
-      continue;
-    }
-    if (beamInfo.type === "begin") {
-      inBeam = true;
-      beamNotes.push(entry);
-    } else if (beamInfo.type === "continue") {
-      if (inBeam) beamNotes.push(entry);
-    } else if (beamInfo.type === "end") {
-      beamNotes.push(entry);
-      if (beamNotes.includes(targetNote)) {
-        break;
-      } else {
-        beamNotes.length = 0;
-        inBeam = false;
-      }
-    }
-  }
-  if (beamNotes.length === 0) {
-    beamNotes.push(targetNote);
-  }
-  for (const note of beamNotes) {
-    if (note.beam) {
-      if (options.beamLevel !== void 0) {
-        note.beam = note.beam.filter((b) => b.number !== options.beamLevel);
-      } else {
-        note.beam = [];
-      }
-      if (note.beam.length === 0) {
-        delete note.beam;
-      }
-    }
-  }
-  return success(result);
-}
-function autoBeam(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];
-  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
-  const divisions = context.divisions;
-  const time = context.time ?? { beats: "4", beatType: 4 };
-  const beatDuration = 4 / time.beatType * divisions;
-  for (const entry of measure.entries) {
-    if (entry.type === "note") {
-      delete entry.beam;
-    }
-  }
-  const notesByVoice = /* @__PURE__ */ new Map();
-  let position = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note") {
-      if (!entry.chord && !entry.rest) {
-        const voice = entry.voice ?? 1;
-        if (options.voice === void 0 || voice === options.voice) {
-          if (!notesByVoice.has(voice)) {
-            notesByVoice.set(voice, []);
-          }
-          notesByVoice.get(voice).push({ note: entry, position });
-        }
-      }
-      if (!entry.chord) {
-        position += entry.duration;
-      }
-    } else if (entry.type === "backup") {
-      position -= entry.duration;
-    } else if (entry.type === "forward") {
-      position += entry.duration;
-    }
-  }
-  for (const [, notes] of notesByVoice) {
-    const beatGroups = [];
-    let currentBeat = -1;
-    let currentGroup = [];
-    for (const { note, position: notePos } of notes) {
-      if (note.duration > beatDuration / 2) {
-        if (currentGroup.length >= 2) {
-          beatGroups.push(currentGroup);
-        }
-        currentGroup = [];
-        currentBeat = -1;
-        continue;
-      }
-      const beat = Math.floor(notePos / beatDuration);
-      if (options.groupByBeat !== false && beat !== currentBeat) {
-        if (currentGroup.length >= 2) {
-          beatGroups.push(currentGroup);
-        }
-        currentGroup = [{ note, position: notePos }];
-        currentBeat = beat;
-      } else {
-        currentGroup.push({ note, position: notePos });
-      }
-    }
-    if (currentGroup.length >= 2) {
-      beatGroups.push(currentGroup);
-    }
-    for (const group of beatGroups) {
-      for (let i = 0; i < group.length; i++) {
-        const { note } = group[i];
-        if (!note.beam) {
-          note.beam = [];
-        }
-        let beamType;
-        if (i === 0) {
-          beamType = "begin";
-        } else if (i === group.length - 1) {
-          beamType = "end";
-        } else {
-          beamType = "continue";
-        }
-        note.beam.push({
-          number: 1,
-          type: beamType
-        });
-      }
-    }
-  }
-  const errors = validateMeasureLocal(measure, context, { checkBeams: 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 copyNotes(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.startPosition >= options.endPosition) {
-    return failure([operationError("INVALID_POSITION", "Start position must be less than end position", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const measure = part.measures[options.measureIndex];
-  const copiedNotes = [];
-  let position = 0;
-  for (const entry of measure.entries) {
-    if (entry.type === "note") {
-      if (entry.voice === options.voice && (options.staff === void 0 || (entry.staff ?? 1) === options.staff)) {
-        if (!entry.chord) {
-          const noteEnd = position + entry.duration;
-          if (position < options.endPosition && noteEnd > options.startPosition) {
-            const clonedNote = cloneNoteWithNewId(entry);
-            if (clonedNote.tie) {
-            }
-            copiedNotes.push({
-              relativePosition: position - options.startPosition,
-              note: clonedNote
-            });
-          }
-          position += entry.duration;
-        } else {
-          if (copiedNotes.length > 0) {
-            const lastCopied = copiedNotes[copiedNotes.length - 1];
-            if (lastCopied.note.voice === entry.voice && (options.staff === void 0 || (lastCopied.note.staff ?? 1) === (entry.staff ?? 1))) {
-              const clonedNote = cloneNoteWithNewId(entry);
-              copiedNotes.push({
-                relativePosition: lastCopied.relativePosition,
-                note: clonedNote
-              });
-            }
-          }
-        }
-      } else if (!entry.chord) {
-        position += entry.duration;
-      }
-    } else if (entry.type === "backup") {
-      position -= entry.duration;
-    } else if (entry.type === "forward") {
-      position += entry.duration;
-    }
-  }
-  if (copiedNotes.length === 0) {
-    return failure([operationError("NOTE_NOT_FOUND", "No notes found in the specified range", { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: options.voice })]);
-  }
-  const selection = {
-    source: {
-      partIndex: options.partIndex,
-      measureIndex: options.measureIndex,
-      startPosition: options.startPosition,
-      endPosition: options.endPosition,
-      voice: options.voice,
-      staff: options.staff
-    },
-    notes: copiedNotes,
-    duration: options.endPosition - options.startPosition
-  };
-  return success(selection);
-}
-function pasteNotes(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.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 targetVoice = options.voice ?? options.selection.source.voice;
-  const targetStaff = options.staff ?? options.selection.source.staff;
-  const pasteEnd = options.position + options.selection.duration;
-  if (pasteEnd > measureDuration) {
-    return failure([operationError(
-      "EXCEEDS_MEASURE",
-      `Paste would exceed measure duration (ends at ${pasteEnd}, measure is ${measureDuration})`,
-      { partIndex: options.partIndex, measureIndex: options.measureIndex },
-      { pasteEnd, measureDuration }
-    )]);
-  }
-  const voiceEntries = getVoiceEntries(measure, targetVoice, targetStaff);
-  if (options.overwrite !== false) {
-    const entriesToKeep = voiceEntries.filter((e) => {
-      if (e.entry.type !== "note") return true;
-      const note = e.entry;
-      if (note.rest) return true;
-      return e.endPosition <= options.position || e.position >= pasteEnd;
-    });
-    const newEntries = [];
-    for (const { position, entry } of entriesToKeep) {
-      if (entry.type === "note") {
-        newEntries.push({ position, entry });
-      }
-    }
-    for (const { relativePosition, note } of options.selection.notes) {
-      const pastePosition = options.position + Math.max(0, relativePosition);
-      const newNote = cloneNoteWithNewId(note);
-      newNote.voice = targetVoice;
-      if (targetStaff !== void 0) {
-        newNote.staff = targetStaff;
-      }
-      delete newNote.tie;
-      delete newNote.ties;
-      if (newNote.notations) {
-        newNote.notations = newNote.notations.filter((n) => n.type !== "tied");
-        if (newNote.notations.length === 0) {
-          delete newNote.notations;
-        }
-      }
-      newEntries.push({ position: pastePosition, entry: newNote });
-    }
-    measure.entries = rebuildMeasureWithVoice(
-      measure,
-      targetVoice,
-      newEntries,
-      measureDuration,
-      targetStaff
-    );
-  } else {
-    const { hasNotes, conflictingNotes } = hasNotesInRange(voiceEntries, options.position, pasteEnd);
-    if (hasNotes) {
-      return failure([operationError(
-        "NOTE_CONFLICT",
-        `Paste range ${options.position}-${pasteEnd} conflicts with existing notes`,
-        { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: targetVoice },
-        { conflictingPositions: conflictingNotes.map((n) => ({ start: n.position, end: n.endPosition })) }
-      )]);
-    }
-    const existingNotes = voiceEntries.filter((e) => e.entry.type === "note").map((e) => ({ position: e.position, entry: e.entry }));
-    for (const { relativePosition, note } of options.selection.notes) {
-      const pastePosition = options.position + Math.max(0, relativePosition);
-      const newNote = cloneNoteWithNewId(note);
-      newNote.voice = targetVoice;
-      if (targetStaff !== void 0) {
-        newNote.staff = targetStaff;
-      }
-      delete newNote.tie;
-      delete newNote.ties;
-      if (newNote.notations) {
-        newNote.notations = newNote.notations.filter((n) => n.type !== "tied");
-        if (newNote.notations.length === 0) {
-          delete newNote.notations;
-        }
-      }
-      existingNotes.push({ position: pastePosition, entry: newNote });
-    }
-    measure.entries = rebuildMeasureWithVoice(
-      measure,
-      targetVoice,
-      existingNotes,
-      measureDuration,
-      targetStaff
-    );
-  }
-  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 cutNotes(score, options) {
-  const copyResult = copyNotes(score, options);
-  if (!copyResult.success) {
-    return failure(copyResult.errors);
-  }
-  const selection = copyResult.data;
-  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 voiceEntries = getVoiceEntries(measure, options.voice, options.staff);
-  const entriesToKeep = voiceEntries.filter((e) => {
-    if (e.entry.type !== "note") return true;
-    const note = e.entry;
-    if (note.rest) return true;
-    return e.endPosition <= options.startPosition || e.position >= options.endPosition;
-  });
-  const newEntries = [];
-  for (const { position, entry } of entriesToKeep) {
-    if (entry.type === "note") {
-      newEntries.push({ position, entry });
-    }
-  }
-  measure.entries = rebuildMeasureWithVoice(
-    measure,
-    options.voice,
-    newEntries,
-    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(
-    { score: result, selection },
-    errors.filter((e) => e.level !== "error")
-  );
-}
-function copyNotesMultiMeasure(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.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  if (options.endMeasureIndex < options.startMeasureIndex || options.endMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  const selection = {
-    source: {
-      partIndex: options.partIndex,
-      startMeasureIndex: options.startMeasureIndex,
-      endMeasureIndex: options.endMeasureIndex,
-      voice: options.voice,
-      staff: options.staff
-    },
-    measures: []
-  };
-  for (let measureIndex = options.startMeasureIndex; measureIndex <= options.endMeasureIndex; measureIndex++) {
-    const measure = part.measures[measureIndex];
-    const measureOffset = measureIndex - options.startMeasureIndex;
-    const copiedNotes = [];
-    let position = 0;
-    for (const entry of measure.entries) {
-      if (entry.type === "note") {
-        if (entry.voice === options.voice && (options.staff === void 0 || (entry.staff ?? 1) === options.staff)) {
-          if (!entry.chord && !entry.rest) {
-            const clonedNote = cloneNoteWithNewId(entry);
-            copiedNotes.push({
-              relativePosition: position,
-              note: clonedNote
-            });
-            position += entry.duration;
-          } else if (entry.chord && copiedNotes.length > 0) {
-            const clonedNote = cloneNoteWithNewId(entry);
-            copiedNotes.push({
-              relativePosition: copiedNotes[copiedNotes.length - 1].relativePosition,
-              note: clonedNote
-            });
-          } else if (!entry.chord) {
-            position += entry.duration;
-          }
-        } else if (!entry.chord) {
-          position += entry.duration;
-        }
-      } else if (entry.type === "backup") {
-        position -= entry.duration;
-      } else if (entry.type === "forward") {
-        position += entry.duration;
-      }
-    }
-    if (copiedNotes.length > 0) {
-      selection.measures.push({
-        measureOffset,
-        notes: copiedNotes
-      });
-    }
-  }
-  if (selection.measures.length === 0) {
-    return failure([operationError("NOTE_NOT_FOUND", "No notes found in the specified range", { partIndex: options.partIndex, voice: options.voice })]);
-  }
-  return success(selection);
-}
-function pasteNotesMultiMeasure(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];
-  const measureCount = options.selection.measures.length > 0 ? options.selection.measures[options.selection.measures.length - 1].measureOffset + 1 : 0;
-  if (options.startMeasureIndex + measureCount > part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Not enough measures to paste (need ${measureCount})`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  let result = cloneScore(score);
-  const targetVoice = options.voice ?? options.selection.source.voice;
-  const targetStaff = options.staff ?? options.selection.source.staff;
-  for (const measureData of options.selection.measures) {
-    const measureIndex = options.startMeasureIndex + measureData.measureOffset;
-    const measure = result.parts[options.partIndex].measures[measureIndex];
-    const context = getMeasureContext(result, options.partIndex, measureIndex);
-    const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
-    const voiceEntries = getVoiceEntries(measure, targetVoice, targetStaff);
-    let entriesToKeep;
-    if (options.overwrite !== false) {
-      entriesToKeep = voiceEntries.filter((e) => e.entry.type === "note" && e.entry.rest).map((e) => ({ position: e.position, entry: e.entry }));
-    } else {
-      entriesToKeep = voiceEntries.filter((e) => e.entry.type === "note").map((e) => ({ position: e.position, entry: e.entry }));
-    }
-    for (const { relativePosition, note } of measureData.notes) {
-      const newNote = cloneNoteWithNewId(note);
-      newNote.voice = targetVoice;
-      if (targetStaff !== void 0) {
-        newNote.staff = targetStaff;
-      }
-      delete newNote.tie;
-      delete newNote.ties;
-      if (newNote.notations) {
-        newNote.notations = newNote.notations.filter((n) => n.type !== "tied");
-        if (newNote.notations.length === 0) {
-          delete newNote.notations;
-        }
-      }
-      entriesToKeep.push({ position: relativePosition, entry: newNote });
-    }
-    measure.entries = rebuildMeasureWithVoice(
-      measure,
-      targetVoice,
-      entriesToKeep,
-      measureDuration,
-      targetStaff
-    );
-    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);
-}
-function addTempo(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.bpm <= 0) {
-    return failure([operationError("INVALID_DURATION", "BPM must be positive", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[options.partIndex].measures[options.measureIndex];
-  const directionTypes = [];
-  directionTypes.push({
-    kind: "metronome",
-    beatUnit: options.beatUnit ?? "quarter",
-    beatUnitDot: options.beatUnitDot,
-    perMinute: options.bpm
-  });
-  if (options.text) {
-    directionTypes.push({
-      kind: "words",
-      text: options.text,
-      fontWeight: "bold"
-    });
-  }
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes,
-    placement: options.placement ?? "above",
-    sound: { tempo: options.bpm }
-  };
-  insertDirectionAtPosition(measure, direction, options.position);
-  return success(result);
-}
-function removeTempo(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];
-  const tempoDirectionIndices = [];
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "metronome")) {
-      tempoDirectionIndices.push(i);
-    }
-  }
-  if (tempoDirectionIndices.length === 0) {
-    return failure([operationError("TEMPO_NOT_FOUND", "No tempo marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const targetIndex = options.directionIndex ?? 0;
-  if (targetIndex < 0 || targetIndex >= tempoDirectionIndices.length) {
-    return failure([operationError("TEMPO_NOT_FOUND", `Tempo direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  measure.entries.splice(tempoDirectionIndices[targetIndex], 1);
-  return success(result);
-}
-function modifyTempo(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];
-  const tempoDirectionIndices = [];
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "metronome")) {
-      tempoDirectionIndices.push(i);
-    }
-  }
-  if (tempoDirectionIndices.length === 0) {
-    return failure([operationError("TEMPO_NOT_FOUND", "No tempo marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const targetIndex = options.directionIndex ?? 0;
-  if (targetIndex < 0 || targetIndex >= tempoDirectionIndices.length) {
-    return failure([operationError("TEMPO_NOT_FOUND", `Tempo direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const direction = measure.entries[tempoDirectionIndices[targetIndex]];
-  const metronome = direction.directionTypes.find((dt) => dt.kind === "metronome");
-  if (metronome && metronome.kind === "metronome") {
-    if (options.bpm !== void 0) {
-      metronome.perMinute = options.bpm;
-    }
-    if (options.beatUnit !== void 0) {
-      metronome.beatUnit = options.beatUnit;
-    }
-    if (options.beatUnitDot !== void 0) {
-      metronome.beatUnitDot = options.beatUnitDot;
-    }
-  }
-  if (options.text !== void 0) {
-    const wordsIndex = direction.directionTypes.findIndex((dt) => dt.kind === "words");
-    if (wordsIndex >= 0) {
-      const words = direction.directionTypes[wordsIndex];
-      if (words.kind === "words") {
-        words.text = options.text;
-      }
-    } else if (options.text) {
-      direction.directionTypes.push({
-        kind: "words",
-        text: options.text,
-        fontWeight: "bold"
-      });
-    }
-  }
-  if (options.bpm !== void 0 && direction.sound) {
-    direction.sound.tempo = options.bpm;
-  }
-  if (options.placement !== void 0) {
-    direction.placement = options.placement;
-  }
-  return success(result);
-}
-function addWedge(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.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
-  }
-  if (options.endMeasureIndex < 0 || options.endMeasureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
-  }
-  if (options.endMeasureIndex < options.startMeasureIndex || options.endMeasureIndex === options.startMeasureIndex && options.endPosition <= options.startPosition) {
-    return failure([operationError("INVALID_RANGE", "End position must be after start position", { partIndex: options.partIndex })]);
-  }
-  const result = cloneScore(score);
-  const startMeasure = result.parts[options.partIndex].measures[options.startMeasureIndex];
-  const startDirection = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "wedge",
-      type: options.type
-    }],
-    placement: options.placement ?? "below",
-    staff: options.staff
-  };
-  insertDirectionAtPosition(startMeasure, startDirection, options.startPosition);
-  const endMeasure = result.parts[options.partIndex].measures[options.endMeasureIndex];
-  const endDirection = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "wedge",
-      type: "stop"
-    }],
-    placement: options.placement ?? "below",
-    staff: options.staff
-  };
-  insertDirectionAtPosition(endMeasure, endDirection, options.endPosition);
-  return success(result);
-}
-function removeWedge(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 wedgeStarts = [];
-  for (let mi = options.measureIndex; mi < result.parts[options.partIndex].measures.length; mi++) {
-    const measure = result.parts[options.partIndex].measures[mi];
-    for (let ei = 0; ei < measure.entries.length; ei++) {
-      const entry = measure.entries[ei];
-      if (entry.type === "direction") {
-        const wedgeType = entry.directionTypes.find((dt) => dt.kind === "wedge");
-        if (wedgeType && wedgeType.kind === "wedge" && (wedgeType.type === "crescendo" || wedgeType.type === "diminuendo")) {
-          wedgeStarts.push({ measureIndex: mi, entryIndex: ei });
-        }
-      }
-    }
-    if (mi === options.measureIndex && wedgeStarts.length > 0) break;
-  }
-  if (wedgeStarts.length === 0) {
-    return failure([operationError("WEDGE_NOT_FOUND", "No wedge found starting in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const targetIndex = options.directionIndex ?? 0;
-  if (targetIndex >= wedgeStarts.length) {
-    return failure([operationError("WEDGE_NOT_FOUND", `Wedge direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const startInfo = wedgeStarts[targetIndex];
-  const startMeasure = result.parts[options.partIndex].measures[startInfo.measureIndex];
-  startMeasure.entries.splice(startInfo.entryIndex, 1);
-  for (let mi = startInfo.measureIndex; mi < result.parts[options.partIndex].measures.length; mi++) {
-    const measure = result.parts[options.partIndex].measures[mi];
-    for (let ei = 0; ei < measure.entries.length; ei++) {
-      const entry = measure.entries[ei];
-      if (entry.type === "direction") {
-        const wedgeType = entry.directionTypes.find((dt) => dt.kind === "wedge" && dt.type === "stop");
-        if (wedgeType) {
-          measure.entries.splice(ei, 1);
-          return success(result);
-        }
-      }
-    }
-  }
-  return success(result);
-}
-function addFermata(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];
-  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
-  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = notes[options.noteIndex];
-  if (note.notations?.some((n) => n.type === "fermata")) {
-    return failure([operationError("FERMATA_ALREADY_EXISTS", "Note already has a fermata", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (!note.notations) {
-    note.notations = [];
-  }
-  const fermataNotation = {
-    type: "fermata",
-    shape: options.shape ?? "normal",
-    fermataType: options.fermataType ?? "upright",
-    placement: options.placement ?? "above"
-  };
-  note.notations.push(fermataNotation);
-  return success(result);
-}
-function removeFermata(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];
-  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
-  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = notes[options.noteIndex];
-  const fermataIndex = note.notations?.findIndex((n) => n.type === "fermata");
-  if (fermataIndex === void 0 || fermataIndex === -1) {
-    return failure([operationError("FERMATA_NOT_FOUND", "Note does not have a fermata", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  note.notations.splice(fermataIndex, 1);
-  if (note.notations.length === 0) {
-    delete note.notations;
-  }
-  return success(result);
-}
-function addOrnament(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];
-  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
-  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = notes[options.noteIndex];
-  if (note.notations?.some((n) => n.type === "ornament" && n.ornament === options.ornament)) {
-    return failure([operationError("ORNAMENT_ALREADY_EXISTS", `Note already has ornament: ${options.ornament}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  if (!note.notations) {
-    note.notations = [];
-  }
-  const ornamentNotation = {
-    type: "ornament",
-    ornament: options.ornament,
-    placement: options.placement,
-    accidentalMark: options.accidentalMark
-  };
-  note.notations.push(ornamentNotation);
-  return success(result);
-}
-function removeOrnament(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];
-  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
-  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const note = notes[options.noteIndex];
-  const ornamentIndex = options.ornament ? note.notations?.findIndex((n) => n.type === "ornament" && n.ornament === options.ornament) : note.notations?.findIndex((n) => n.type === "ornament");
-  if (ornamentIndex === void 0 || ornamentIndex === -1) {
-    return failure([operationError("ORNAMENT_NOT_FOUND", "Note does not have the specified ornament", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  note.notations.splice(ornamentIndex, 1);
-  if (note.notations.length === 0) {
-    delete note.notations;
-  }
-  return success(result);
-}
-function addPedal(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];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "pedal",
-      type: options.pedalType,
-      line: options.line
-    }],
-    placement: options.placement ?? "below"
-  };
-  insertDirectionAtPosition(measure, direction, options.position);
-  return success(result);
-}
-function removePedal(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];
-  const pedalIndices = [];
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "pedal")) {
-      pedalIndices.push(i);
-    }
-  }
-  if (pedalIndices.length === 0) {
-    return failure([operationError("PEDAL_NOT_FOUND", "No pedal marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const targetIndex = options.directionIndex ?? 0;
-  if (targetIndex < 0 || targetIndex >= pedalIndices.length) {
-    return failure([operationError("PEDAL_NOT_FOUND", `Pedal direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  measure.entries.splice(pedalIndices[targetIndex], 1);
-  return success(result);
-}
-function addTextDirection(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.text.trim()) {
-    return failure([operationError("INVALID_TEXT", "Text cannot be empty", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[options.partIndex].measures[options.measureIndex];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "words",
-      text: options.text,
-      fontStyle: options.fontStyle,
-      fontWeight: options.fontWeight
-    }],
-    placement: options.placement ?? "above"
-  };
-  insertDirectionAtPosition(measure, direction, options.position);
-  return success(result);
-}
-function addRehearsalMark(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];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "rehearsal",
-      text: options.text,
-      enclosure: options.enclosure ?? "square"
-    }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, 0);
-  return success(result);
-}
-function insertDirectionAtPosition(measure, direction, position) {
-  let currentPosition = 0;
-  let insertIndex = 0;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (currentPosition >= position) {
-      insertIndex = i;
-      break;
-    }
-    if (entry.type === "note" && !entry.chord) {
-      currentPosition += entry.duration;
-    } else if (entry.type === "forward") {
-      currentPosition += entry.duration;
-    } else if (entry.type === "backup") {
-      currentPosition -= entry.duration;
-    }
-    insertIndex = i + 1;
-  }
-  measure.entries.splice(insertIndex, 0, direction);
-}
-function addRepeatBarline(score, options) {
-  const { partIndex, measureIndex, direction, times } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const location = direction === "forward" ? "left" : "right";
-  const barStyle = direction === "forward" ? "heavy-light" : "light-heavy";
-  for (const p of result.parts) {
-    if (measureIndex >= p.measures.length) continue;
-    const measure = p.measures[measureIndex];
-    if (!measure.barlines) {
-      measure.barlines = [];
-    }
-    const existingIndex = measure.barlines.findIndex((b) => b.location === location && b.repeat);
-    if (existingIndex >= 0) {
-      return failure([operationError("REPEAT_ALREADY_EXISTS", `Repeat barline already exists at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
-    }
-    const nonRepeatIndex = measure.barlines.findIndex((b) => b.location === location && !b.repeat);
-    if (nonRepeatIndex >= 0) {
-      measure.barlines.splice(nonRepeatIndex, 1);
-    }
-    measure.barlines.push({
-      _id: generateId(),
-      location,
-      barStyle,
-      repeat: {
-        direction,
-        times
-      }
-    });
-  }
-  return success(result);
-}
-function removeRepeatBarline(score, options) {
-  const { partIndex, measureIndex, location } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  if (!measure.barlines) {
-    return failure([operationError("REPEAT_NOT_FOUND", `No repeat barline found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
-  }
-  const existingIndex = measure.barlines.findIndex((b) => b.location === location && b.repeat);
-  if (existingIndex < 0) {
-    return failure([operationError("REPEAT_NOT_FOUND", `No repeat barline found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  for (const p of result.parts) {
-    if (measureIndex >= p.measures.length) continue;
-    const m = p.measures[measureIndex];
-    if (m.barlines) {
-      const idx = m.barlines.findIndex((b) => b.location === location && b.repeat);
-      if (idx >= 0) {
-        m.barlines.splice(idx, 1);
-      }
-      if (m.barlines.length === 0) {
-        delete m.barlines;
-      }
-    }
-  }
-  return success(result);
-}
-function addEnding(score, options) {
-  const { partIndex, measureIndex, number, type } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const location = type === "start" ? "left" : "right";
-  for (const p of result.parts) {
-    if (measureIndex >= p.measures.length) continue;
-    const measure = p.measures[measureIndex];
-    if (!measure.barlines) {
-      measure.barlines = [];
-    }
-    let barline = measure.barlines.find((b) => b.location === location);
-    if (!barline) {
-      barline = { _id: generateId(), location };
-      measure.barlines.push(barline);
-    }
-    if (barline.ending) {
-      return failure([operationError("ENDING_ALREADY_EXISTS", `Ending already exists at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
-    }
-    barline.ending = { number, type };
-  }
-  return success(result);
-}
-function removeEnding(score, options) {
-  const { partIndex, measureIndex, location } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  const barline = measure.barlines?.find((b) => b.location === location && b.ending);
-  if (!barline) {
-    return failure([operationError("ENDING_NOT_FOUND", `No ending found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  for (const p of result.parts) {
-    if (measureIndex >= p.measures.length) continue;
-    const m = p.measures[measureIndex];
-    if (m.barlines) {
-      const bl = m.barlines.find((b) => b.location === location);
-      if (bl) {
-        delete bl.ending;
-        if (!bl.barStyle && !bl.repeat && !bl.ending) {
-          const idx = m.barlines.indexOf(bl);
-          m.barlines.splice(idx, 1);
-        }
-      }
-      if (m.barlines.length === 0) {
-        delete m.barlines;
-      }
-    }
-  }
-  return success(result);
-}
-function changeBarline(score, options) {
-  const { partIndex, measureIndex, location, barStyle } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  for (const p of result.parts) {
-    if (measureIndex >= p.measures.length) continue;
-    const measure = p.measures[measureIndex];
-    if (!measure.barlines) {
-      measure.barlines = [];
-    }
-    let barline = measure.barlines.find((b) => b.location === location);
-    if (!barline) {
-      barline = { _id: generateId(), location };
-      measure.barlines.push(barline);
-    }
-    barline.barStyle = barStyle;
-  }
-  return success(result);
-}
-function addSegno(score, options) {
-  const { partIndex, measureIndex, position = 0 } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "segno" }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, position);
-  return success(result);
-}
-function addCoda(score, options) {
-  const { partIndex, measureIndex, position = 0 } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "coda" }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, position);
-  return success(result);
-}
-function addDaCapo(score, options) {
-  const { partIndex, measureIndex, position } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
-  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
-  const insertPos = position ?? measureDuration;
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "words", text: "D.C." }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, insertPos);
-  const sound = {
-    _id: generateId(),
-    type: "sound",
-    dacapo: true
-  };
-  measure.entries.push(sound);
-  return success(result);
-}
-function addDalSegno(score, options) {
-  const { partIndex, measureIndex, position } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
-  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
-  const insertPos = position ?? measureDuration;
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "words", text: "D.S." }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, insertPos);
-  const sound = {
-    _id: generateId(),
-    type: "sound",
-    dalsegno: "segno"
-  };
-  measure.entries.push(sound);
-  return success(result);
-}
-function addFine(score, options) {
-  const { partIndex, measureIndex, position } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
-  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
-  const insertPos = position ?? measureDuration;
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "words", text: "Fine" }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, insertPos);
-  const sound = {
-    _id: generateId(),
-    type: "sound",
-    fine: true
-  };
-  measure.entries.push(sound);
-  return success(result);
-}
-function addToCoda(score, options) {
-  const { partIndex, measureIndex, position } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
-  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
-  const insertPos = position ?? measureDuration;
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{ kind: "words", text: "To Coda" }],
-    placement: "above"
-  };
-  insertDirectionAtPosition(measure, direction, insertPos);
-  const sound = {
-    _id: generateId(),
-    type: "sound",
-    tocoda: "coda"
-  };
-  measure.entries.push(sound);
-  return success(result);
-}
-function addGraceNote(score, options) {
-  const { partIndex, measureIndex, targetNoteIndex, pitch, noteType = "eighth", slash = true, voice, staff } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  let targetNote = null;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord) {
-      if (noteCount === targetNoteIndex) {
-        targetEntryIndex = i;
-        targetNote = entry;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0 || !targetNote) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${targetNoteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultMeasure = result.parts[partIndex].measures[measureIndex];
-  const graceNote = {
-    _id: generateId(),
-    type: "note",
-    pitch,
-    duration: 0,
-    // Grace notes have no duration
-    voice: voice ?? targetNote.voice,
-    staff: staff ?? targetNote.staff,
-    noteType,
-    grace: {
-      slash
-    }
-  };
-  resultMeasure.entries.splice(targetEntryIndex, 0, graceNote);
-  return success(result);
-}
-function removeGraceNote(score, options) {
-  const { partIndex, measureIndex, graceNoteIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let graceCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && entry.grace) {
-      if (graceCount === graceNoteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      graceCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("GRACE_NOTE_NOT_FOUND", `Grace note at index ${graceNoteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
-  return success(result);
-}
-function convertToGrace(score, options) {
-  const { partIndex, measureIndex, noteIndex, slash = true } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note") {
-    return failure([operationError("NOTE_NOT_FOUND", `Entry at index is not a note`, { partIndex, measureIndex })]);
-  }
-  if (targetEntry.grace) {
-    return failure([operationError("INVALID_GRACE_NOTE", `Note is already a grace note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.grace = { slash };
-  resultNote.duration = 0;
-  return success(result);
-}
-function addLyric(score, options) {
-  const { partIndex, measureIndex, noteIndex, text, syllabic = "single", verse = 1, extend = false } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note") {
-    return failure([operationError("NOTE_NOT_FOUND", `Entry is not a note`, { partIndex, measureIndex })]);
-  }
-  if (targetEntry.lyrics?.some((l) => l.number === verse)) {
-    return failure([operationError("LYRIC_ALREADY_EXISTS", `Lyric for verse ${verse} already exists on this note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.lyrics) {
-    resultNote.lyrics = [];
-  }
-  const lyric = {
-    number: verse,
-    syllabic,
-    text,
-    extend
-  };
-  resultNote.lyrics.push(lyric);
-  return success(result);
-}
-function removeLyric(score, options) {
-  const { partIndex, measureIndex, noteIndex, verse } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.lyrics || targetEntry.lyrics.length === 0) {
-    return failure([operationError("LYRIC_NOT_FOUND", `No lyrics found on note`, { partIndex, measureIndex })]);
-  }
-  if (verse !== void 0) {
-    const lyricIndex = targetEntry.lyrics.findIndex((l) => l.number === verse);
-    if (lyricIndex < 0) {
-      return failure([operationError("LYRIC_NOT_FOUND", `Lyric for verse ${verse} not found on note`, { partIndex, measureIndex })]);
-    }
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (verse !== void 0) {
-    resultNote.lyrics = resultNote.lyrics.filter((l) => l.number !== verse);
-  } else {
-    delete resultNote.lyrics;
-  }
-  if (resultNote.lyrics && resultNote.lyrics.length === 0) {
-    delete resultNote.lyrics;
-  }
-  return success(result);
-}
-function updateLyric(score, options) {
-  const { partIndex, measureIndex, noteIndex, verse = 1, text, syllabic, extend } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.lyrics) {
-    return failure([operationError("LYRIC_NOT_FOUND", `No lyrics found on note`, { partIndex, measureIndex })]);
-  }
-  const lyricIndex = targetEntry.lyrics.findIndex((l) => l.number === verse);
-  if (lyricIndex < 0) {
-    return failure([operationError("LYRIC_NOT_FOUND", `Lyric for verse ${verse} not found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  const lyric = resultNote.lyrics[lyricIndex];
-  if (text !== void 0) {
-    lyric.text = text;
-  }
-  if (syllabic !== void 0) {
-    lyric.syllabic = syllabic;
-  }
-  if (extend !== void 0) {
-    lyric.extend = extend;
-  }
-  return success(result);
-}
-function addHarmony(score, options) {
-  const { partIndex, measureIndex, position, root, kind, kindText, bass, degrees, staff, placement = "above" } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const validSteps = ["A", "B", "C", "D", "E", "F", "G"];
-  if (!validSteps.includes(root.step.toUpperCase())) {
-    return failure([operationError("INVALID_HARMONY", `Invalid root step: ${root.step}`, { partIndex, measureIndex })]);
-  }
-  if (bass && !validSteps.includes(bass.step.toUpperCase())) {
-    return failure([operationError("INVALID_HARMONY", `Invalid bass step: ${bass.step}`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const harmony = {
-    _id: generateId(),
-    type: "harmony",
-    root: {
-      rootStep: root.step.toUpperCase(),
-      rootAlter: root.alter
-    },
-    kind,
-    kindText,
-    bass: bass ? {
-      bassStep: bass.step.toUpperCase(),
-      bassAlter: bass.alter
-    } : void 0,
-    degrees: degrees?.map((d) => ({
-      degreeValue: d.value,
-      degreeAlter: d.alter,
-      degreeType: d.type
-    })),
-    staff,
-    placement
-  };
-  let currentPosition = 0;
-  let insertIndex = 0;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (currentPosition >= position) {
-      insertIndex = i;
-      break;
-    }
-    if (entry.type === "note" && !entry.chord) {
-      currentPosition += entry.duration;
-    } else if (entry.type === "forward") {
-      currentPosition += entry.duration;
-    } else if (entry.type === "backup") {
-      currentPosition -= entry.duration;
-    }
-    insertIndex = i + 1;
-  }
-  measure.entries.splice(insertIndex, 0, harmony);
-  return success(result);
-}
-function removeHarmony(score, options) {
-  const { partIndex, measureIndex, harmonyIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let harmonyCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "harmony") {
-      if (harmonyCount === harmonyIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      harmonyCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("HARMONY_NOT_FOUND", `Harmony at index ${harmonyIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
-  return success(result);
-}
-function updateHarmony(score, options) {
-  const { partIndex, measureIndex, harmonyIndex, root, kind, kindText, bass, degrees } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let harmonyCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "harmony") {
-      if (harmonyCount === harmonyIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      harmonyCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("HARMONY_NOT_FOUND", `Harmony at index ${harmonyIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const validSteps = ["A", "B", "C", "D", "E", "F", "G"];
-  if (root && !validSteps.includes(root.step.toUpperCase())) {
-    return failure([operationError("INVALID_HARMONY", `Invalid root step: ${root.step}`, { partIndex, measureIndex })]);
-  }
-  if (bass && !validSteps.includes(bass.step.toUpperCase())) {
-    return failure([operationError("INVALID_HARMONY", `Invalid bass step: ${bass.step}`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const harmony = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (root) {
-    harmony.root = {
-      rootStep: root.step.toUpperCase(),
-      rootAlter: root.alter
-    };
-  }
-  if (kind !== void 0) {
-    harmony.kind = kind;
-  }
-  if (kindText !== void 0) {
-    harmony.kindText = kindText;
-  }
-  if (bass !== void 0) {
-    if (bass === null) {
-      delete harmony.bass;
-    } else {
-      harmony.bass = {
-        bassStep: bass.step.toUpperCase(),
-        bassAlter: bass.alter
-      };
-    }
-  }
-  if (degrees !== void 0) {
-    if (degrees === null) {
-      delete harmony.degrees;
-    } else {
-      harmony.degrees = degrees.map((d) => ({
-        degreeValue: d.value,
-        degreeAlter: d.alter,
-        degreeType: d.type
-      }));
-    }
-  }
-  return success(result);
-}
-function addFingering(score, options) {
-  const { partIndex, measureIndex, noteIndex, fingering, substitution = false, alternate = false, placement } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.notations) {
-    resultNote.notations = [];
-  }
-  resultNote.notations.push({
-    type: "technical",
-    technical: "fingering",
-    fingering,
-    fingeringSubstitution: substitution || void 0,
-    fingeringAlternate: alternate || void 0,
-    placement
-  });
-  return success(result);
-}
-function removeFingering(score, options) {
-  const { partIndex, measureIndex, noteIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.notations) {
-    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
-  }
-  const fingeringIndex = targetEntry.notations.findIndex(
-    (n) => n.type === "technical" && n.technical === "fingering"
-  );
-  if (fingeringIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `No fingering found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.notations.splice(fingeringIndex, 1);
-  if (resultNote.notations.length === 0) {
-    delete resultNote.notations;
-  }
-  return success(result);
-}
-function addBowing(score, options) {
-  const { partIndex, measureIndex, noteIndex, bowingType, placement } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.notations) {
-    resultNote.notations = [];
-  }
-  resultNote.notations.push({
-    type: "technical",
-    technical: bowingType,
-    placement
-  });
-  return success(result);
-}
-function removeBowing(score, options) {
-  const { partIndex, measureIndex, noteIndex, bowingType } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.notations) {
-    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
-  }
-  const bowingIndex = targetEntry.notations.findIndex((n) => {
-    if (n.type !== "technical") return false;
-    if (bowingType) return n.technical === bowingType;
-    return n.technical === "up-bow" || n.technical === "down-bow";
-  });
-  if (bowingIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `No bowing found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.notations.splice(bowingIndex, 1);
-  if (resultNote.notations.length === 0) {
-    delete resultNote.notations;
-  }
-  return success(result);
-}
-function addStringNumber(score, options) {
-  const { partIndex, measureIndex, noteIndex, stringNumber, placement } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  if (stringNumber < 1) {
-    return failure([operationError("INVALID_POSITION", `String number must be positive`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.notations) {
-    resultNote.notations = [];
-  }
-  resultNote.notations.push({
-    type: "technical",
-    technical: "string",
-    string: stringNumber,
-    placement
-  });
-  return success(result);
-}
-function removeStringNumber(score, options) {
-  const { partIndex, measureIndex, noteIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.notations) {
-    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
-  }
-  const stringIndex = targetEntry.notations.findIndex(
-    (n) => n.type === "technical" && n.technical === "string"
-  );
-  if (stringIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `No string number found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.notations.splice(stringIndex, 1);
-  if (resultNote.notations.length === 0) {
-    delete resultNote.notations;
-  }
-  return success(result);
-}
-function addOctaveShift(score, options) {
-  const { partIndex, measureIndex, position, shiftType, size = 8 } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "octave-shift",
-      type: shiftType,
-      size
-    }],
-    placement: shiftType === "down" ? "above" : "below"
-  };
-  insertDirectionAtPosition(measure, direction, position);
-  return success(result);
-}
-function stopOctaveShift(score, options) {
-  const { partIndex, measureIndex, position, size = 8 } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const measure = result.parts[partIndex].measures[measureIndex];
-  const direction = {
-    _id: generateId(),
-    type: "direction",
-    directionTypes: [{
-      kind: "octave-shift",
-      type: "stop",
-      size
-    }]
-  };
-  insertDirectionAtPosition(measure, direction, position);
-  return success(result);
-}
-function removeOctaveShift(score, options) {
-  const { partIndex, measureIndex, octaveShiftIndex = 0 } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let shiftCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "direction") {
-      const hasOctaveShift = entry.directionTypes.some((dt) => dt.kind === "octave-shift");
-      if (hasOctaveShift) {
-        if (shiftCount === octaveShiftIndex) {
-          targetEntryIndex = i;
-          break;
-        }
-        shiftCount++;
-      }
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Octave shift at index ${octaveShiftIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
-  return success(result);
-}
-function addBreathMark(score, options) {
-  const { partIndex, measureIndex, noteIndex, placement = "above" } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.notations) {
-    resultNote.notations = [];
-  }
-  const existingBreathMark = resultNote.notations.find(
-    (n) => n.type === "articulation" && n.articulation === "breath-mark"
-  );
-  if (existingBreathMark) {
-    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Breath mark already exists on note`, { partIndex, measureIndex })]);
-  }
-  resultNote.notations.push({
-    type: "articulation",
-    articulation: "breath-mark",
-    placement
-  });
-  return success(result);
-}
-function removeBreathMark(score, options) {
-  const { partIndex, measureIndex, noteIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.notations) {
-    return failure([operationError("ARTICULATION_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
-  }
-  const breathMarkIndex = targetEntry.notations.findIndex(
-    (n) => n.type === "articulation" && n.articulation === "breath-mark"
-  );
-  if (breathMarkIndex < 0) {
-    return failure([operationError("ARTICULATION_NOT_FOUND", `No breath mark found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.notations.splice(breathMarkIndex, 1);
-  if (resultNote.notations.length === 0) {
-    delete resultNote.notations;
-  }
-  return success(result);
-}
-function addCaesura(score, options) {
-  const { partIndex, measureIndex, noteIndex, placement = "above" } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  if (!resultNote.notations) {
-    resultNote.notations = [];
-  }
-  const existingCaesura = resultNote.notations.find(
-    (n) => n.type === "articulation" && n.articulation === "caesura"
-  );
-  if (existingCaesura) {
-    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Caesura already exists on note`, { partIndex, measureIndex })]);
-  }
-  resultNote.notations.push({
-    type: "articulation",
-    articulation: "caesura",
-    placement
-  });
-  return success(result);
-}
-function removeCaesura(score, options) {
-  const { partIndex, measureIndex, noteIndex } = options;
-  if (partIndex < 0 || partIndex >= score.parts.length) {
-    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
-  }
-  const part = score.parts[partIndex];
-  if (measureIndex < 0 || measureIndex >= part.measures.length) {
-    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
-  }
-  const measure = part.measures[measureIndex];
-  let noteCount = 0;
-  let targetEntryIndex = -1;
-  for (let i = 0; i < measure.entries.length; i++) {
-    const entry = measure.entries[i];
-    if (entry.type === "note" && !entry.chord && !entry.rest) {
-      if (noteCount === noteIndex) {
-        targetEntryIndex = i;
-        break;
-      }
-      noteCount++;
-    }
-  }
-  if (targetEntryIndex < 0) {
-    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
-  }
-  const targetEntry = measure.entries[targetEntryIndex];
-  if (targetEntry.type !== "note" || !targetEntry.notations) {
-    return failure([operationError("ARTICULATION_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
-  }
-  const caesuraIndex = targetEntry.notations.findIndex(
-    (n) => n.type === "articulation" && n.articulation === "caesura"
-  );
-  if (caesuraIndex < 0) {
-    return failure([operationError("ARTICULATION_NOT_FOUND", `No caesura found on note`, { partIndex, measureIndex })]);
-  }
-  const result = cloneScore(score);
-  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
-  resultNote.notations.splice(caesuraIndex, 1);
-  if (resultNote.notations.length === 0) {
-    delete resultNote.notations;
-  }
-  return success(result);
-}
-var addText = addTextDirection;
-var setBeaming = autoBeam;
-var addChordSymbol = addHarmony;
-var removeChordSymbol = removeHarmony;
-var updateChordSymbol = updateHarmony;
-var changeClef = insertClefChange;
-var setBarline = changeBarline;
-var addRepeat = addRepeatBarline;
-var removeRepeat = removeRepeatBarline;
+import {
+  addArticulation,
+  addBeam,
+  addBowing,
+  addBreathMark,
+  addCaesura,
+  addChord,
+  addChordNote,
+  addChordNoteChecked,
+  addChordSymbol,
+  addCoda,
+  addDaCapo,
+  addDalSegno,
+  addDynamics,
+  addEnding,
+  addFermata,
+  addFine,
+  addFingering,
+  addGraceNote,
+  addHarmony,
+  addLyric,
+  addNote,
+  addNoteChecked,
+  addOctaveShift,
+  addOrnament,
+  addPart,
+  addPedal,
+  addRehearsalMark,
+  addRepeat,
+  addRepeatBarline,
+  addSegno,
+  addSlur,
+  addStringNumber,
+  addTempo,
+  addText,
+  addTextDirection,
+  addTie,
+  addToCoda,
+  addVoice,
+  addWedge,
+  autoBeam,
+  changeBarline,
+  changeClef,
+  changeKey,
+  changeNoteDuration,
+  changeTime,
+  convertToGrace,
+  copyNotes,
+  copyNotesMultiMeasure,
+  createTuplet,
+  cutNotes,
+  deleteMeasure,
+  deleteNote,
+  deleteNoteChecked,
+  duplicatePart,
+  insertClefChange,
+  insertMeasure,
+  insertNote,
+  lowerAccidental,
+  modifyDynamics,
+  modifyNoteDuration,
+  modifyNoteDurationChecked,
+  modifyNotePitch,
+  modifyNotePitchChecked,
+  modifyTempo,
+  moveNoteToStaff,
+  pasteNotes,
+  pasteNotesMultiMeasure,
+  raiseAccidental,
+  removeArticulation,
+  removeBeam,
+  removeBowing,
+  removeBreathMark,
+  removeCaesura,
+  removeChordSymbol,
+  removeDynamics,
+  removeEnding,
+  removeFermata,
+  removeFingering,
+  removeGraceNote,
+  removeHarmony,
+  removeLyric,
+  removeNote,
+  removeOctaveShift,
+  removeOrnament,
+  removePart,
+  removePedal,
+  removeRepeat,
+  removeRepeatBarline,
+  removeSlur,
+  removeStringNumber,
+  removeTempo,
+  removeTie,
+  removeTuplet,
+  removeWedge,
+  setBarline,
+  setBeaming,
+  setNotePitch,
+  setNotePitchBySemitone,
+  setStaves,
+  shiftNotePitch,
+  stopOctaveShift,
+  transpose,
+  transposeChecked,
+  updateChordSymbol,
+  updateHarmony,
+  updateLyric
+} from "../chunk-EFP2DAOK.mjs";
+import "../chunk-ZDAN74FN.mjs";
 export {
   addArticulation,
   addBeam,