@sudobility/music_types 0.11.31 → 0.11.33

package/dist/domain/commands/note-commands.d.ts

@@ -1,6 +1,12 @@
-import type { Accidental, Articulation, DurationName, Hairpin, Ornament, Ottava, Pitch, UUID } from "../../index.js";
-import type { Dynamic, Lyric } from "../../index.js";
+import type { Articulation, DurationName, NoteEvent, Pitch, Score, UUID } from "../../index.js";
 import type { ScoreCommand } from "./types.js";
+/**
+ * Applies `updater` to every note event in `score` whose id is in
+ * `eventIds`; other events pass through unchanged. Preserves referential
+ * equality at every level (voice/measure/track) that has no matching
+ * event, so a call that matches nothing is a true no-op (see `withTracks`).
+ */
+export declare function mapNotes(score: Score, eventIds: readonly UUID[], updater: (note: NoteEvent) => NoteEvent): Score;
 export type AddNoteParams = {
     trackId: UUID;
     measureId: UUID;
@@ -59,159 +65,6 @@ export declare function moveNotesCommand(eventIds: UUID[], params: MoveNotesPara
 export declare function resizeNotesCommand(eventIds: UUID[], durationTicks: number, label: string): ScoreCommand;
 /** Sets the given notes' duration to a named value (e.g. from the inspector), converted to ticks via the score's ppq. */
 export declare function changeDurationCommand(eventIds: UUID[], duration: DurationName, label: string): ScoreCommand;
-/** Sets the given notes' pitch to an absolute `Pitch`. */
-export declare function changePitchCommand(eventIds: UUID[], pitch: Pitch, label: string): ScoreCommand;
-/** Sets the given notes' velocity (0-127). */
-export declare function changeVelocityCommand(eventIds: UUID[], velocity: number, label: string): ScoreCommand;
-/** Sets (or clears, when `articulation` is `undefined`) the given notes' articulation. */
-export declare function changeArticulationCommand(eventIds: UUID[], articulation: Articulation | undefined, label: string): ScoreCommand;
-/**
- * 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 declare function changeOrnamentCommand(eventIds: UUID[], ornament: Ornament | undefined, label: string): ScoreCommand;
-/**
- * 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 declare function toggleFermataCommand(eventIds: UUID[], label: string): ScoreCommand;
-/**
- * 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 declare function changeDynamicCommand(eventIds: UUID[], dynamic: Dynamic | undefined, label: string): ScoreCommand;
-/** Sets the given notes' pitch accidental, keeping their step/octave. */
-export declare function changeAccidentalCommand(eventIds: UUID[], accidental: Accidental, label: string): ScoreCommand;
-/** Toggles `tieStart` or `tieStop` on the given notes. */
-export declare function toggleTieCommand(eventIds: UUID[], which: "tieStart" | "tieStop", label: string): ScoreCommand;
-/**
- * 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 declare function toggleSlurCommand(eventIds: UUID[], label: string): ScoreCommand;
-/**
- * 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 declare function toggleHairpinCommand(eventIds: UUID[], hairpin: Hairpin, label: string): ScoreCommand;
-/**
- * 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 declare function toggleArpeggiateCommand(eventIds: UUID[], label: string): ScoreCommand;
-/**
- * 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 declare function toggleOttavaCommand(eventIds: UUID[], ottava: Ottava, label: string): ScoreCommand;
-/**
- * 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 declare function toggleGlissandoCommand(eventIds: UUID[], label: string): ScoreCommand;
-/**
- * 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 declare function setFingeringCommand(eventIds: UUID[], fingering: string | undefined, label: string): ScoreCommand;
-/**
- * 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 declare function setLyricCommand(eventId: UUID, lyric: Lyric | undefined, label: string): ScoreCommand;
-/**
- * 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 declare function setChordSymbolCommand(eventId: UUID, symbol: string | undefined, label: string): ScoreCommand;
-/**
- * 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 declare function toGraceNoteCommand(eventId: UUID, label: string): ScoreCommand;
-/** Removes every ornament from the given notes. */
-export declare function clearGraceNotesCommand(eventIds: UUID[], label: string): ScoreCommand;
 /** Moves the given notes to the voice at ordinal position `targetVoiceIndex` within their current measure (created if absent). */
 export declare function changeVoiceCommand(eventIds: UUID[], targetVoiceIndex: number, label: string): ScoreCommand;
 //# sourceMappingURL=note-commands.d.ts.map

package/dist/domain/commands/note-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"note-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/note-commands.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"note-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/note-commands.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,KAAK,EACL,KAAK,EAEL,IAAI,EACL,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAa/C;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,SAAS,IAAI,EAAE,EACzB,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,GACtC,KAAK,CAoBP;AAID,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAwBF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,IAAI,EAAE,EAChB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAID,MAAM,MAAM,eAAe,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC;AAiF7E;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,IAAI,EAAE,EAChB,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AA0CD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,EAAE,EAChB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAED,yHAAyH;AACzH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,IAAI,EAAE,EAChB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AA0DD,kIAAkI;AAClI,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,EAAE,EAChB,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,MAAM,GACZ,YAAY,CAId"}

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

@@ -13,7 +13,6 @@
 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";
@@ -25,7 +24,7 @@ import { clearDanglingTies, ensureVoiceAtIndex, insertNoteIntoTrack, removeNotes
  * equality at every level (voice/measure/track) that has no matching
  * event, so a call that matches nothing is a true no-op (see `withTracks`).
  */
-function mapNotes(score, eventIds, updater) {
+export function mapNotes(score, eventIds, updater) {
     const idSet = new Set(eventIds);
     const tracks = score.tracks.map((track) => {
         const measures = track.measures.map((measure) => {
@@ -209,427 +208,6 @@ export function resizeNotesCommand(eventIds, durationTicks, label) {
 export function changeDurationCommand(eventIds, duration, label) {
     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 })));
-}
-/** Sets the given notes' velocity (0-127). */
-export function changeVelocityCommand(eventIds, velocity, label) {
-    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) => {
-        if (articulation)
-            return { ...note, articulation };
-        const updated = { ...note };
-        delete updated.articulation;
-        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) => ({
-        ...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] })));
-}
-/**
- * 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);