@sudobility/music_types 0.11.29 → 0.11.31

package/dist/domain/commands/note-commands.js

@@ -10,13 +10,14 @@
  * note that crosses a measure boundary into tied segments via Task 3's
  * `splitNoteAcrossMeasures`, per the Task 5 brief.
  */
-import { createId } from '../score/ids.js';
-import { splitNoteAcrossMeasures } from '../score/ties.js';
-import { isNoteEvent } from '../../index.js';
-import { ticksFor } from '../time/ticks.js';
-import { transposePitch } from '../pitch/transpose.js';
-import { transformCommand } from './snapshot.js';
-import { clearDanglingTies, ensureVoiceAtIndex, insertNoteIntoTrack, removeNotesFromTrack, reflowVoice, withTracks, } from './reflow.js';
+import { createId } from "../score/ids.js";
+import { splitNoteAcrossMeasures } from "../score/ties.js";
+import { isNoteEvent } from "../../index.js";
+import { findEvent } from "../score/queries.js";
+import { ticksFor } from "../time/ticks.js";
+import { transposePitch } from "../pitch/transpose.js";
+import { transformCommand } from "./snapshot.js";
+import { clearDanglingTies, ensureVoiceAtIndex, insertNoteIntoTrack, removeNotesFromTrack, reflowVoice, withTracks, } from "./reflow.js";
 // ---- shared traversal helpers ------------------------------------------------
 /**
  * Applies `updater` to every note event in `score` whose id is in
@@ -26,14 +27,14 @@ import { clearDanglingTies, ensureVoiceAtIndex, insertNoteIntoTrack, removeNotes
  */
 function mapNotes(score, eventIds, updater) {
     const idSet = new Set(eventIds);
-    const tracks = score.tracks.map(track => {
-        const measures = track.measures.map(measure => {
-            const voices = measure.voices.map(voice => {
-                if (!voice.events.some(e => idSet.has(e.id)))
+    const tracks = score.tracks.map((track) => {
+        const measures = track.measures.map((measure) => {
+            const voices = measure.voices.map((voice) => {
+                if (!voice.events.some((e) => idSet.has(e.id)))
                     return voice;
                 return {
                     ...voice,
-                    events: voice.events.map(event => isNoteEvent(event) && idSet.has(event.id) ? updater(event) : event),
+                    events: voice.events.map((event) => isNoteEvent(event) && idSet.has(event.id) ? updater(event) : event),
                 };
             });
             const measureChanged = voices.some((v, i) => v !== measure.voices[i]);
@@ -45,10 +46,10 @@ function mapNotes(score, eventIds, updater) {
     return withTracks(score, tracks);
 }
 function addNote(score, params) {
-    const tracks = score.tracks.map(track => {
+    const tracks = score.tracks.map((track) => {
         if (track.id !== params.trackId)
             return track;
-        const measureExists = track.measures.some(m => m.id === params.measureId);
+        const measureExists = track.measures.some((m) => m.id === params.measureId);
         if (!measureExists)
             return track;
         const note = {
@@ -57,7 +58,7 @@ function addNote(score, params) {
             startTick: params.startTick,
             durationTicks: params.durationTicks,
             velocity: params.velocity ?? 80,
-            voiceId: '', // renumbered by insertNoteIntoTrack to the destination voice's id
+            voiceId: "", // renumbered by insertNoteIntoTrack to the destination voice's id
             trackId: track.id,
             ...(params.articulation ? { articulation: params.articulation } : {}),
         };
@@ -84,7 +85,7 @@ function addNote(score, params) {
  * further, or split it into per-measure `addNoteCommand` calls themselves.
  */
 export function addNoteCommand(params, label) {
-    return transformCommand(label, score => addNote(score, params));
+    return transformCommand(label, (score) => addNote(score, params));
 }
 // ---- deleteEventsCommand -------------------------------------------------------
 function deleteEvents(score, eventIds) {
@@ -93,7 +94,7 @@ function deleteEvents(score, eventIds) {
     // note *before* actually removing the notes (clearDanglingTies needs
     // the deleted notes still in place to find their chain partners).
     const detied = clearDanglingTies(score, idSet);
-    const tracks = detied.tracks.map(track => removeNotesFromTrack(track, idSet));
+    const tracks = detied.tracks.map((track) => removeNotesFromTrack(track, idSet));
     return withTracks(detied, tracks);
 }
 /**
@@ -102,13 +103,13 @@ function deleteEvents(score, eventIds) {
  * also being deleted, that partner's now-dangling tie flag is cleared.
  */
 export function deleteEventsCommand(eventIds, label) {
-    return transformCommand(label, score => deleteEvents(score, eventIds));
+    return transformCommand(label, (score) => deleteEvents(score, eventIds));
 }
 function moveNotesOnTrack(track, eventIds, params) {
     const toMove = [];
-    track.measures.forEach(measure => {
+    track.measures.forEach((measure) => {
         measure.voices.forEach((voice, voiceIndex) => {
-            voice.events.forEach(event => {
+            voice.events.forEach((event) => {
                 if (isNoteEvent(event) && eventIds.has(event.id))
                     toMove.push({ note: event, voiceIndex });
             });
@@ -116,8 +117,8 @@ function moveNotesOnTrack(track, eventIds, params) {
     });
     if (toMove.length === 0)
         return track;
-    let working = removeNotesFromTrack(track, new Set(toMove.map(m => m.note.id)));
-    const boundaries = working.measures.map(m => m.startTick);
+    let working = removeNotesFromTrack(track, new Set(toMove.map((m) => m.note.id)));
+    const boundaries = working.measures.map((m) => m.startTick);
     const lastMeasure = working.measures[working.measures.length - 1];
     const trackEnd = lastMeasure
         ? lastMeasure.startTick + lastMeasure.durationTicks
@@ -125,7 +126,7 @@ function moveNotesOnTrack(track, eventIds, params) {
     for (const { note, voiceIndex } of toMove) {
         const maxStart = Math.max(0, trackEnd - note.durationTicks);
         const clampedStart = Math.max(0, Math.min(note.startTick + params.deltaTicks, maxStart));
-        const destMeasure = working.measures.find(m => clampedStart >= m.startTick &&
+        const destMeasure = working.measures.find((m) => clampedStart >= m.startTick &&
             clampedStart < m.startTick + m.durationTicks) ?? lastMeasure;
         const newPitch = params.deltaSemitones !== 0
             ? transposePitch(note.pitch, params.deltaSemitones, destMeasure?.keySignature)
@@ -149,7 +150,7 @@ function moveNotes(score, eventIds, params) {
     // As in deleteEvents: clear dangling tie flags on any surviving partner
     // of a moved note before moveNotesOnTrack relocates it away.
     const detied = clearDanglingTies(score, idSet);
-    const tracks = detied.tracks.map(track => moveNotesOnTrack(track, idSet, params));
+    const tracks = detied.tracks.map((track) => moveNotesOnTrack(track, idSet, params));
     return withTracks(detied, tracks);
 }
 /**
@@ -163,21 +164,21 @@ function moveNotes(score, eventIds, params) {
  * partner's now-dangling tie flag is cleared too.
  */
 export function moveNotesCommand(eventIds, params, label) {
-    return transformCommand(label, score => moveNotes(score, eventIds, params));
+    return transformCommand(label, (score) => moveNotes(score, eventIds, params));
 }
 // ---- resizeNotesCommand / changeDurationCommand ----------------------------------
 function resizeNotes(score, eventIds, durationTicks) {
     const idSet = new Set(eventIds);
-    const tracks = score.tracks.map(track => {
-        const measures = track.measures.map(measure => {
+    const tracks = score.tracks.map((track) => {
+        const measures = track.measures.map((measure) => {
             let nextMeasure = measure;
             let changed = false;
             for (const voice of measure.voices) {
-                if (!voice.events.some(e => idSet.has(e.id)))
+                if (!voice.events.some((e) => idSet.has(e.id)))
                     continue;
                 changed = true;
                 const measureEnd = measure.startTick + measure.durationTicks;
-                const updatedNotes = voice.events.filter(isNoteEvent).map(e => {
+                const updatedNotes = voice.events.filter(isNoteEvent).map((e) => {
                     if (!idSet.has(e.id))
                         return e;
                     const clamped = Math.max(1, Math.min(durationTicks, measureEnd - e.startTick));
@@ -185,7 +186,7 @@ function resizeNotes(score, eventIds, durationTicks) {
                 });
                 const withResized = {
                     ...nextMeasure,
-                    voices: nextMeasure.voices.map(v => v.id === voice.id ? { ...v, events: updatedNotes } : v),
+                    voices: nextMeasure.voices.map((v) => v.id === voice.id ? { ...v, events: updatedNotes } : v),
                 };
                 nextMeasure = reflowVoice(withResized, voice.id, track.id);
             }
@@ -202,24 +203,24 @@ function resizeNotes(score, eventIds, durationTicks) {
  * current measure (no cross-measure re-splitting), then reflows.
  */
 export function resizeNotesCommand(eventIds, durationTicks, label) {
-    return transformCommand(label, score => resizeNotes(score, eventIds, durationTicks));
+    return transformCommand(label, (score) => resizeNotes(score, eventIds, durationTicks));
 }
 /** Sets the given notes' duration to a named value (e.g. from the inspector), converted to ticks via the score's ppq. */
 export function changeDurationCommand(eventIds, duration, label) {
-    return transformCommand(label, score => resizeNotes(score, eventIds, ticksFor(duration, score.ppq)));
+    return transformCommand(label, (score) => resizeNotes(score, eventIds, ticksFor(duration, score.ppq)));
 }
 // ---- simple per-note field commands ------------------------------------------
 /** Sets the given notes' pitch to an absolute `Pitch`. */
 export function changePitchCommand(eventIds, pitch, label) {
-    return transformCommand(label, score => mapNotes(score, eventIds, note => ({ ...note, pitch })));
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => ({ ...note, pitch })));
 }
 /** Sets the given notes' velocity (0-127). */
 export function changeVelocityCommand(eventIds, velocity, label) {
-    return transformCommand(label, score => mapNotes(score, eventIds, note => ({ ...note, velocity })));
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => ({ ...note, velocity })));
 }
 /** Sets (or clears, when `articulation` is `undefined`) the given notes' articulation. */
 export function changeArticulationCommand(eventIds, articulation, label) {
-    return transformCommand(label, score => mapNotes(score, eventIds, note => {
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => {
         if (articulation)
             return { ...note, articulation };
         const updated = { ...note };
@@ -227,25 +228,416 @@ export function changeArticulationCommand(eventIds, articulation, label) {
         return updated;
     }));
 }
+/**
+ * Sets (or clears, when `ornament` is `undefined`) the given notes' ornament.
+ *
+ * Shaped like `changeArticulationCommand` rather than like the fermata toggle,
+ * because an ornament is a choice among several rather than an on/off: a menu
+ * sets the one it names, and "None" clears. A note carries at most one sign —
+ * a trill that is also a turn is not a marking anybody writes.
+ */
+export function changeOrnamentCommand(eventIds, ornament, label) {
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => {
+        if (ornament)
+            return { ...note, ornament };
+        const updated = { ...note };
+        delete updated.ornament;
+        return updated;
+    }));
+}
+/**
+ * Puts a fermata on the given notes, or takes it off the ones that have one.
+ *
+ * Toggles on the *whole selection together* rather than per note: the state is
+ * read from whether every selected note already carries one, so a mixed
+ * selection gains fermatas rather than flipping each note independently. A
+ * control that did the latter would leave a selection half-marked and look
+ * broken.
+ *
+ * Unlike `toggleSlurCommand` this needs no endpoints and refuses nothing — a
+ * fermata is a property of a single note, so one note is a perfectly good
+ * selection and each marked note stands alone. Chords are marked note by note
+ * because that is what the selection contains; the renderer draws one fermata
+ * per notehead position, which is what a chord with a pause looks like.
+ */
+export function toggleFermataCommand(eventIds, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event));
+        if (notes.length === 0)
+            return score;
+        // Only remove when every selected note already has one, so a selection
+        // that is partly marked becomes fully marked rather than inverting.
+        const allMarked = notes.every((note) => note.fermata);
+        return mapNotes(score, eventIds, (note) => {
+            if (allMarked) {
+                const updated = { ...note };
+                delete updated.fermata;
+                return updated;
+            }
+            return { ...note, fermata: true };
+        });
+    });
+}
+/**
+ * Sets or clears the dynamic marking the given notes start.
+ *
+ * A dynamic is stored on the note it applies *from* and governs until the next
+ * one on that track, so marking one note `f` is how a passage becomes loud —
+ * there is nothing to apply to the notes in between, and applying it to each
+ * would print a marking under every notehead.
+ */
+export function changeDynamicCommand(eventIds, dynamic, label) {
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => {
+        if (dynamic)
+            return { ...note, dynamic };
+        const updated = { ...note };
+        delete updated.dynamic;
+        return updated;
+    }));
+}
 /** Sets the given notes' pitch accidental, keeping their step/octave. */
 export function changeAccidentalCommand(eventIds, accidental, label) {
-    return transformCommand(label, score => mapNotes(score, eventIds, note => ({
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => ({
         ...note,
         pitch: { ...note.pitch, accidental },
     })));
 }
 /** Toggles `tieStart` or `tieStop` on the given notes. */
 export function toggleTieCommand(eventIds, which, label) {
-    return transformCommand(label, score => mapNotes(score, eventIds, note => ({ ...note, [which]: !note[which] })));
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => ({ ...note, [which]: !note[which] })));
+}
+/**
+ * Slurs a selection, or removes the slur it already carries.
+ *
+ * Takes the whole selection rather than a flag per note, because that is what
+ * a slur is: one mark over a run of notes. The caller says "slur these" and
+ * this decides which of them is the start and which the stop — marking them
+ * individually would let a user create a start with no stop, which draws
+ * nothing and is invisible to fix.
+ *
+ * Endpoints are the earliest and latest note by tick, not the order the ids
+ * arrived in: a selection built by shift-clicking around a phrase is still
+ * that phrase.
+ *
+ * Fewer than two notes cannot be slurred — a phrase mark over one note means
+ * nothing — and toggling off is offered when the span is already slurred, so
+ * the same control removes what it made.
+ */
+export function toggleSlurCommand(eventIds, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event))
+            .sort((a, b) => a.startTick - b.startTick);
+        if (notes.length < 2)
+            return score;
+        const first = notes[0];
+        const last = notes[notes.length - 1];
+        const alreadySlurred = Boolean(first.slurStart && last.slurStop);
+        return mapNotes(score, eventIds, (note) => {
+            const updated = { ...note };
+            delete updated.slurStart;
+            delete updated.slurStop;
+            if (alreadySlurred)
+                return updated;
+            if (note.id === first.id)
+                updated.slurStart = true;
+            if (note.id === last.id)
+                updated.slurStop = true;
+            return updated;
+        });
+    });
+}
+/**
+ * Writes a hairpin across the selection, or removes the one it already has.
+ *
+ * Shaped like `toggleSlurCommand`, because a hairpin is the same kind of thing
+ * — one mark over a run of notes. The caller says "crescendo these" and this
+ * decides which of them opens it and which closes it; marking them one at a
+ * time would let a user create an opening with no close, which draws nothing
+ * and is invisible to fix.
+ *
+ * Endpoints are the earliest and latest note **by tick**, not the order the
+ * ids arrived in, so a selection built by shift-clicking around a phrase is
+ * still that phrase.
+ *
+ * Fewer than two notes is refused: a wedge over one note has nowhere to open
+ * to. Re-applying the **same** direction to a span that already carries it
+ * removes it, so one control undoes what it made; applying the **other**
+ * direction flips it, which is what reaching for the other button means.
+ */
+export function toggleHairpinCommand(eventIds, hairpin, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event))
+            .sort((a, b) => a.startTick - b.startTick);
+        if (notes.length < 2)
+            return score;
+        const first = notes[0];
+        const last = notes[notes.length - 1];
+        const sameAlready = first.hairpinStart === hairpin && Boolean(last.hairpinStop);
+        return mapNotes(score, eventIds, (note) => {
+            const updated = { ...note };
+            delete updated.hairpinStart;
+            delete updated.hairpinStop;
+            if (sameAlready)
+                return updated;
+            if (note.id === first.id)
+                updated.hairpinStart = hairpin;
+            if (note.id === last.id)
+                updated.hairpinStop = true;
+            return updated;
+        });
+    });
+}
+/**
+ * Rolls the selected chords, or stops rolling them.
+ *
+ * Toggles the whole selection together, like the fermata: the state is read
+ * from whether *every* selected note already carries the flag, so a partly
+ * marked selection becomes fully marked rather than inverting note by note.
+ *
+ * The mark belongs to a chord, but the selection is notes — so this simply
+ * sets the flag on what was selected and lets the renderer decide. A lone note
+ * keeps the flag harmlessly and draws nothing, which is better than refusing:
+ * selecting a bar and rolling its chords should not fail because one beat
+ * happens to be a single note.
+ */
+export function toggleArpeggiateCommand(eventIds, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event));
+        if (notes.length === 0)
+            return score;
+        const allMarked = notes.every((note) => note.arpeggiate);
+        return mapNotes(score, eventIds, (note) => {
+            if (allMarked) {
+                const updated = { ...note };
+                delete updated.arpeggiate;
+                return updated;
+            }
+            return { ...note, arpeggiate: true };
+        });
+    });
+}
+/**
+ * Brackets the selection at an octave, or removes the bracket it has.
+ *
+ * A span like the hairpin: endpoints by tick, two notes minimum, the same
+ * displacement twice removes it and a different one replaces it.
+ */
+export function toggleOttavaCommand(eventIds, ottava, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event))
+            .sort((a, b) => a.startTick - b.startTick);
+        if (notes.length < 2)
+            return score;
+        const first = notes[0];
+        const last = notes[notes.length - 1];
+        const sameAlready = first.ottavaStart === ottava && Boolean(last.ottavaStop);
+        return mapNotes(score, eventIds, (note) => {
+            const updated = { ...note };
+            delete updated.ottavaStart;
+            delete updated.ottavaStop;
+            if (sameAlready)
+                return updated;
+            if (note.id === first.id)
+                updated.ottavaStart = ottava;
+            if (note.id === last.id)
+                updated.ottavaStop = true;
+            return updated;
+        });
+    });
+}
+/**
+ * Slides between the selected notes, or removes the slide.
+ *
+ * Two notes exactly is the usual case and two is the minimum: a glissando is
+ * a line *between* noteheads, so one note has nothing to slide to. A wider
+ * selection slides from its first note to its last, which is what dragging
+ * across a run and asking for a slide means.
+ */
+export function toggleGlissandoCommand(eventIds, label) {
+    return transformCommand(label, (score) => {
+        const notes = eventIds
+            .map((id) => findEvent(score, id))
+            .filter((event) => event !== null && isNoteEvent(event))
+            .sort((a, b) => a.startTick - b.startTick);
+        if (notes.length < 2)
+            return score;
+        const first = notes[0];
+        const last = notes[notes.length - 1];
+        const already = Boolean(first.glissandoStart && last.glissandoStop);
+        return mapNotes(score, eventIds, (note) => {
+            const updated = { ...note };
+            delete updated.glissandoStart;
+            delete updated.glissandoStop;
+            if (already)
+                return updated;
+            if (note.id === first.id)
+                updated.glissandoStart = true;
+            if (note.id === last.id)
+                updated.glissandoStop = true;
+            return updated;
+        });
+    });
+}
+/**
+ * Sets or clears the finger written on the given notes.
+ *
+ * Blank clears it rather than storing an empty string, which would reserve
+ * space beside the notehead and print nothing.
+ */
+export function setFingeringCommand(eventIds, fingering, label) {
+    const trimmed = fingering?.trim();
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => {
+        if (trimmed)
+            return { ...note, fingering: trimmed };
+        const updated = { ...note };
+        delete updated.fingering;
+        return updated;
+    }));
+}
+/**
+ * Sets or clears the syllable sung on one note.
+ *
+ * One note at a time, unlike the other note commands: every syllable in a line
+ * is different, so applying one across a selection could only ever write the
+ * same word repeatedly.
+ *
+ * Blank text clears the lyric rather than storing an empty one — an empty
+ * syllable would reserve space under the note and print nothing.
+ */
+export function setLyricCommand(eventId, lyric, label) {
+    return transformCommand(label, (score) => mapNotes(score, [eventId], (note) => {
+        const updated = { ...note };
+        if (!lyric || lyric.text.trim() === "") {
+            delete updated.lyric;
+            return updated;
+        }
+        updated.lyric = {
+            text: lyric.text.trim(),
+            // `single` is the default the model states, so storing it would only
+            // be noise in every saved score.
+            ...(lyric.syllabic && lyric.syllabic !== "single"
+                ? { syllabic: lyric.syllabic }
+                : {}),
+        };
+        return updated;
+    }));
+}
+/**
+ * Sets or clears the chord symbol printed from a note.
+ *
+ * One note at a time, like a lyric: every chord in a progression is different,
+ * so applying one across a selection could only write the same symbol
+ * repeatedly. Blank text clears it rather than storing an empty symbol, which
+ * would reserve space above the stave and print nothing.
+ */
+export function setChordSymbolCommand(eventId, symbol, label) {
+    return transformCommand(label, (score) => mapNotes(score, [eventId], (note) => {
+        const updated = { ...note };
+        const trimmed = symbol?.trim();
+        if (!trimmed) {
+            delete updated.chordSymbol;
+            return updated;
+        }
+        updated.chordSymbol = trimmed;
+        return updated;
+    }));
+}
+/**
+ * Turns a written note into a grace note on the note that follows it.
+ *
+ * The note leaves the voice and reappears hanging off its neighbour, and the
+ * gap it leaves is filled with a rest — so the bar still adds up, which is the
+ * whole reason grace notes are stored on their principal rather than as events
+ * of their own.
+ *
+ * The principal is the next note *in the same voice*, since that is what the
+ * ornament leads into. A note with nothing after it cannot become one: an
+ * ornament with nothing to ornament would simply vanish from the page.
+ */
+export function toGraceNoteCommand(eventId, label) {
+    return transformCommand(label, (score) => {
+        const tracks = score.tracks.map((track) => ({
+            ...track,
+            measures: track.measures.map((measure) => ({
+                ...measure,
+                voices: measure.voices.map((voice) => {
+                    const index = voice.events.findIndex((e) => e.id === eventId);
+                    if (index === -1)
+                        return voice;
+                    const source = voice.events[index];
+                    if (!isNoteEvent(source))
+                        return voice;
+                    // The principal: the next *note* after it in this voice.
+                    const principalIndex = voice.events.findIndex((e, i) => i > index && isNoteEvent(e));
+                    if (principalIndex === -1)
+                        return voice;
+                    const principal = voice.events[principalIndex];
+                    const grace = {
+                        pitch: source.pitch,
+                        durationTicks: source.durationTicks,
+                        slashed: true,
+                    };
+                    /*
+                      Ornaments the source itself carried travel with it, ahead of the
+                      note it becomes: turning a decorated note into a grace note should
+                      move the whole ornamental run to the new principal, not silently
+                      drop everything in front of it.
+                    */
+                    const carried = [...(source.graceNotes ?? []), grace];
+                    return {
+                        ...voice,
+                        events: voice.events.map((event, i) => {
+                            // The time the note occupied stays occupied, by a rest: an
+                            // ornament borrows from its principal, it does not shorten the
+                            // bar.
+                            if (i === index)
+                                return {
+                                    id: source.id,
+                                    startTick: source.startTick,
+                                    durationTicks: source.durationTicks,
+                                    voiceId: source.voiceId,
+                                    trackId: source.trackId,
+                                };
+                            if (i === principalIndex)
+                                return {
+                                    ...principal,
+                                    graceNotes: [...(principal.graceNotes ?? []), ...carried],
+                                };
+                            return event;
+                        }),
+                    };
+                }),
+            })),
+        }));
+        return withTracks(score, tracks);
+    });
+}
+/** Removes every ornament from the given notes. */
+export function clearGraceNotesCommand(eventIds, label) {
+    return transformCommand(label, (score) => mapNotes(score, eventIds, (note) => {
+        const updated = { ...note };
+        delete updated.graceNotes;
+        return updated;
+    }));
 }
 // ---- changeVoiceCommand -----------------------------------------------------------
 function changeVoice(score, eventIds, targetVoiceIndex) {
     const idSet = new Set(eventIds);
-    const tracks = score.tracks.map(track => {
-        const measures = track.measures.map(measure => {
+    const tracks = score.tracks.map((track) => {
+        const measures = track.measures.map((measure) => {
             const matches = [];
-            measure.voices.forEach(voice => {
-                voice.events.forEach(e => {
+            measure.voices.forEach((voice) => {
+                voice.events.forEach((e) => {
                     if (isNoteEvent(e) && idSet.has(e.id))
                         matches.push(e);
                 });
@@ -254,21 +646,21 @@ function changeVoice(score, eventIds, targetVoiceIndex) {
                 return measure;
             let nextMeasure = measure;
             for (const voice of measure.voices) {
-                if (!voice.events.some(e => idSet.has(e.id)))
+                if (!voice.events.some((e) => idSet.has(e.id)))
                     continue;
                 const remaining = voice.events
                     .filter(isNoteEvent)
-                    .filter(e => !idSet.has(e.id));
+                    .filter((e) => !idSet.has(e.id));
                 const withRemoved = {
                     ...nextMeasure,
-                    voices: nextMeasure.voices.map(v => v.id === voice.id ? { ...v, events: remaining } : v),
+                    voices: nextMeasure.voices.map((v) => v.id === voice.id ? { ...v, events: remaining } : v),
                 };
                 nextMeasure = reflowVoice(withRemoved, voice.id, track.id);
             }
             nextMeasure = ensureVoiceAtIndex(nextMeasure, targetVoiceIndex, track.id);
             const targetVoice = nextMeasure.voices[targetVoiceIndex];
             const existingNotes = targetVoice.events.filter(isNoteEvent);
-            const movedNotes = matches.map(n => ({
+            const movedNotes = matches.map((n) => ({
                 ...n,
                 voiceId: targetVoice.id,
             }));
@@ -287,6 +679,6 @@ function changeVoice(score, eventIds, targetVoiceIndex) {
 }
 /** Moves the given notes to the voice at ordinal position `targetVoiceIndex` within their current measure (created if absent). */
 export function changeVoiceCommand(eventIds, targetVoiceIndex, label) {
-    return transformCommand(label, score => changeVoice(score, eventIds, targetVoiceIndex));
+    return transformCommand(label, (score) => changeVoice(score, eventIds, targetVoiceIndex));
 }
 //# sourceMappingURL=note-commands.js.map