musicxml-io 0.2.8 → 0.2.11

package/dist/index.mjs

@@ -3552,8 +3552,10 @@ function serializeSystemLayout(layout, indent) {
 }
 function serializeCredit(credit, indent) {
   const lines = [];
-  const pageAttr = credit.page !== void 0 ? ` page="${credit.page}"` : "";
-  lines.push(`${indent}<credit${pageAttr}>`);
+  let attrs = "";
+  if (credit._id) attrs += ` id="${escapeXml(credit._id)}"`;
+  if (credit.page !== void 0) attrs += ` page="${credit.page}"`;
+  lines.push(`${indent}<credit${attrs}>`);
   if (credit.creditType) {
     for (const ct of credit.creditType) {
       lines.push(`${indent}${indent}<credit-type>${escapeXml(ct)}</credit-type>`);
@@ -3561,19 +3563,19 @@ function serializeCredit(credit, indent) {
   }
   if (credit.creditWords) {
     for (const cw of credit.creditWords) {
-      let attrs = "";
-      if (cw.defaultX !== void 0) attrs += ` default-x="${cw.defaultX}"`;
-      if (cw.defaultY !== void 0) attrs += ` default-y="${cw.defaultY}"`;
-      if (cw.fontSize) attrs += ` font-size="${escapeXml(cw.fontSize)}"`;
-      if (cw.fontWeight) attrs += ` font-weight="${escapeXml(cw.fontWeight)}"`;
-      if (cw.fontStyle) attrs += ` font-style="${escapeXml(cw.fontStyle)}"`;
-      if (cw.justify) attrs += ` justify="${escapeXml(cw.justify)}"`;
-      if (cw.halign) attrs += ` halign="${escapeXml(cw.halign)}"`;
-      if (cw.valign) attrs += ` valign="${escapeXml(cw.valign)}"`;
-      if (cw.letterSpacing) attrs += ` letter-spacing="${escapeXml(cw.letterSpacing)}"`;
-      if (cw.xmlLang) attrs += ` xml:lang="${escapeXml(cw.xmlLang)}"`;
-      if (cw.xmlSpace) attrs += ` xml:space="${escapeXml(cw.xmlSpace)}"`;
-      lines.push(`${indent}${indent}<credit-words${attrs}>${escapeXml(cw.text)}</credit-words>`);
+      let attrs2 = "";
+      if (cw.defaultX !== void 0) attrs2 += ` default-x="${cw.defaultX}"`;
+      if (cw.defaultY !== void 0) attrs2 += ` default-y="${cw.defaultY}"`;
+      if (cw.fontSize) attrs2 += ` font-size="${escapeXml(cw.fontSize)}"`;
+      if (cw.fontWeight) attrs2 += ` font-weight="${escapeXml(cw.fontWeight)}"`;
+      if (cw.fontStyle) attrs2 += ` font-style="${escapeXml(cw.fontStyle)}"`;
+      if (cw.justify) attrs2 += ` justify="${escapeXml(cw.justify)}"`;
+      if (cw.halign) attrs2 += ` halign="${escapeXml(cw.halign)}"`;
+      if (cw.valign) attrs2 += ` valign="${escapeXml(cw.valign)}"`;
+      if (cw.letterSpacing) attrs2 += ` letter-spacing="${escapeXml(cw.letterSpacing)}"`;
+      if (cw.xmlLang) attrs2 += ` xml:lang="${escapeXml(cw.xmlLang)}"`;
+      if (cw.xmlSpace) attrs2 += ` xml:space="${escapeXml(cw.xmlSpace)}"`;
+      lines.push(`${indent}${indent}<credit-words${attrs2}>${escapeXml(cw.text)}</credit-words>`);
     }
   }
   lines.push(`${indent}</credit>`);
@@ -3693,6 +3695,7 @@ function serializePartGroup(group, indent) {
   const lines = [];
   let attrs = ` type="${group.groupType}"`;
   if (group.number !== void 0) attrs += ` number="${group.number}"`;
+  if (group._id) attrs += ` id="${escapeXml(group._id)}"`;
   lines.push(`${indent}<part-group${attrs}>`);
   if (group.groupName) {
     lines.push(`${indent}  <group-name>${escapeXml(group.groupName)}</group-name>`);
@@ -3733,6 +3736,7 @@ function serializePart(part, indent) {
 function serializeMeasure(measure, indent) {
   const lines = [];
   let attrs = ` number="${measure.number}"`;
+  if (measure._id) attrs += ` id="${escapeXml(measure._id)}"`;
   if (measure.width !== void 0) attrs += ` width="${measure.width}"`;
   if (measure.implicit) attrs += ` implicit="yes"`;
   lines.push(`${indent}<measure${attrs}>`);
@@ -3807,9 +3811,10 @@ function serializePrint(print, indent) {
   lines.push(`${indent}</print>`);
   return lines;
 }
-function serializeAttributes(attrs, indent) {
+function serializeAttributes(attrs, indent, id) {
   const lines = [];
-  lines.push(`${indent}<attributes>`);
+  const idAttr = id ? ` id="${escapeXml(id)}"` : "";
+  lines.push(`${indent}<attributes${idAttr}>`);
   if (attrs.divisions !== void 0) {
     lines.push(`${indent}  <divisions>${attrs.divisions}</divisions>`);
   }
@@ -3957,7 +3962,7 @@ function serializeEntry(entry, indent) {
     case "sound":
       return serializeSound(entry, indent);
     case "attributes":
-      return serializeAttributes(entry.attributes, indent);
+      return serializeAttributes(entry.attributes, indent, entry._id);
     default:
       return [];
   }
@@ -3965,6 +3970,7 @@ function serializeEntry(entry, indent) {
 function serializeNote(note, indent) {
   const lines = [];
   const noteAttrs = buildAttrs({
+    "id": note._id,
     "default-x": note.defaultX,
     "default-y": note.defaultY,
     "relative-x": note.relativeX,
@@ -4447,7 +4453,8 @@ function serializeBackup(backup, indent) {
 }
 function serializeForward(forward, indent) {
   const lines = [];
-  lines.push(`${indent}<forward>`);
+  const idAttr = forward._id ? ` id="${escapeXml(forward._id)}"` : "";
+  lines.push(`${indent}<forward${idAttr}>`);
   lines.push(`${indent}  <duration>${forward.duration}</duration>`);
   if (forward.voice !== void 0) {
     lines.push(`${indent}  <voice>${forward.voice}</voice>`);
@@ -4461,6 +4468,7 @@ function serializeForward(forward, indent) {
 function serializeDirection(direction, indent) {
   const lines = [];
   let attrs = "";
+  if (direction._id) attrs += ` id="${escapeXml(direction._id)}"`;
   if (direction.placement) attrs += ` placement="${direction.placement}"`;
   if (direction.directive) attrs += ' directive="yes"';
   if (direction.system) attrs += ` system="${direction.system}"`;
@@ -4722,7 +4730,9 @@ function serializeDirectionType(dirType, indent) {
 }
 function serializeBarline(barline, indent) {
   const lines = [];
-  lines.push(`${indent}<barline location="${barline.location}">`);
+  let attrs = ` location="${barline.location}"`;
+  if (barline._id) attrs += ` id="${escapeXml(barline._id)}"`;
+  lines.push(`${indent}<barline${attrs}>`);
   if (barline.barStyle) {
     lines.push(`${indent}  <bar-style>${barline.barStyle}</bar-style>`);
   }
@@ -4815,6 +4825,7 @@ function serializeMeasureStyle(ms, indent) {
 function serializeHarmony(harmony, indent) {
   const lines = [];
   const attrs = buildAttrs({
+    id: harmony._id,
     placement: harmony.placement,
     "print-frame": harmony.printFrame,
     "default-y": harmony.defaultY,
@@ -4892,6 +4903,7 @@ function serializeHarmony(harmony, indent) {
 function serializeFiguredBass(fb, indent) {
   const lines = [];
   let attrs = "";
+  if (fb._id) attrs += ` id="${escapeXml(fb._id)}"`;
   if (fb.parentheses) attrs += ' parentheses="yes"';
   lines.push(`${indent}<figured-bass${attrs}>`);
   for (const fig of fb.figures) {
@@ -4923,6 +4935,7 @@ function serializeFiguredBass(fb, indent) {
 function serializeSound(sound, indent) {
   const lines = [];
   const attrs = [];
+  if (sound._id) attrs.push(`id="${escapeXml(sound._id)}"`);
   if (sound.tempo !== void 0) attrs.push(`tempo="${sound.tempo}"`);
   if (sound.dynamics !== void 0) attrs.push(`dynamics="${sound.dynamics}"`);
   if (sound.dacapo) attrs.push('dacapo="yes"');
@@ -4954,7 +4967,7 @@ function serializeSound(sound, indent) {
     }
     lines.push(`${indent}  </swing>`);
     lines.push(`${indent}</sound>`);
-  } else if (attrs.length === 0) {
+  } else if (attrs.length === 0 && !sound._id) {
     lines.push(`${indent}<sound/>`);
   } else {
     lines.push(`${indent}<sound${attrStr}/>`);
@@ -5340,9 +5353,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 };
 }
@@ -6950,6 +7082,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;
@@ -7391,6 +7551,189 @@ 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 })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const existingVoiceEntries = getVoiceEntries(measure, options.voice, options.staff);
+  if (existingVoiceEntries.length > 0) {
+    return failure([operationError(
+      "NOTE_CONFLICT",
+      `Voice ${options.voice} already exists in this measure`,
+      { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: options.voice }
+    )]);
+  }
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
+  const rest = createRest(measureDuration, options.voice, options.staff);
+  const currentEnd = getMeasureEndPosition(measure);
+  if (currentEnd > 0) {
+    measure.entries.push({ _id: generateId(), type: "backup", duration: currentEnd });
+  }
+  measure.entries.push(rest);
+  return success(result);
+}
 function transposePitch(pitch, semitones) {
   const currentSemitone = STEP_SEMITONES[pitch.step] + (pitch.alter ?? 0) + pitch.octave * 12;
   const targetSemitone = currentSemitone + semitones;
@@ -7430,6 +7773,163 @@ function transpose(score, semitones) {
   }
   return success(result);
 }
+function addPart(score, options) {
+  if (score.parts.find((p) => p.id === options.id)) {
+    return failure([operationError("DUPLICATE_PART_ID", `Part ID "${options.id}" already exists`, { partId: options.id })]);
+  }
+  const result = cloneScore(score);
+  const insertIndex = options.insertIndex ?? result.parts.length;
+  const partInfo = {
+    _id: generateId(),
+    type: "score-part",
+    id: options.id,
+    name: options.name,
+    abbreviation: options.abbreviation
+  };
+  let partListInsertIndex = result.partList.length;
+  let partCount = 0;
+  for (let i = 0; i < result.partList.length; i++) {
+    if (result.partList[i].type === "score-part") {
+      if (partCount === insertIndex) {
+        partListInsertIndex = i;
+        break;
+      }
+      partCount++;
+    }
+  }
+  result.partList.splice(partListInsertIndex, 0, partInfo);
+  const measureCount = result.parts.length > 0 ? result.parts[0].measures.length : 1;
+  const newPart = { _id: generateId(), id: options.id, measures: [] };
+  for (let i = 0; i < measureCount; i++) {
+    const measureNumber = result.parts.length > 0 ? result.parts[0].measures[i]?.number ?? String(i + 1) : String(i + 1);
+    const measure = { _id: generateId(), number: measureNumber, entries: [] };
+    if (i === 0) {
+      measure.attributes = {
+        divisions: options.divisions ?? 4,
+        time: options.time ?? { beats: "4", beatType: 4 },
+        key: options.key ?? { fifths: 0 },
+        clef: options.clef ? [options.clef] : [{ sign: "G", line: 2 }]
+      };
+    }
+    newPart.measures.push(measure);
+  }
+  result.parts.splice(insertIndex, 0, newPart);
+  const validationResult = validate(result, { checkPartReferences: true, checkPartStructure: true });
+  if (!validationResult.valid) {
+    return failure(validationResult.errors);
+  }
+  return success(result, validationResult.warnings);
+}
+function removePart(score, partId) {
+  const partIndex = score.parts.findIndex((p) => p.id === partId);
+  if (partIndex === -1) {
+    return failure([operationError("PART_NOT_FOUND", `Part "${partId}" not found`, { partId })]);
+  }
+  if (score.parts.length <= 1) {
+    return failure([operationError("PART_NOT_FOUND", "Cannot remove the only remaining part", { partId })]);
+  }
+  const result = cloneScore(score);
+  result.parts.splice(partIndex, 1);
+  const partListIndex = result.partList.findIndex((e) => e.type === "score-part" && e.id === partId);
+  if (partListIndex !== -1) {
+    result.partList.splice(partListIndex, 1);
+  }
+  return success(result);
+}
+function duplicatePart(score, options) {
+  const sourceIndex = score.parts.findIndex((p) => p.id === options.sourcePartId);
+  if (sourceIndex === -1) {
+    return failure([operationError("PART_NOT_FOUND", `Source part "${options.sourcePartId}" not found`, { partId: options.sourcePartId })]);
+  }
+  if (score.parts.find((p) => p.id === options.newPartId)) {
+    return failure([operationError("DUPLICATE_PART_ID", `Part ID "${options.newPartId}" already exists`, { partId: options.newPartId })]);
+  }
+  const result = cloneScore(score);
+  const sourcePart = result.parts[sourceIndex];
+  const newPart = clonePartWithNewIds(sourcePart);
+  newPart.id = options.newPartId;
+  const sourcePartInfo = result.partList.find((e) => e.type === "score-part" && e.id === options.sourcePartId);
+  const newPartInfo = {
+    _id: generateId(),
+    type: "score-part",
+    id: options.newPartId,
+    name: options.newPartName ?? sourcePartInfo?.name,
+    abbreviation: sourcePartInfo?.abbreviation
+  };
+  result.parts.splice(sourceIndex + 1, 0, newPart);
+  const partListSourceIndex = result.partList.findIndex((e) => e.type === "score-part" && e.id === options.sourcePartId);
+  if (partListSourceIndex !== -1) {
+    result.partList.splice(partListSourceIndex + 1, 0, newPartInfo);
+  } else {
+    result.partList.push(newPartInfo);
+  }
+  return success(result);
+}
+function setStaves(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  if (options.staves < 1) {
+    return failure([operationError("INVALID_STAFF", `Staves count must be at least 1`, { partIndex: options.partIndex })]);
+  }
+  const result = cloneScore(score);
+  const part = result.parts[options.partIndex];
+  const fromMeasureIndex = options.fromMeasure ?? 0;
+  const measure = part.measures[fromMeasureIndex];
+  if (!measure) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${fromMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: fromMeasureIndex })]);
+  }
+  if (!measure.attributes) {
+    measure.attributes = {};
+  }
+  measure.attributes.staves = options.staves;
+  if (options.clefs) {
+    measure.attributes.clef = options.clefs;
+  } else {
+    const existingClefs = measure.attributes.clef ?? [];
+    const newClefs = [...existingClefs];
+    for (let staff = existingClefs.length + 1; staff <= options.staves; staff++) {
+      newClefs.push(staff === 2 ? { sign: "F", line: 4, staff } : { sign: "G", line: 2, staff });
+    }
+    measure.attributes.clef = newClefs;
+  }
+  const validationResult = validate(result, { checkVoiceStaff: true, checkStaffStructure: true });
+  if (!validationResult.valid) {
+    return failure(validationResult.errors);
+  }
+  return success(result, validationResult.warnings);
+}
+function moveNoteToStaff(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.targetStaff < 1) {
+    return failure([operationError("INVALID_STAFF", `Target staff must be at least 1`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && !entry.rest) {
+      if (noteCount === options.noteIndex) {
+        entry.staff = options.targetStaff;
+        const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+        const errors = validateMeasureLocal(measure, context, { checkVoiceStaff: true });
+        const criticalErrors = errors.filter((e) => e.level === "error");
+        if (criticalErrors.length > 0) {
+          return failure(criticalErrors);
+        }
+        return success(result, errors.filter((e) => e.level !== "error"));
+      }
+      noteCount++;
+    }
+  }
+  return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+}
 function changeKey(score, key, options) {
   const result = cloneScore(score);
   const targetMeasure = String(options.fromMeasure);
@@ -7494,36 +7994,2839 @@ 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
-  });
-  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;
-};
+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 pitchesEqual2(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 (!pitchesEqual2(startNote.pitch, endNote.pitch)) {
+    return failure([operationError("TIE_PITCH_MISMATCH", "Tied notes must have the same pitch", { partIndex: options.partIndex }, { startPitch: startNote.pitch, endPitch: endNote.pitch })]);
+  }
+  if (startNote.tie?.type === "start" || startNote.tie?.type === "continue") {
+    return failure([operationError("TIE_ALREADY_EXISTS", "Start note already has a tie start", { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  startNote.tie = { type: "start" };
+  if (!startNote.notations) startNote.notations = [];
+  startNote.notations.push({ type: "tied", tiedType: "start" });
+  endNote.tie = { type: "stop" };
+  if (!endNote.notations) endNote.notations = [];
+  endNote.notations.push({ type: "tied", tiedType: "stop" });
+  const validationResult = validate(result, { checkTies: true });
+  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, validationResult.warnings);
+}
+function removeTie(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const noteResult = findNoteByIndex(measure, options.noteIndex);
+  if (!noteResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = noteResult.note;
+  if (!note.tie) {
+    return failure([operationError("TIE_NOT_FOUND", "Note does not have a tie", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  delete note.tie;
+  delete note.ties;
+  if (note.notations) {
+    note.notations = note.notations.filter((n) => n.type !== "tied");
+    if (note.notations.length === 0) {
+      delete note.notations;
+    }
+  }
+  return success(result);
+}
+function addSlur(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  if (options.endMeasureIndex < 0 || options.endMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
+  }
+  const result = cloneScore(score);
+  const startMeasure = result.parts[options.partIndex].measures[options.startMeasureIndex];
+  const endMeasure = result.parts[options.partIndex].measures[options.endMeasureIndex];
+  const startResult = findNoteByIndex(startMeasure, options.startNoteIndex);
+  if (!startResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `Start note index ${options.startNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  const endResult = findNoteByIndex(endMeasure, options.endNoteIndex);
+  if (!endResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `End note index ${options.endNoteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
+  }
+  const startNote = startResult.note;
+  const endNote = endResult.note;
+  const slurNumber = options.number ?? 1;
+  if (startNote.notations?.some((n) => n.type === "slur" && n.slurType === "start" && (n.number ?? 1) === slurNumber)) {
+    return failure([operationError("SLUR_ALREADY_EXISTS", `Slur ${slurNumber} already starts on this note`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  if (!startNote.notations) startNote.notations = [];
+  startNote.notations.push({
+    type: "slur",
+    slurType: "start",
+    number: slurNumber,
+    placement: options.placement
+  });
+  if (!endNote.notations) endNote.notations = [];
+  endNote.notations.push({
+    type: "slur",
+    slurType: "stop",
+    number: slurNumber
+  });
+  const validationResult = validate(result, { checkSlurs: true });
+  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, validationResult.warnings);
+}
+function removeSlur(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const noteResult = findNoteByIndex(measure, options.noteIndex);
+  if (!noteResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = noteResult.note;
+  const slurNumber = options.number ?? 1;
+  if (!note.notations?.some((n) => n.type === "slur" && (n.number ?? 1) === slurNumber)) {
+    return failure([operationError("SLUR_NOT_FOUND", `Slur ${slurNumber} not found on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  note.notations = note.notations.filter((n) => !(n.type === "slur" && (n.number ?? 1) === slurNumber));
+  if (note.notations.length === 0) {
+    delete note.notations;
+  }
+  return success(result);
+}
+function addArticulation(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const noteResult = findNoteByIndex(measure, options.noteIndex);
+  if (!noteResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = noteResult.note;
+  if (note.notations?.some((n) => n.type === "articulation" && n.articulation === options.articulation)) {
+    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Articulation ${options.articulation} already exists on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!note.notations) note.notations = [];
+  note.notations.push({
+    type: "articulation",
+    articulation: options.articulation,
+    placement: options.placement
+  });
+  return success(result);
+}
+function removeArticulation(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const noteResult = findNoteByIndex(measure, options.noteIndex);
+  if (!noteResult) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = noteResult.note;
+  if (!note.notations?.some((n) => n.type === "articulation" && n.articulation === options.articulation)) {
+    return failure([operationError("ARTICULATION_NOT_FOUND", `Articulation ${options.articulation} not found on this note`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  note.notations = note.notations.filter((n) => !(n.type === "articulation" && n.articulation === options.articulation));
+  if (note.notations.length === 0) {
+    delete note.notations;
+  }
+  return success(result);
+}
+function getInsertPositionForDirection(measure, targetPosition) {
+  let position = 0;
+  let insertIndex = 0;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (position >= targetPosition) {
+      return insertIndex;
+    }
+    if (entry.type === "note" && !entry.chord) {
+      position += entry.duration;
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      position += entry.duration;
+    }
+    insertIndex = i + 1;
+  }
+  return insertIndex;
+}
+function addDynamics(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.position < 0) {
+    return failure([operationError("INVALID_POSITION", "Position cannot be negative", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const directionEntry = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "dynamics",
+      value: options.dynamics
+    }],
+    placement: options.placement ?? "below",
+    staff: options.staff
+  };
+  const insertIndex = getInsertPositionForDirection(measure, options.position);
+  measure.entries.splice(insertIndex, 0, directionEntry);
+  return success(result);
+}
+function removeDynamics(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let directionCount = 0;
+  let targetIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction") {
+      const hasDynamics = entry.directionTypes.some((dt) => dt.kind === "dynamics");
+      if (hasDynamics) {
+        if (directionCount === options.directionIndex) {
+          targetIndex = i;
+          break;
+        }
+        directionCount++;
+      }
+    }
+  }
+  if (targetIndex === -1) {
+    return failure([operationError("DYNAMICS_NOT_FOUND", `Dynamics direction index ${options.directionIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  measure.entries.splice(targetIndex, 1);
+  return success(result);
+}
+function modifyDynamics(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let dynamicsCount = 0;
+  let targetIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction") {
+      const hasDynamics = entry.directionTypes.some((dt) => dt.kind === "dynamics");
+      if (hasDynamics) {
+        if (dynamicsCount === options.directionIndex) {
+          targetIndex = i;
+          break;
+        }
+        dynamicsCount++;
+      }
+    }
+  }
+  if (targetIndex === -1) {
+    return failure([operationError("DYNAMICS_NOT_FOUND", `Dynamics direction index ${options.directionIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const direction = measure.entries[targetIndex];
+  const dynamicsType = direction.directionTypes.find((dt) => dt.kind === "dynamics");
+  if (dynamicsType && dynamicsType.kind === "dynamics") {
+    dynamicsType.value = options.dynamics;
+  }
+  if (options.placement !== void 0) {
+    direction.placement = options.placement;
+  }
+  return success(result);
+}
+function insertClefChange(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.position < 0) {
+    return failure([operationError("INVALID_POSITION", "Position cannot be negative", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const validSigns = ["G", "F", "C", "percussion", "TAB"];
+  if (!validSigns.includes(options.clef.sign)) {
+    return failure([operationError("INVALID_CLEF", `Invalid clef sign: ${options.clef.sign}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  if (options.position === 0) {
+    if (!measure.attributes) {
+      measure.attributes = {};
+    }
+    const staff = options.clef.staff ?? 1;
+    if (!measure.attributes.clef) {
+      measure.attributes.clef = [];
+    }
+    const existingIndex = measure.attributes.clef.findIndex((c) => (c.staff ?? 1) === staff);
+    if (existingIndex >= 0) {
+      measure.attributes.clef[existingIndex] = options.clef;
+    } else {
+      measure.attributes.clef.push(options.clef);
+    }
+  } else {
+    const attributesEntry = {
+      _id: generateId(),
+      type: "attributes",
+      attributes: {
+        clef: [options.clef]
+      }
+    };
+    const insertIndex = getInsertPositionForDirection(measure, options.position);
+    measure.entries.splice(insertIndex, 0, attributesEntry);
+  }
+  const validationResult = validate(result, { checkStaffStructure: true });
+  const criticalErrors = validationResult.errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, validationResult.warnings);
+}
+var addNote = (score, options) => {
+  const result = insertNote(score, {
+    partIndex: options.partIndex,
+    measureIndex: options.measureIndex,
+    voice: options.voice,
+    staff: options.staff,
+    position: options.position,
+    pitch: options.note.pitch ?? { step: "C", octave: 4 },
+    duration: options.note.duration,
+    noteType: options.note.noteType,
+    dots: options.note.dots
+  });
+  return result.success ? result.data : score;
+};
+var deleteNote = (score, options) => {
+  const result = removeNote(score, options);
+  return result.success ? result.data : score;
+};
+var addChordNote = (score, options) => {
+  const result = addChord(score, { ...options, noteIndex: options.afterNoteIndex });
+  return result.success ? result.data : score;
+};
+var modifyNotePitch = (score, options) => {
+  const result = setNotePitch(score, options);
+  return result.success ? result.data : score;
+};
+var modifyNoteDuration = (score, options) => {
+  const result = changeNoteDuration(score, { ...options, newDuration: options.duration });
+  return result.success ? result.data : score;
+};
+var addNoteChecked = (score, options) => {
+  return insertNote(score, {
+    partIndex: options.partIndex,
+    measureIndex: options.measureIndex,
+    voice: options.voice,
+    staff: options.staff,
+    position: options.position,
+    pitch: options.note.pitch ?? { step: "C", octave: 4 },
+    duration: options.note.duration,
+    noteType: options.note.noteType,
+    dots: options.note.dots
+  });
+};
+var deleteNoteChecked = removeNote;
+var addChordNoteChecked = (score, options) => {
+  return addChord(score, { ...options, noteIndex: options.afterNoteIndex });
+};
+var modifyNotePitchChecked = setNotePitch;
+var modifyNoteDurationChecked = (score, options) => {
+  return changeNoteDuration(score, { ...options, newDuration: options.duration });
+};
+var transposeChecked = transpose;
+function createTuplet(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.noteCount < 2) {
+    return failure([operationError("INVALID_DURATION", "Tuplet must contain at least 2 notes", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.actualNotes < 2 || options.normalNotes < 1) {
+    return failure([operationError("INVALID_DURATION", "Invalid tuplet ratio", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const notes = [];
+  let noteCount = 0;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.rest && !entry.chord) {
+      if (noteCount >= options.startNoteIndex && noteCount < options.startNoteIndex + options.noteCount) {
+        notes.push({ note: entry, entryIndex: i });
+      }
+      noteCount++;
+    }
+  }
+  if (notes.length !== options.noteCount) {
+    return failure([operationError("NOTE_NOT_FOUND", `Could not find ${options.noteCount} notes starting at index ${options.startNoteIndex}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const voice = notes[0].note.voice;
+  const staff = notes[0].note.staff;
+  if (!notes.every((n) => n.note.voice === voice)) {
+    return failure([operationError("NOTE_CONFLICT", "All notes in a tuplet must be in the same voice", { partIndex: options.partIndex, measureIndex: options.measureIndex, voice })]);
+  }
+  if (!notes.every((n) => n.note.staff === staff)) {
+    return failure([operationError("NOTE_CONFLICT", "All notes in a tuplet must be on the same staff", { partIndex: options.partIndex, measureIndex: options.measureIndex, staff })]);
+  }
+  const tupletNumber = 1;
+  for (let i = 0; i < notes.length; i++) {
+    const { note } = notes[i];
+    note.timeModification = {
+      actualNotes: options.actualNotes,
+      normalNotes: options.normalNotes
+    };
+    if (!note.notations) note.notations = [];
+    if (i === 0) {
+      note.notations.push({
+        type: "tuplet",
+        tupletType: "start",
+        number: tupletNumber,
+        bracket: options.bracket ?? true,
+        showNumber: options.showNumber ?? "actual",
+        tupletActual: { tupletNumber: options.actualNotes },
+        tupletNormal: { tupletNumber: options.normalNotes }
+      });
+    } else if (i === notes.length - 1) {
+      note.notations.push({
+        type: "tuplet",
+        tupletType: "stop",
+        number: tupletNumber
+      });
+    }
+  }
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const errors = validateMeasureLocal(measure, context, {
+    checkTuplets: true,
+    checkMeasureDuration: true
+  });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, errors.filter((e) => e.level !== "error"));
+}
+function removeTuplet(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  let targetNote = null;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.rest) {
+      if (noteCount === options.noteIndex) {
+        targetNote = entry;
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (!targetNote || targetEntryIndex === -1) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!targetNote.timeModification) {
+    return failure([operationError("NOTE_NOT_FOUND", "Note is not part of a tuplet", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const voice = targetNote.voice;
+  const staff = targetNote.staff;
+  const actualNotes = targetNote.timeModification.actualNotes;
+  const normalNotes = targetNote.timeModification.normalNotes;
+  const tupletNotes = [];
+  let inTuplet = false;
+  let currentTupletNumber;
+  for (const entry of measure.entries) {
+    if (entry.type !== "note" || entry.rest) continue;
+    if (entry.voice !== voice || entry.staff !== staff) continue;
+    const hasSameTimeModification = entry.timeModification?.actualNotes === actualNotes && entry.timeModification?.normalNotes === normalNotes;
+    const tupletStart = entry.notations?.find(
+      (n) => n.type === "tuplet" && n.tupletType === "start"
+    );
+    const tupletStop = entry.notations?.find(
+      (n) => n.type === "tuplet" && n.tupletType === "stop" && (currentTupletNumber === void 0 || n.number === currentTupletNumber)
+    );
+    if (tupletStart && tupletStart.type === "tuplet") {
+      inTuplet = true;
+      currentTupletNumber = tupletStart.number;
+    }
+    if (inTuplet && hasSameTimeModification) {
+      tupletNotes.push(entry);
+    }
+    if (tupletStop && inTuplet) {
+      if (tupletNotes.includes(targetNote)) {
+        break;
+      } else {
+        tupletNotes.length = 0;
+        inTuplet = false;
+        currentTupletNumber = void 0;
+      }
+    }
+  }
+  if (tupletNotes.length === 0) {
+    tupletNotes.push(targetNote);
+  }
+  for (const note of tupletNotes) {
+    delete note.timeModification;
+    if (note.notations) {
+      note.notations = note.notations.filter((n) => n.type !== "tuplet");
+      if (note.notations.length === 0) {
+        delete note.notations;
+      }
+    }
+  }
+  return success(result);
+}
+function addBeam(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.noteCount < 2) {
+    return failure([operationError("INVALID_DURATION", "Beam must contain at least 2 notes", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const beamLevel = options.beamLevel ?? 1;
+  const notes = [];
+  let noteCount = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && !entry.rest && !entry.chord) {
+      if (noteCount >= options.startNoteIndex && noteCount < options.startNoteIndex + options.noteCount) {
+        notes.push(entry);
+      }
+      noteCount++;
+    }
+  }
+  if (notes.length !== options.noteCount) {
+    return failure([operationError("NOTE_NOT_FOUND", `Could not find ${options.noteCount} notes starting at index ${options.startNoteIndex}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const voice = notes[0].voice;
+  if (!notes.every((n) => n.voice === voice)) {
+    return failure([operationError("NOTE_CONFLICT", "All beamed notes must be in the same voice", { partIndex: options.partIndex, measureIndex: options.measureIndex, voice })]);
+  }
+  for (let i = 0; i < notes.length; i++) {
+    const note = notes[i];
+    if (!note.beam) {
+      note.beam = [];
+    }
+    note.beam = note.beam.filter((b) => b.number !== beamLevel);
+    let beamType;
+    if (i === 0) {
+      beamType = "begin";
+    } else if (i === notes.length - 1) {
+      beamType = "end";
+    } else {
+      beamType = "continue";
+    }
+    note.beam.push({
+      number: beamLevel,
+      type: beamType
+    });
+  }
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const errors = validateMeasureLocal(measure, context, { checkBeams: true });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, errors.filter((e) => e.level !== "error"));
+}
+function removeBeam(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  let noteCount = 0;
+  let targetNote = null;
+  for (const entry of measure.entries) {
+    if (entry.type === "note" && !entry.rest) {
+      if (noteCount === options.noteIndex) {
+        targetNote = entry;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (!targetNote) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} not found`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!targetNote.beam || targetNote.beam.length === 0) {
+    return failure([operationError("NOTE_NOT_FOUND", "Note is not part of a beam group", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const voice = targetNote.voice;
+  const staff = targetNote.staff;
+  const beamNotes = [];
+  let inBeam = false;
+  const targetBeamLevel = options.beamLevel ?? targetNote.beam[0]?.number ?? 1;
+  for (const entry of measure.entries) {
+    if (entry.type !== "note" || entry.rest) continue;
+    if (entry.voice !== voice || entry.staff !== staff) continue;
+    const beamInfo = entry.beam?.find((b) => b.number === targetBeamLevel);
+    if (!beamInfo) {
+      if (inBeam) {
+        break;
+      }
+      continue;
+    }
+    if (beamInfo.type === "begin") {
+      inBeam = true;
+      beamNotes.push(entry);
+    } else if (beamInfo.type === "continue") {
+      if (inBeam) beamNotes.push(entry);
+    } else if (beamInfo.type === "end") {
+      beamNotes.push(entry);
+      if (beamNotes.includes(targetNote)) {
+        break;
+      } else {
+        beamNotes.length = 0;
+        inBeam = false;
+      }
+    }
+  }
+  if (beamNotes.length === 0) {
+    beamNotes.push(targetNote);
+  }
+  for (const note of beamNotes) {
+    if (note.beam) {
+      if (options.beamLevel !== void 0) {
+        note.beam = note.beam.filter((b) => b.number !== options.beamLevel);
+      } else {
+        note.beam = [];
+      }
+      if (note.beam.length === 0) {
+        delete note.beam;
+      }
+    }
+  }
+  return success(result);
+}
+function autoBeam(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const divisions = context.divisions;
+  const time = context.time ?? { beats: "4", beatType: 4 };
+  const beatDuration = 4 / time.beatType * divisions;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      delete entry.beam;
+    }
+  }
+  const notesByVoice = /* @__PURE__ */ new Map();
+  let position = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      if (!entry.chord && !entry.rest) {
+        const voice = entry.voice;
+        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: hasNotes2, conflictingNotes } = hasNotesInRange(voiceEntries, options.position, pasteEnd);
+    if (hasNotes2) {
+      return failure([operationError(
+        "NOTE_CONFLICT",
+        `Paste range ${options.position}-${pasteEnd} conflicts with existing notes`,
+        { partIndex: options.partIndex, measureIndex: options.measureIndex, voice: targetVoice },
+        { conflictingPositions: conflictingNotes.map((n) => ({ start: n.position, end: n.endPosition })) }
+      )]);
+    }
+    const existingNotes = voiceEntries.filter((e) => e.entry.type === "note").map((e) => ({ position: e.position, entry: e.entry }));
+    for (const { relativePosition, note } of options.selection.notes) {
+      const pastePosition = options.position + Math.max(0, relativePosition);
+      const newNote = cloneNoteWithNewId(note);
+      newNote.voice = targetVoice;
+      if (targetStaff !== void 0) {
+        newNote.staff = targetStaff;
+      }
+      delete newNote.tie;
+      delete newNote.ties;
+      if (newNote.notations) {
+        newNote.notations = newNote.notations.filter((n) => n.type !== "tied");
+        if (newNote.notations.length === 0) {
+          delete newNote.notations;
+        }
+      }
+      existingNotes.push({ position: pastePosition, entry: newNote });
+    }
+    measure.entries = rebuildMeasureWithVoice(
+      measure,
+      targetVoice,
+      existingNotes,
+      measureDuration,
+      targetStaff
+    );
+  }
+  const errors = validateMeasureLocal(measure, context, {
+    checkMeasureDuration: true,
+    checkPosition: true,
+    checkVoiceStaff: true
+  });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(result, errors.filter((e) => e.level !== "error"));
+}
+function cutNotes(score, options) {
+  const copyResult = copyNotes(score, options);
+  if (!copyResult.success) {
+    return failure(copyResult.errors);
+  }
+  const selection = copyResult.data;
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const context = getMeasureContext(result, options.partIndex, options.measureIndex);
+  const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
+  const voiceEntries = getVoiceEntries(measure, options.voice, options.staff);
+  const entriesToKeep = voiceEntries.filter((e) => {
+    if (e.entry.type !== "note") return true;
+    const note = e.entry;
+    if (note.rest) return true;
+    return e.endPosition <= options.startPosition || e.position >= options.endPosition;
+  });
+  const newEntries = [];
+  for (const { position, entry } of entriesToKeep) {
+    if (entry.type === "note") {
+      newEntries.push({ position, entry });
+    }
+  }
+  measure.entries = rebuildMeasureWithVoice(
+    measure,
+    options.voice,
+    newEntries,
+    measureDuration,
+    options.staff
+  );
+  const errors = validateMeasureLocal(measure, context, {
+    checkMeasureDuration: true,
+    checkPosition: true,
+    checkVoiceStaff: true
+  });
+  const criticalErrors = errors.filter((e) => e.level === "error");
+  if (criticalErrors.length > 0) {
+    return failure(criticalErrors);
+  }
+  return success(
+    { score: result, selection },
+    errors.filter((e) => e.level !== "error")
+  );
+}
+function copyNotesMultiMeasure(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  if (options.endMeasureIndex < options.startMeasureIndex || options.endMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
+  }
+  const selection = {
+    source: {
+      partIndex: options.partIndex,
+      startMeasureIndex: options.startMeasureIndex,
+      endMeasureIndex: options.endMeasureIndex,
+      voice: options.voice,
+      staff: options.staff
+    },
+    measures: []
+  };
+  for (let measureIndex = options.startMeasureIndex; measureIndex <= options.endMeasureIndex; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    const measureOffset = measureIndex - options.startMeasureIndex;
+    const copiedNotes = [];
+    let position = 0;
+    for (const entry of measure.entries) {
+      if (entry.type === "note") {
+        if (entry.voice === options.voice && (options.staff === void 0 || (entry.staff ?? 1) === options.staff)) {
+          if (!entry.chord && !entry.rest) {
+            const clonedNote = cloneNoteWithNewId(entry);
+            copiedNotes.push({
+              relativePosition: position,
+              note: clonedNote
+            });
+            position += entry.duration;
+          } else if (entry.chord && copiedNotes.length > 0) {
+            const clonedNote = cloneNoteWithNewId(entry);
+            copiedNotes.push({
+              relativePosition: copiedNotes[copiedNotes.length - 1].relativePosition,
+              note: clonedNote
+            });
+          } else if (!entry.chord) {
+            position += entry.duration;
+          }
+        } else if (!entry.chord) {
+          position += entry.duration;
+        }
+      } else if (entry.type === "backup") {
+        position -= entry.duration;
+      } else if (entry.type === "forward") {
+        position += entry.duration;
+      }
+    }
+    if (copiedNotes.length > 0) {
+      selection.measures.push({
+        measureOffset,
+        notes: copiedNotes
+      });
+    }
+  }
+  if (selection.measures.length === 0) {
+    return failure([operationError("NOTE_NOT_FOUND", "No notes found in the specified range", { partIndex: options.partIndex, voice: options.voice })]);
+  }
+  return success(selection);
+}
+function pasteNotesMultiMeasure(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  const measureCount = options.selection.measures.length > 0 ? options.selection.measures[options.selection.measures.length - 1].measureOffset + 1 : 0;
+  if (options.startMeasureIndex + measureCount > part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Not enough measures to paste (need ${measureCount})`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  let result = cloneScore(score);
+  const targetVoice = options.voice ?? options.selection.source.voice;
+  const targetStaff = options.staff ?? options.selection.source.staff;
+  for (const measureData of options.selection.measures) {
+    const measureIndex = options.startMeasureIndex + measureData.measureOffset;
+    const measure = result.parts[options.partIndex].measures[measureIndex];
+    const context = getMeasureContext(result, options.partIndex, measureIndex);
+    const measureDuration = context.time ? getMeasureDuration(context.divisions, context.time) : context.divisions * 4;
+    const voiceEntries = getVoiceEntries(measure, targetVoice, targetStaff);
+    let entriesToKeep;
+    if (options.overwrite !== false) {
+      entriesToKeep = voiceEntries.filter((e) => e.entry.type === "note" && e.entry.rest).map((e) => ({ position: e.position, entry: e.entry }));
+    } else {
+      entriesToKeep = voiceEntries.filter((e) => e.entry.type === "note").map((e) => ({ position: e.position, entry: e.entry }));
+    }
+    for (const { relativePosition, note } of measureData.notes) {
+      const newNote = cloneNoteWithNewId(note);
+      newNote.voice = targetVoice;
+      if (targetStaff !== void 0) {
+        newNote.staff = targetStaff;
+      }
+      delete newNote.tie;
+      delete newNote.ties;
+      if (newNote.notations) {
+        newNote.notations = newNote.notations.filter((n) => n.type !== "tied");
+        if (newNote.notations.length === 0) {
+          delete newNote.notations;
+        }
+      }
+      entriesToKeep.push({ position: relativePosition, entry: newNote });
+    }
+    measure.entries = rebuildMeasureWithVoice(
+      measure,
+      targetVoice,
+      entriesToKeep,
+      measureDuration,
+      targetStaff
+    );
+    const errors = validateMeasureLocal(measure, context, {
+      checkMeasureDuration: true,
+      checkPosition: true,
+      checkVoiceStaff: true
+    });
+    const criticalErrors = errors.filter((e) => e.level === "error");
+    if (criticalErrors.length > 0) {
+      return failure(criticalErrors);
+    }
+  }
+  return success(result);
+}
+function addTempo(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (options.bpm <= 0) {
+    return failure([operationError("INVALID_DURATION", "BPM must be positive", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const directionTypes = [];
+  directionTypes.push({
+    kind: "metronome",
+    beatUnit: options.beatUnit ?? "quarter",
+    beatUnitDot: options.beatUnitDot,
+    perMinute: options.bpm
+  });
+  if (options.text) {
+    directionTypes.push({
+      kind: "words",
+      text: options.text,
+      fontWeight: "bold"
+    });
+  }
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes,
+    placement: options.placement ?? "above",
+    sound: { tempo: options.bpm }
+  };
+  insertDirectionAtPosition(measure, direction, options.position);
+  return success(result);
+}
+function removeTempo(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const tempoDirectionIndices = [];
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "metronome")) {
+      tempoDirectionIndices.push(i);
+    }
+  }
+  if (tempoDirectionIndices.length === 0) {
+    return failure([operationError("TEMPO_NOT_FOUND", "No tempo marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const targetIndex = options.directionIndex ?? 0;
+  if (targetIndex < 0 || targetIndex >= tempoDirectionIndices.length) {
+    return failure([operationError("TEMPO_NOT_FOUND", `Tempo direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  measure.entries.splice(tempoDirectionIndices[targetIndex], 1);
+  return success(result);
+}
+function modifyTempo(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const tempoDirectionIndices = [];
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "metronome")) {
+      tempoDirectionIndices.push(i);
+    }
+  }
+  if (tempoDirectionIndices.length === 0) {
+    return failure([operationError("TEMPO_NOT_FOUND", "No tempo marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const targetIndex = options.directionIndex ?? 0;
+  if (targetIndex < 0 || targetIndex >= tempoDirectionIndices.length) {
+    return failure([operationError("TEMPO_NOT_FOUND", `Tempo direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const direction = measure.entries[tempoDirectionIndices[targetIndex]];
+  const metronome = direction.directionTypes.find((dt) => dt.kind === "metronome");
+  if (metronome && metronome.kind === "metronome") {
+    if (options.bpm !== void 0) {
+      metronome.perMinute = options.bpm;
+    }
+    if (options.beatUnit !== void 0) {
+      metronome.beatUnit = options.beatUnit;
+    }
+    if (options.beatUnitDot !== void 0) {
+      metronome.beatUnitDot = options.beatUnitDot;
+    }
+  }
+  if (options.text !== void 0) {
+    const wordsIndex = direction.directionTypes.findIndex((dt) => dt.kind === "words");
+    if (wordsIndex >= 0) {
+      const words = direction.directionTypes[wordsIndex];
+      if (words.kind === "words") {
+        words.text = options.text;
+      }
+    } else if (options.text) {
+      direction.directionTypes.push({
+        kind: "words",
+        text: options.text,
+        fontWeight: "bold"
+      });
+    }
+  }
+  if (options.bpm !== void 0 && direction.sound) {
+    direction.sound.tempo = options.bpm;
+  }
+  if (options.placement !== void 0) {
+    direction.placement = options.placement;
+  }
+  return success(result);
+}
+function addWedge(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.startMeasureIndex < 0 || options.startMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Start measure index ${options.startMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.startMeasureIndex })]);
+  }
+  if (options.endMeasureIndex < 0 || options.endMeasureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `End measure index ${options.endMeasureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.endMeasureIndex })]);
+  }
+  if (options.endMeasureIndex < options.startMeasureIndex || options.endMeasureIndex === options.startMeasureIndex && options.endPosition <= options.startPosition) {
+    return failure([operationError("INVALID_RANGE", "End position must be after start position", { partIndex: options.partIndex })]);
+  }
+  const result = cloneScore(score);
+  const startMeasure = result.parts[options.partIndex].measures[options.startMeasureIndex];
+  const startDirection = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "wedge",
+      type: options.type
+    }],
+    placement: options.placement ?? "below",
+    staff: options.staff
+  };
+  insertDirectionAtPosition(startMeasure, startDirection, options.startPosition);
+  const endMeasure = result.parts[options.partIndex].measures[options.endMeasureIndex];
+  const endDirection = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "wedge",
+      type: "stop"
+    }],
+    placement: options.placement ?? "below",
+    staff: options.staff
+  };
+  insertDirectionAtPosition(endMeasure, endDirection, options.endPosition);
+  return success(result);
+}
+function removeWedge(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const wedgeStarts = [];
+  for (let mi = options.measureIndex; mi < result.parts[options.partIndex].measures.length; mi++) {
+    const measure = result.parts[options.partIndex].measures[mi];
+    for (let ei = 0; ei < measure.entries.length; ei++) {
+      const entry = measure.entries[ei];
+      if (entry.type === "direction") {
+        const wedgeType = entry.directionTypes.find((dt) => dt.kind === "wedge");
+        if (wedgeType && wedgeType.kind === "wedge" && (wedgeType.type === "crescendo" || wedgeType.type === "diminuendo")) {
+          wedgeStarts.push({ measureIndex: mi, entryIndex: ei });
+        }
+      }
+    }
+    if (mi === options.measureIndex && wedgeStarts.length > 0) break;
+  }
+  if (wedgeStarts.length === 0) {
+    return failure([operationError("WEDGE_NOT_FOUND", "No wedge found starting in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const targetIndex = options.directionIndex ?? 0;
+  if (targetIndex >= wedgeStarts.length) {
+    return failure([operationError("WEDGE_NOT_FOUND", `Wedge direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const startInfo = wedgeStarts[targetIndex];
+  const startMeasure = result.parts[options.partIndex].measures[startInfo.measureIndex];
+  startMeasure.entries.splice(startInfo.entryIndex, 1);
+  for (let mi = startInfo.measureIndex; mi < result.parts[options.partIndex].measures.length; mi++) {
+    const measure = result.parts[options.partIndex].measures[mi];
+    for (let ei = 0; ei < measure.entries.length; ei++) {
+      const entry = measure.entries[ei];
+      if (entry.type === "direction") {
+        const wedgeType = entry.directionTypes.find((dt) => dt.kind === "wedge" && dt.type === "stop");
+        if (wedgeType) {
+          measure.entries.splice(ei, 1);
+          return success(result);
+        }
+      }
+    }
+  }
+  return success(result);
+}
+function addFermata(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
+  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = notes[options.noteIndex];
+  if (note.notations?.some((n) => n.type === "fermata")) {
+    return failure([operationError("FERMATA_ALREADY_EXISTS", "Note already has a fermata", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!note.notations) {
+    note.notations = [];
+  }
+  const fermataNotation = {
+    type: "fermata",
+    shape: options.shape ?? "normal",
+    fermataType: options.fermataType ?? "upright",
+    placement: options.placement ?? "above"
+  };
+  note.notations.push(fermataNotation);
+  return success(result);
+}
+function removeFermata(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
+  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = notes[options.noteIndex];
+  const fermataIndex = note.notations?.findIndex((n) => n.type === "fermata");
+  if (fermataIndex === void 0 || fermataIndex === -1) {
+    return failure([operationError("FERMATA_NOT_FOUND", "Note does not have a fermata", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  note.notations.splice(fermataIndex, 1);
+  if (note.notations.length === 0) {
+    delete note.notations;
+  }
+  return success(result);
+}
+function addOrnament(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
+  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = notes[options.noteIndex];
+  if (note.notations?.some((n) => n.type === "ornament" && n.ornament === options.ornament)) {
+    return failure([operationError("ORNAMENT_ALREADY_EXISTS", `Note already has ornament: ${options.ornament}`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!note.notations) {
+    note.notations = [];
+  }
+  const ornamentNotation = {
+    type: "ornament",
+    ornament: options.ornament,
+    placement: options.placement,
+    accidentalMark: options.accidentalMark
+  };
+  note.notations.push(ornamentNotation);
+  return success(result);
+}
+function removeOrnament(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const notes = measure.entries.filter((e) => e.type === "note" && !e.rest);
+  if (options.noteIndex < 0 || options.noteIndex >= notes.length) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note index ${options.noteIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const note = notes[options.noteIndex];
+  const ornamentIndex = options.ornament ? note.notations?.findIndex((n) => n.type === "ornament" && n.ornament === options.ornament) : note.notations?.findIndex((n) => n.type === "ornament");
+  if (ornamentIndex === void 0 || ornamentIndex === -1) {
+    return failure([operationError("ORNAMENT_NOT_FOUND", "Note does not have the specified ornament", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  note.notations.splice(ornamentIndex, 1);
+  if (note.notations.length === 0) {
+    delete note.notations;
+  }
+  return success(result);
+}
+function addPedal(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "pedal",
+      type: options.pedalType,
+      line: options.line
+    }],
+    placement: options.placement ?? "below"
+  };
+  insertDirectionAtPosition(measure, direction, options.position);
+  return success(result);
+}
+function removePedal(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const pedalIndices = [];
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction" && entry.directionTypes.some((dt) => dt.kind === "pedal")) {
+      pedalIndices.push(i);
+    }
+  }
+  if (pedalIndices.length === 0) {
+    return failure([operationError("PEDAL_NOT_FOUND", "No pedal marking found in measure", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const targetIndex = options.directionIndex ?? 0;
+  if (targetIndex < 0 || targetIndex >= pedalIndices.length) {
+    return failure([operationError("PEDAL_NOT_FOUND", `Pedal direction index ${targetIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  measure.entries.splice(pedalIndices[targetIndex], 1);
+  return success(result);
+}
+function addTextDirection(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  if (!options.text.trim()) {
+    return failure([operationError("INVALID_TEXT", "Text cannot be empty", { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "words",
+      text: options.text,
+      fontStyle: options.fontStyle,
+      fontWeight: options.fontWeight
+    }],
+    placement: options.placement ?? "above"
+  };
+  insertDirectionAtPosition(measure, direction, options.position);
+  return success(result);
+}
+function addRehearsalMark(score, options) {
+  if (options.partIndex < 0 || options.partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${options.partIndex} out of bounds`, { partIndex: options.partIndex })]);
+  }
+  const part = score.parts[options.partIndex];
+  if (options.measureIndex < 0 || options.measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${options.measureIndex} out of bounds`, { partIndex: options.partIndex, measureIndex: options.measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[options.partIndex].measures[options.measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "rehearsal",
+      text: options.text,
+      enclosure: options.enclosure ?? "square"
+    }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, 0);
+  return success(result);
+}
+function insertDirectionAtPosition(measure, direction, position) {
+  let currentPosition = 0;
+  let insertIndex = 0;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (currentPosition >= position) {
+      insertIndex = i;
+      break;
+    }
+    if (entry.type === "note" && !entry.chord) {
+      currentPosition += entry.duration;
+    } else if (entry.type === "forward") {
+      currentPosition += entry.duration;
+    } else if (entry.type === "backup") {
+      currentPosition -= entry.duration;
+    }
+    insertIndex = i + 1;
+  }
+  measure.entries.splice(insertIndex, 0, direction);
+}
+function addRepeatBarline(score, options) {
+  const { partIndex, measureIndex, direction, times } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const location = direction === "forward" ? "left" : "right";
+  const barStyle = direction === "forward" ? "heavy-light" : "light-heavy";
+  for (const p of result.parts) {
+    if (measureIndex >= p.measures.length) continue;
+    const measure = p.measures[measureIndex];
+    if (!measure.barlines) {
+      measure.barlines = [];
+    }
+    const existingIndex = measure.barlines.findIndex((b) => b.location === location && b.repeat);
+    if (existingIndex >= 0) {
+      return failure([operationError("REPEAT_ALREADY_EXISTS", `Repeat barline already exists at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
+    }
+    const nonRepeatIndex = measure.barlines.findIndex((b) => b.location === location && !b.repeat);
+    if (nonRepeatIndex >= 0) {
+      measure.barlines.splice(nonRepeatIndex, 1);
+    }
+    measure.barlines.push({
+      _id: generateId(),
+      location,
+      barStyle,
+      repeat: {
+        direction,
+        times
+      }
+    });
+  }
+  return success(result);
+}
+function removeRepeatBarline(score, options) {
+  const { partIndex, measureIndex, location } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  if (!measure.barlines) {
+    return failure([operationError("REPEAT_NOT_FOUND", `No repeat barline found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
+  }
+  const existingIndex = measure.barlines.findIndex((b) => b.location === location && b.repeat);
+  if (existingIndex < 0) {
+    return failure([operationError("REPEAT_NOT_FOUND", `No repeat barline found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  for (const p of result.parts) {
+    if (measureIndex >= p.measures.length) continue;
+    const m = p.measures[measureIndex];
+    if (m.barlines) {
+      const idx = m.barlines.findIndex((b) => b.location === location && b.repeat);
+      if (idx >= 0) {
+        m.barlines.splice(idx, 1);
+      }
+      if (m.barlines.length === 0) {
+        delete m.barlines;
+      }
+    }
+  }
+  return success(result);
+}
+function addEnding(score, options) {
+  const { partIndex, measureIndex, number, type } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const location = type === "start" ? "left" : "right";
+  for (const p of result.parts) {
+    if (measureIndex >= p.measures.length) continue;
+    const measure = p.measures[measureIndex];
+    if (!measure.barlines) {
+      measure.barlines = [];
+    }
+    let barline = measure.barlines.find((b) => b.location === location);
+    if (!barline) {
+      barline = { _id: generateId(), location };
+      measure.barlines.push(barline);
+    }
+    if (barline.ending) {
+      return failure([operationError("ENDING_ALREADY_EXISTS", `Ending already exists at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
+    }
+    barline.ending = { number, type };
+  }
+  return success(result);
+}
+function removeEnding(score, options) {
+  const { partIndex, measureIndex, location } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  const barline = measure.barlines?.find((b) => b.location === location && b.ending);
+  if (!barline) {
+    return failure([operationError("ENDING_NOT_FOUND", `No ending found at ${location} of measure ${measureIndex}`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  for (const p of result.parts) {
+    if (measureIndex >= p.measures.length) continue;
+    const m = p.measures[measureIndex];
+    if (m.barlines) {
+      const bl = m.barlines.find((b) => b.location === location);
+      if (bl) {
+        delete bl.ending;
+        if (!bl.barStyle && !bl.repeat && !bl.ending) {
+          const idx = m.barlines.indexOf(bl);
+          m.barlines.splice(idx, 1);
+        }
+      }
+      if (m.barlines.length === 0) {
+        delete m.barlines;
+      }
+    }
+  }
+  return success(result);
+}
+function changeBarline(score, options) {
+  const { partIndex, measureIndex, location, barStyle } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  for (const p of result.parts) {
+    if (measureIndex >= p.measures.length) continue;
+    const measure = p.measures[measureIndex];
+    if (!measure.barlines) {
+      measure.barlines = [];
+    }
+    let barline = measure.barlines.find((b) => b.location === location);
+    if (!barline) {
+      barline = { _id: generateId(), location };
+      measure.barlines.push(barline);
+    }
+    barline.barStyle = barStyle;
+  }
+  return success(result);
+}
+function addSegno(score, options) {
+  const { partIndex, measureIndex, position = 0 } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "segno" }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, position);
+  return success(result);
+}
+function addCoda(score, options) {
+  const { partIndex, measureIndex, position = 0 } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "coda" }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, position);
+  return success(result);
+}
+function addDaCapo(score, options) {
+  const { partIndex, measureIndex, position } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
+  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
+  const insertPos = position ?? measureDuration;
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "words", text: "D.C." }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, insertPos);
+  const sound = {
+    _id: generateId(),
+    type: "sound",
+    dacapo: true
+  };
+  measure.entries.push(sound);
+  return success(result);
+}
+function addDalSegno(score, options) {
+  const { partIndex, measureIndex, position } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
+  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
+  const insertPos = position ?? measureDuration;
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "words", text: "D.S." }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, insertPos);
+  const sound = {
+    _id: generateId(),
+    type: "sound",
+    dalsegno: "segno"
+  };
+  measure.entries.push(sound);
+  return success(result);
+}
+function addFine(score, options) {
+  const { partIndex, measureIndex, position } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
+  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
+  const insertPos = position ?? measureDuration;
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "words", text: "Fine" }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, insertPos);
+  const sound = {
+    _id: generateId(),
+    type: "sound",
+    fine: true
+  };
+  measure.entries.push(sound);
+  return success(result);
+}
+function addToCoda(score, options) {
+  const { partIndex, measureIndex, position } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const attrs = getAttributesAtMeasure(result, { part: partIndex, measure: measureIndex });
+  const measureDuration = getMeasureDuration(attrs.divisions ?? 1, attrs.time ?? { beats: "4", beatType: 4 });
+  const insertPos = position ?? measureDuration;
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{ kind: "words", text: "To Coda" }],
+    placement: "above"
+  };
+  insertDirectionAtPosition(measure, direction, insertPos);
+  const sound = {
+    _id: generateId(),
+    type: "sound",
+    tocoda: "coda"
+  };
+  measure.entries.push(sound);
+  return success(result);
+}
+function addGraceNote(score, options) {
+  const { partIndex, measureIndex, targetNoteIndex, pitch, noteType = "eighth", slash = true, voice, staff } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  let targetNote = null;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord) {
+      if (noteCount === targetNoteIndex) {
+        targetEntryIndex = i;
+        targetNote = entry;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0 || !targetNote) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${targetNoteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultMeasure = result.parts[partIndex].measures[measureIndex];
+  const graceNote = {
+    _id: generateId(),
+    type: "note",
+    pitch,
+    duration: 0,
+    // Grace notes have no duration
+    voice: voice ?? targetNote.voice,
+    staff: staff ?? targetNote.staff,
+    noteType,
+    grace: {
+      slash
+    }
+  };
+  resultMeasure.entries.splice(targetEntryIndex, 0, graceNote);
+  return success(result);
+}
+function removeGraceNote(score, options) {
+  const { partIndex, measureIndex, graceNoteIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let graceCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && entry.grace) {
+      if (graceCount === graceNoteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      graceCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("GRACE_NOTE_NOT_FOUND", `Grace note at index ${graceNoteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
+  return success(result);
+}
+function convertToGrace(score, options) {
+  const { partIndex, measureIndex, noteIndex, slash = true } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note") {
+    return failure([operationError("NOTE_NOT_FOUND", `Entry at index is not a note`, { partIndex, measureIndex })]);
+  }
+  if (targetEntry.grace) {
+    return failure([operationError("INVALID_GRACE_NOTE", `Note is already a grace note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.grace = { slash };
+  resultNote.duration = 0;
+  return success(result);
+}
+function addLyric(score, options) {
+  const { partIndex, measureIndex, noteIndex, text, syllabic = "single", verse = 1, extend = false } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note") {
+    return failure([operationError("NOTE_NOT_FOUND", `Entry is not a note`, { partIndex, measureIndex })]);
+  }
+  if (targetEntry.lyrics?.some((l) => l.number === verse)) {
+    return failure([operationError("LYRIC_ALREADY_EXISTS", `Lyric for verse ${verse} already exists on this note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.lyrics) {
+    resultNote.lyrics = [];
+  }
+  const lyric = {
+    number: verse,
+    syllabic,
+    text,
+    extend
+  };
+  resultNote.lyrics.push(lyric);
+  return success(result);
+}
+function removeLyric(score, options) {
+  const { partIndex, measureIndex, noteIndex, verse } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.lyrics || targetEntry.lyrics.length === 0) {
+    return failure([operationError("LYRIC_NOT_FOUND", `No lyrics found on note`, { partIndex, measureIndex })]);
+  }
+  if (verse !== void 0) {
+    const lyricIndex = targetEntry.lyrics.findIndex((l) => l.number === verse);
+    if (lyricIndex < 0) {
+      return failure([operationError("LYRIC_NOT_FOUND", `Lyric for verse ${verse} not found on note`, { partIndex, measureIndex })]);
+    }
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (verse !== void 0) {
+    resultNote.lyrics = resultNote.lyrics.filter((l) => l.number !== verse);
+  } else {
+    delete resultNote.lyrics;
+  }
+  if (resultNote.lyrics && resultNote.lyrics.length === 0) {
+    delete resultNote.lyrics;
+  }
+  return success(result);
+}
+function updateLyric(score, options) {
+  const { partIndex, measureIndex, noteIndex, verse = 1, text, syllabic, extend } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.lyrics) {
+    return failure([operationError("LYRIC_NOT_FOUND", `No lyrics found on note`, { partIndex, measureIndex })]);
+  }
+  const lyricIndex = targetEntry.lyrics.findIndex((l) => l.number === verse);
+  if (lyricIndex < 0) {
+    return failure([operationError("LYRIC_NOT_FOUND", `Lyric for verse ${verse} not found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  const lyric = resultNote.lyrics[lyricIndex];
+  if (text !== void 0) {
+    lyric.text = text;
+  }
+  if (syllabic !== void 0) {
+    lyric.syllabic = syllabic;
+  }
+  if (extend !== void 0) {
+    lyric.extend = extend;
+  }
+  return success(result);
+}
+function addHarmony(score, options) {
+  const { partIndex, measureIndex, position, root, kind, kindText, bass, degrees, staff, placement = "above" } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const validSteps = ["A", "B", "C", "D", "E", "F", "G"];
+  if (!validSteps.includes(root.step.toUpperCase())) {
+    return failure([operationError("INVALID_HARMONY", `Invalid root step: ${root.step}`, { partIndex, measureIndex })]);
+  }
+  if (bass && !validSteps.includes(bass.step.toUpperCase())) {
+    return failure([operationError("INVALID_HARMONY", `Invalid bass step: ${bass.step}`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const harmony = {
+    _id: generateId(),
+    type: "harmony",
+    root: {
+      rootStep: root.step.toUpperCase(),
+      rootAlter: root.alter
+    },
+    kind,
+    kindText,
+    bass: bass ? {
+      bassStep: bass.step.toUpperCase(),
+      bassAlter: bass.alter
+    } : void 0,
+    degrees: degrees?.map((d) => ({
+      degreeValue: d.value,
+      degreeAlter: d.alter,
+      degreeType: d.type
+    })),
+    staff,
+    placement
+  };
+  let currentPosition = 0;
+  let insertIndex = 0;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (currentPosition >= position) {
+      insertIndex = i;
+      break;
+    }
+    if (entry.type === "note" && !entry.chord) {
+      currentPosition += entry.duration;
+    } else if (entry.type === "forward") {
+      currentPosition += entry.duration;
+    } else if (entry.type === "backup") {
+      currentPosition -= entry.duration;
+    }
+    insertIndex = i + 1;
+  }
+  measure.entries.splice(insertIndex, 0, harmony);
+  return success(result);
+}
+function removeHarmony(score, options) {
+  const { partIndex, measureIndex, harmonyIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let harmonyCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "harmony") {
+      if (harmonyCount === harmonyIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      harmonyCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("HARMONY_NOT_FOUND", `Harmony at index ${harmonyIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
+  return success(result);
+}
+function updateHarmony(score, options) {
+  const { partIndex, measureIndex, harmonyIndex, root, kind, kindText, bass, degrees } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let harmonyCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "harmony") {
+      if (harmonyCount === harmonyIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      harmonyCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("HARMONY_NOT_FOUND", `Harmony at index ${harmonyIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const validSteps = ["A", "B", "C", "D", "E", "F", "G"];
+  if (root && !validSteps.includes(root.step.toUpperCase())) {
+    return failure([operationError("INVALID_HARMONY", `Invalid root step: ${root.step}`, { partIndex, measureIndex })]);
+  }
+  if (bass && !validSteps.includes(bass.step.toUpperCase())) {
+    return failure([operationError("INVALID_HARMONY", `Invalid bass step: ${bass.step}`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const harmony = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (root) {
+    harmony.root = {
+      rootStep: root.step.toUpperCase(),
+      rootAlter: root.alter
+    };
+  }
+  if (kind !== void 0) {
+    harmony.kind = kind;
+  }
+  if (kindText !== void 0) {
+    harmony.kindText = kindText;
+  }
+  if (bass !== void 0) {
+    if (bass === null) {
+      delete harmony.bass;
+    } else {
+      harmony.bass = {
+        bassStep: bass.step.toUpperCase(),
+        bassAlter: bass.alter
+      };
+    }
+  }
+  if (degrees !== void 0) {
+    if (degrees === null) {
+      delete harmony.degrees;
+    } else {
+      harmony.degrees = degrees.map((d) => ({
+        degreeValue: d.value,
+        degreeAlter: d.alter,
+        degreeType: d.type
+      }));
+    }
+  }
+  return success(result);
+}
+function addFingering(score, options) {
+  const { partIndex, measureIndex, noteIndex, fingering, substitution = false, alternate = false, placement } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.notations) {
+    resultNote.notations = [];
+  }
+  resultNote.notations.push({
+    type: "technical",
+    technical: "fingering",
+    fingering,
+    fingeringSubstitution: substitution || void 0,
+    fingeringAlternate: alternate || void 0,
+    placement
+  });
+  return success(result);
+}
+function removeFingering(score, options) {
+  const { partIndex, measureIndex, noteIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.notations) {
+    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
+  }
+  const fingeringIndex = targetEntry.notations.findIndex(
+    (n) => n.type === "technical" && n.technical === "fingering"
+  );
+  if (fingeringIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `No fingering found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.notations.splice(fingeringIndex, 1);
+  if (resultNote.notations.length === 0) {
+    delete resultNote.notations;
+  }
+  return success(result);
+}
+function addBowing(score, options) {
+  const { partIndex, measureIndex, noteIndex, bowingType, placement } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.notations) {
+    resultNote.notations = [];
+  }
+  resultNote.notations.push({
+    type: "technical",
+    technical: bowingType,
+    placement
+  });
+  return success(result);
+}
+function removeBowing(score, options) {
+  const { partIndex, measureIndex, noteIndex, bowingType } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.notations) {
+    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
+  }
+  const bowingIndex = targetEntry.notations.findIndex((n) => {
+    if (n.type !== "technical") return false;
+    if (bowingType) return n.technical === bowingType;
+    return n.technical === "up-bow" || n.technical === "down-bow";
+  });
+  if (bowingIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `No bowing found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.notations.splice(bowingIndex, 1);
+  if (resultNote.notations.length === 0) {
+    delete resultNote.notations;
+  }
+  return success(result);
+}
+function addStringNumber(score, options) {
+  const { partIndex, measureIndex, noteIndex, stringNumber, placement } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  if (stringNumber < 1) {
+    return failure([operationError("INVALID_POSITION", `String number must be positive`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.notations) {
+    resultNote.notations = [];
+  }
+  resultNote.notations.push({
+    type: "technical",
+    technical: "string",
+    string: stringNumber,
+    placement
+  });
+  return success(result);
+}
+function removeStringNumber(score, options) {
+  const { partIndex, measureIndex, noteIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.notations) {
+    return failure([operationError("NOTE_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
+  }
+  const stringIndex = targetEntry.notations.findIndex(
+    (n) => n.type === "technical" && n.technical === "string"
+  );
+  if (stringIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `No string number found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.notations.splice(stringIndex, 1);
+  if (resultNote.notations.length === 0) {
+    delete resultNote.notations;
+  }
+  return success(result);
+}
+function addOctaveShift(score, options) {
+  const { partIndex, measureIndex, position, shiftType, size = 8 } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "octave-shift",
+      type: shiftType,
+      size
+    }],
+    placement: shiftType === "down" ? "above" : "below"
+  };
+  insertDirectionAtPosition(measure, direction, position);
+  return success(result);
+}
+function stopOctaveShift(score, options) {
+  const { partIndex, measureIndex, position, size = 8 } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const measure = result.parts[partIndex].measures[measureIndex];
+  const direction = {
+    _id: generateId(),
+    type: "direction",
+    directionTypes: [{
+      kind: "octave-shift",
+      type: "stop",
+      size
+    }]
+  };
+  insertDirectionAtPosition(measure, direction, position);
+  return success(result);
+}
+function removeOctaveShift(score, options) {
+  const { partIndex, measureIndex, octaveShiftIndex = 0 } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let shiftCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "direction") {
+      const hasOctaveShift = entry.directionTypes.some((dt) => dt.kind === "octave-shift");
+      if (hasOctaveShift) {
+        if (shiftCount === octaveShiftIndex) {
+          targetEntryIndex = i;
+          break;
+        }
+        shiftCount++;
+      }
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Octave shift at index ${octaveShiftIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  result.parts[partIndex].measures[measureIndex].entries.splice(targetEntryIndex, 1);
+  return success(result);
+}
+function addBreathMark(score, options) {
+  const { partIndex, measureIndex, noteIndex, placement = "above" } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.notations) {
+    resultNote.notations = [];
+  }
+  const existingBreathMark = resultNote.notations.find(
+    (n) => n.type === "articulation" && n.articulation === "breath-mark"
+  );
+  if (existingBreathMark) {
+    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Breath mark already exists on note`, { partIndex, measureIndex })]);
+  }
+  resultNote.notations.push({
+    type: "articulation",
+    articulation: "breath-mark",
+    placement
+  });
+  return success(result);
+}
+function removeBreathMark(score, options) {
+  const { partIndex, measureIndex, noteIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.notations) {
+    return failure([operationError("ARTICULATION_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
+  }
+  const breathMarkIndex = targetEntry.notations.findIndex(
+    (n) => n.type === "articulation" && n.articulation === "breath-mark"
+  );
+  if (breathMarkIndex < 0) {
+    return failure([operationError("ARTICULATION_NOT_FOUND", `No breath mark found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.notations.splice(breathMarkIndex, 1);
+  if (resultNote.notations.length === 0) {
+    delete resultNote.notations;
+  }
+  return success(result);
+}
+function addCaesura(score, options) {
+  const { partIndex, measureIndex, noteIndex, placement = "above" } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  if (!resultNote.notations) {
+    resultNote.notations = [];
+  }
+  const existingCaesura = resultNote.notations.find(
+    (n) => n.type === "articulation" && n.articulation === "caesura"
+  );
+  if (existingCaesura) {
+    return failure([operationError("ARTICULATION_ALREADY_EXISTS", `Caesura already exists on note`, { partIndex, measureIndex })]);
+  }
+  resultNote.notations.push({
+    type: "articulation",
+    articulation: "caesura",
+    placement
+  });
+  return success(result);
+}
+function removeCaesura(score, options) {
+  const { partIndex, measureIndex, noteIndex } = options;
+  if (partIndex < 0 || partIndex >= score.parts.length) {
+    return failure([operationError("PART_NOT_FOUND", `Part index ${partIndex} out of bounds`, { partIndex })]);
+  }
+  const part = score.parts[partIndex];
+  if (measureIndex < 0 || measureIndex >= part.measures.length) {
+    return failure([operationError("MEASURE_NOT_FOUND", `Measure index ${measureIndex} out of bounds`, { partIndex, measureIndex })]);
+  }
+  const measure = part.measures[measureIndex];
+  let noteCount = 0;
+  let targetEntryIndex = -1;
+  for (let i = 0; i < measure.entries.length; i++) {
+    const entry = measure.entries[i];
+    if (entry.type === "note" && !entry.chord && !entry.rest) {
+      if (noteCount === noteIndex) {
+        targetEntryIndex = i;
+        break;
+      }
+      noteCount++;
+    }
+  }
+  if (targetEntryIndex < 0) {
+    return failure([operationError("NOTE_NOT_FOUND", `Note at index ${noteIndex} not found`, { partIndex, measureIndex })]);
+  }
+  const targetEntry = measure.entries[targetEntryIndex];
+  if (targetEntry.type !== "note" || !targetEntry.notations) {
+    return failure([operationError("ARTICULATION_NOT_FOUND", `No notations found on note`, { partIndex, measureIndex })]);
+  }
+  const caesuraIndex = targetEntry.notations.findIndex(
+    (n) => n.type === "articulation" && n.articulation === "caesura"
+  );
+  if (caesuraIndex < 0) {
+    return failure([operationError("ARTICULATION_NOT_FOUND", `No caesura found on note`, { partIndex, measureIndex })]);
+  }
+  const result = cloneScore(score);
+  const resultNote = result.parts[partIndex].measures[measureIndex].entries[targetEntryIndex];
+  resultNote.notations.splice(caesuraIndex, 1);
+  if (resultNote.notations.length === 0) {
+    delete resultNote.notations;
+  }
+  return success(result);
+}
+var addText = addTextDirection;
+var setBeaming = autoBeam;
+var addChordSymbol = addHarmony;
+var removeChordSymbol = removeHarmony;
+var updateChordSymbol = updateHarmony;
+var changeClef = insertClefChange;
+var setBarline = changeBarline;
+var addRepeat = addRepeatBarline;
+var removeRepeat = removeRepeatBarline;
 
 // src/file.ts
 import { readFile, writeFile } from "fs/promises";
@@ -7655,18 +10958,66 @@ export {
   STEPS,
   STEP_SEMITONES,
   ValidationException,
+  addArticulation,
+  addBeam,
+  addBowing,
+  addBreathMark,
+  addCaesura,
+  addChord,
   addChordNote,
+  addChordNoteChecked,
+  addChordSymbol,
+  addCoda,
+  addDaCapo,
+  addDalSegno,
+  addDynamics,
+  addEnding,
+  addFermata,
+  addFine,
+  addFingering,
+  addGraceNote,
+  addHarmony,
+  addLyric,
   addNote,
+  addNoteChecked,
+  addOctaveShift,
+  addOrnament,
+  addPart,
+  addPedal,
+  addRehearsalMark,
+  addRepeat,
+  addRepeatBarline,
+  addSegno,
+  addSlur,
+  addStringNumber,
+  addTempo,
+  addText,
+  addTextDirection,
+  addTie,
+  addToCoda,
+  addVoice,
+  addWedge,
   assertMeasureValid,
   assertValid,
+  autoBeam,
   buildVoiceToStaffMap,
   buildVoiceToStaffMapForPart,
+  changeBarline,
+  changeClef,
   changeKey,
+  changeNoteDuration,
   changeTime,
+  convertToGrace,
+  copyNotes,
+  copyNotesMultiMeasure,
   countNotes,
+  createTuplet,
+  cutNotes,
   decodeBuffer,
   deleteMeasure,
   deleteNote,
+  deleteNoteChecked,
+  duplicatePart,
   exportMidi,
   findBarlines,
   findDirectionsByType,
@@ -7760,7 +11111,9 @@ export {
   hasTieStop,
   hasTuplet,
   inferStaff,
+  insertClefChange,
   insertMeasure,
+  insertNote,
   isChordNote,
   isCompressed,
   isCueNote,
@@ -7773,19 +11126,65 @@ export {
   isValid,
   iterateEntries,
   iterateNotes,
+  lowerAccidental,
   measureRoundtrip,
+  modifyDynamics,
   modifyNoteDuration,
+  modifyNoteDurationChecked,
   modifyNotePitch,
+  modifyNotePitchChecked,
+  modifyTempo,
+  moveNoteToStaff,
   parse,
   parseAuto,
   parseCompressed,
   parseFile,
+  pasteNotes,
+  pasteNotesMultiMeasure,
   pitchToSemitone,
+  raiseAccidental,
+  removeArticulation,
+  removeBeam,
+  removeBowing,
+  removeBreathMark,
+  removeCaesura,
+  removeChordSymbol,
+  removeDynamics,
+  removeEnding,
+  removeFermata,
+  removeFingering,
+  removeGraceNote,
+  removeHarmony,
+  removeLyric,
+  removeNote,
+  removeOctaveShift,
+  removeOrnament,
+  removePart,
+  removePedal,
+  removeRepeat,
+  removeRepeatBarline,
+  removeSlur,
+  removeStringNumber,
+  removeTempo,
+  removeTie,
+  removeTuplet,
+  removeWedge,
   scoresEqual,
   serialize,
   serializeCompressed,
   serializeToFile,
+  setBarline,
+  setBeaming,
+  setNotePitch,
+  setNotePitchBySemitone,
+  setStaves,
+  shiftNotePitch,
+  stopOctaveShift,
   transpose,
+  transposeChecked,
+  updateChordSymbol,
+  updateHarmony,
+  updateLyric,
   validate,
   validateBackupForward,
   validateBeams,