musicxml-io 0.2.0 → 0.2.7

package/dist/operations/index.js

@@ -20,36 +20,110 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/operations/index.ts
 var operations_exports = {};
 __export(operations_exports, {
+  addArticulation: () => addArticulation,
+  addBeam: () => addBeam,
+  addBowing: () => addBowing,
+  addBreathMark: () => addBreathMark,
+  addCaesura: () => addCaesura,
   addChord: () => addChord,
   addChordNote: () => addChordNote,
   addChordNoteChecked: () => addChordNoteChecked,
+  addCoda: () => addCoda,
+  addDaCapo: () => addDaCapo,
+  addDalSegno: () => addDalSegno,
+  addDynamics: () => addDynamics,
+  addEnding: () => addEnding,
+  addFermata: () => addFermata,
+  addFine: () => addFine,
+  addFingering: () => addFingering,
+  addGraceNote: () => addGraceNote,
+  addHarmony: () => addHarmony,
+  addLyric: () => addLyric,
   addNote: () => addNote,
   addNoteChecked: () => addNoteChecked,
+  addOctaveShift: () => addOctaveShift,
+  addOrnament: () => addOrnament,
   addPart: () => addPart,
+  addPedal: () => addPedal,
+  addRehearsalMark: () => addRehearsalMark,
+  addRepeatBarline: () => addRepeatBarline,
+  addSegno: () => addSegno,
+  addSlur: () => addSlur,
+  addStringNumber: () => addStringNumber,
+  addTempo: () => addTempo,
+  addTextDirection: () => addTextDirection,
+  addTie: () => addTie,
+  addToCoda: () => addToCoda,
   addVoice: () => addVoice,
+  addWedge: () => addWedge,
+  autoBeam: () => autoBeam,
+  changeBarline: () => changeBarline,
   changeKey: () => changeKey,
   changeNoteDuration: () => changeNoteDuration,
   changeTime: () => changeTime,
+  convertToGrace: () => convertToGrace,
+  copyNotes: () => copyNotes,
+  copyNotesMultiMeasure: () => copyNotesMultiMeasure,
+  createTuplet: () => createTuplet,
+  cutNotes: () => cutNotes,
   deleteMeasure: () => deleteMeasure,
   deleteNote: () => deleteNote,
   deleteNoteChecked: () => deleteNoteChecked,
   duplicatePart: () => duplicatePart,
+  insertClefChange: () => insertClefChange,
   insertMeasure: () => insertMeasure,
   insertNote: () => insertNote,
+  lowerAccidental: () => lowerAccidental,
   modifyNoteDuration: () => modifyNoteDuration,
   modifyNoteDurationChecked: () => modifyNoteDurationChecked,
   modifyNotePitch: () => modifyNotePitch,
   modifyNotePitchChecked: () => modifyNotePitchChecked,
   moveNoteToStaff: () => moveNoteToStaff,
+  pasteNotes: () => pasteNotes,
+  pasteNotesMultiMeasure: () => pasteNotesMultiMeasure,
+  raiseAccidental: () => raiseAccidental,
+  removeArticulation: () => removeArticulation,
+  removeBeam: () => removeBeam,
+  removeBowing: () => removeBowing,
+  removeBreathMark: () => removeBreathMark,
+  removeCaesura: () => removeCaesura,
+  removeDynamics: () => removeDynamics,
+  removeEnding: () => removeEnding,
+  removeFermata: () => removeFermata,
+  removeFingering: () => removeFingering,
+  removeGraceNote: () => removeGraceNote,
+  removeHarmony: () => removeHarmony,
+  removeLyric: () => removeLyric,
   removeNote: () => removeNote,
+  removeOctaveShift: () => removeOctaveShift,
+  removeOrnament: () => removeOrnament,
   removePart: () => removePart,
+  removePedal: () => removePedal,
+  removeRepeatBarline: () => removeRepeatBarline,
+  removeSlur: () => removeSlur,
+  removeStringNumber: () => removeStringNumber,
+  removeTempo: () => removeTempo,
+  removeTie: () => removeTie,
+  removeTuplet: () => removeTuplet,
+  removeWedge: () => removeWedge,
   setNotePitch: () => setNotePitch,
+  setNotePitchBySemitone: () => setNotePitchBySemitone,
   setStaves: () => setStaves,
+  shiftNotePitch: () => shiftNotePitch,
+  stopOctaveShift: () => stopOctaveShift,
   transpose: () => transpose,
-  transposeChecked: () => transposeChecked
+  transposeChecked: () => transposeChecked,
+  updateHarmony: () => updateHarmony,
+  updateLyric: () => updateLyric
 });
 module.exports = __toCommonJS(operations_exports);
 
+// src/id.ts
+var import_nanoid = require("nanoid");
+function generateId() {
+  return "i" + (0, import_nanoid.nanoid)(10);
+}
+
 // src/utils/index.ts
 var STEPS = ["C", "D", "E", "F", "G", "A", "B"];
 var STEP_SEMITONES = {
@@ -61,6 +135,128 @@ var STEP_SEMITONES = {
   "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 };
 }
@@ -87,6 +283,14 @@ function updatePositionForEntry(state, entry) {
       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);
@@ -956,6 +1160,27 @@ function getMeasureContext(score, partIndex, 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 };
@@ -975,6 +1200,34 @@ function operationError(code, 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;
@@ -1037,6 +1290,7 @@ function hasNotesInRange(voiceEntries, startPos, endPos) {
 }
 function createRest(duration, voice, staff) {
   return {
+    _id: generateId(),
     type: "note",
     rest: { displayStep: void 0, displayOctave: void 0 },
     duration,
@@ -1098,10 +1352,11 @@ function rebuildMeasureWithVoice(measure, voice, newEntries, measureDuration, st
   for (const { position: targetPos, entry } of allEntries) {
     const diff = targetPos - currentPosition;
     if (diff < 0) {
-      result.push({ type: "backup", duration: -diff });
+      result.push({ _id: generateId(), type: "backup", duration: -diff });
       currentPosition = targetPos;
     } else if (diff > 0) {
       result.push({
+        _id: generateId(),
         type: "forward",
         duration: diff,
         voice: entry.type === "note" ? entry.voice : 1,
@@ -1156,6 +1411,7 @@ function insertNote(score, options) {
     )]);
   }
   const newNote = {
+    _id: generateId(),
     type: "note",
     pitch: options.pitch,
     duration: options.duration,
@@ -1262,6 +1518,7 @@ function addChord(score, options) {
     return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
   }
   const chordNote = {
+    _id: generateId(),
     type: "note",
     pitch: options.pitch,
     duration: targetEntry.duration,
@@ -1412,6 +1669,161 @@ function setNotePitch(score, options) {
   }
   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 })]);
@@ -1435,7 +1847,7 @@ function addVoice(score, options) {
   const rest = createRest(measureDuration, options.voice, options.staff);
   const currentEnd = getMeasureEndPosition(measure);
   if (currentEnd > 0) {
-    measure.entries.push({ type: "backup", duration: currentEnd });
+    measure.entries.push({ _id: generateId(), type: "backup", duration: currentEnd });
   }
   measure.entries.push(rest);
   return success(result);
@@ -1486,6 +1898,7 @@ function addPart(score, options) {
   const result = cloneScore(score);
   const insertIndex = options.insertIndex ?? result.parts.length;
   const partInfo = {
+    _id: generateId(),
     type: "score-part",
     id: options.id,
     name: options.name,
@@ -1504,10 +1917,10 @@ function addPart(score, options) {
   }
   result.partList.splice(partListInsertIndex, 0, partInfo);
   const measureCount = result.parts.length > 0 ? result.parts[0].measures.length : 1;
-  const newPart = { id: options.id, measures: [] };
+  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 = { number: measureNumber, entries: [] };
+    const measure = { _id: generateId(), number: measureNumber, entries: [] };
     if (i === 0) {
       measure.attributes = {
         divisions: options.divisions ?? 4,
@@ -1551,10 +1964,11 @@ function duplicatePart(score, options) {
   }
   const result = cloneScore(score);
   const sourcePart = result.parts[sourceIndex];
-  const newPart = JSON.parse(JSON.stringify(sourcePart));
+  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,
@@ -1668,7 +2082,7 @@ function insertMeasure(score, options) {
     if (insertIndex === -1) continue;
     const numericPart = parseInt(targetMeasure, 10);
     const newMeasureNumber = String(isNaN(numericPart) ? insertIndex + 2 : numericPart + 1);
-    const newMeasure = { number: newMeasureNumber, entries: [] };
+    const newMeasure = { _id: generateId(), number: newMeasureNumber, entries: [] };
     if (options.copyAttributes && part.measures[insertIndex].attributes) {
       newMeasure.attributes = { ...part.measures[insertIndex].attributes };
     }
@@ -1698,85 +2112,2827 @@ function deleteMeasure(score, measureNumber) {
   }
   return result;
 }
-var addNote = (score, options) => {
-  const result = insertNote(score, {
-    partIndex: options.partIndex,
-    measureIndex: options.measureIndex,
-    voice: options.voice,
-    staff: options.staff,
-    position: options.position,
-    pitch: options.note.pitch ?? { step: "C", octave: 4 },
-    duration: options.note.duration,
-    noteType: options.note.noteType,
-    dots: options.note.dots
+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
   });
-  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
+  if (!endNote.notations) endNote.notations = [];
+  endNote.notations.push({
+    type: "slur",
+    slurType: "stop",
+    number: slurNumber
   });
-};
-var deleteNoteChecked = removeNote;
-var addChordNoteChecked = (score, options) => {
-  return addChord(score, { ...options, noteIndex: options.afterNoteIndex });
-};
-var modifyNotePitchChecked = setNotePitch;
-var modifyNoteDurationChecked = (score, options) => {
+  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 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;
+        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 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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addArticulation,
+  addBeam,
+  addBowing,
+  addBreathMark,
+  addCaesura,
   addChord,
   addChordNote,
   addChordNoteChecked,
+  addCoda,
+  addDaCapo,
+  addDalSegno,
+  addDynamics,
+  addEnding,
+  addFermata,
+  addFine,
+  addFingering,
+  addGraceNote,
+  addHarmony,
+  addLyric,
   addNote,
   addNoteChecked,
+  addOctaveShift,
+  addOrnament,
   addPart,
+  addPedal,
+  addRehearsalMark,
+  addRepeatBarline,
+  addSegno,
+  addSlur,
+  addStringNumber,
+  addTempo,
+  addTextDirection,
+  addTie,
+  addToCoda,
   addVoice,
+  addWedge,
+  autoBeam,
+  changeBarline,
   changeKey,
   changeNoteDuration,
   changeTime,
+  convertToGrace,
+  copyNotes,
+  copyNotesMultiMeasure,
+  createTuplet,
+  cutNotes,
   deleteMeasure,
   deleteNote,
   deleteNoteChecked,
   duplicatePart,
+  insertClefChange,
   insertMeasure,
   insertNote,
+  lowerAccidental,
   modifyNoteDuration,
   modifyNoteDurationChecked,
   modifyNotePitch,
   modifyNotePitchChecked,
   moveNoteToStaff,
+  pasteNotes,
+  pasteNotesMultiMeasure,
+  raiseAccidental,
+  removeArticulation,
+  removeBeam,
+  removeBowing,
+  removeBreathMark,
+  removeCaesura,
+  removeDynamics,
+  removeEnding,
+  removeFermata,
+  removeFingering,
+  removeGraceNote,
+  removeHarmony,
+  removeLyric,
   removeNote,
+  removeOctaveShift,
+  removeOrnament,
   removePart,
+  removePedal,
+  removeRepeatBarline,
+  removeSlur,
+  removeStringNumber,
+  removeTempo,
+  removeTie,
+  removeTuplet,
+  removeWedge,
   setNotePitch,
+  setNotePitchBySemitone,
   setStaves,
+  shiftNotePitch,
+  stopOctaveShift,
   transpose,
-  transposeChecked
+  transposeChecked,
+  updateHarmony,
+  updateLyric
 });