@sudobility/music_types 0.11.20 → 0.11.22

package/CLAUDE.md

@@ -1,5 +1,10 @@
 # @sudobility/music_types
 
+> **Git policy — never auto-commit or auto-push.** Leave your work in the working tree.
+> Run `git commit`, `git push`, `gh pr create`, or `scripts/push_all.sh` **only when the user
+> explicitly asks in that turn**. Approval for an earlier change does not carry forward, and
+> finishing a task is not permission to commit it.
+
 TypeScript types and Zod schemas for the ScoreSmith music family (music_api, music_client, music_lib, music_app).
 
 ## Tech Stack
@@ -45,3 +50,7 @@ Everything exports from a single sectioned `src/index.ts`:
 - `music_client` — typed network client + React Query hooks
 - `music_lib` — domain logic, adapters, store
 - `music_app` — web app (UI/routing only)
+
+## Git Workflow
+
+- Do not use feature branches for code changes. Always stay on the current branch.

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

@@ -0,0 +1,66 @@
+import type { MusicalEvent, NoteEvent, Score, UUID } from '../../index.js';
+import type { QuantizeOptions } from '../quantization/options.js';
+import type { ScoreCommand } from './types.js';
+export type PasteDestination = {
+    trackId: UUID;
+    voiceIndex: number;
+    anchorTick: number;
+};
+/**
+ * Pastes a copied list of note events (e.g. from a prior "copy" of a
+ * selection) into `destination.trackId`/`voiceIndex`, anchored so the
+ * earliest-starting pasted note lands at `destination.anchorTick` and
+ * every other note keeps its relative offset. A pasted note that ends up
+ * crossing a measure boundary is split into tied segments, matching
+ * `moveNotesCommand`. Ids are regenerated so pasted notes never collide
+ * with their source.
+ */
+export declare function pasteEventsCommand(notes: NoteEvent[], destination: PasteDestination, label: string): ScoreCommand;
+/**
+ * One voice (identified by `trackId`/`measureId`/`voiceId`) touched by a
+ * quantize action, with its *note* events already extracted (not the
+ * synthetic rests `reflowVoice` fills gaps with — feeding those into
+ * `quantizeEvents` alongside real notes could snap a filler rest's start
+ * independently of its neighboring note and corrupt the measure). Building
+ * this list is O(score) but doesn't itself call `quantizeEvents` — see
+ * `collectQuantizeTargets`'s doc comment for why it's split out as its own
+ * step (Task 17).
+ */
+export type QuantizeTarget = {
+    trackId: UUID;
+    measureId: UUID;
+    voiceId: UUID;
+    notes: NoteEvent[];
+};
+/**
+ * The cheap, non-quantizing "which voices does this selection touch, and
+ * what are their current notes" pass of quantization: walks the score once
+ * and collects one `QuantizeTarget` per voice containing at least one of
+ * `eventIds`. Split out from `quantizeCommand`'s transform so the
+ * intent layer (`editing.ts`'s `quantizeSelection`, `interactions.ts`'s
+ * `commitQuantize`) can run this synchronously to decide *how much* work a
+ * quantize action actually implies (spec §29: route a manual quantize of
+ * >2000 events through `services/quantization/quantize-service.ts`'s
+ * worker) before committing to the expensive `quantizeEvents` call either
+ * on the main thread or off it — without duplicating this measure/voice
+ * walk in two places.
+ */
+export declare function collectQuantizeTargets(score: Score, eventIds: readonly UUID[]): QuantizeTarget[];
+/**
+ * Splices each target's already-quantized notes (`quantizedByVoiceId`,
+ * keyed by `QuantizeTarget.voiceId` — computed by the caller via
+ * `quantizeEvents`) back into `score`: clips each note back to its measure's span, then
+ * `reflowVoice` regenerates that voice's rests around the result. This
+ * keeps quantization measure-local (no cross-measure re-splitting), a
+ * deliberate Task 5 scope limitation documented in the original brief.
+ * A target whose `voiceId` has no entry in `quantizedByVoiceId` is treated
+ * as "nothing computed for it" (splices in an empty note list) — the
+ * sole caller (`quantize`, below) always populates every target's key
+ * before calling this.
+ */
+export declare function applyQuantizedGroups(score: Score, targets: readonly QuantizeTarget[], quantizedByVoiceId: ReadonlyMap<UUID, MusicalEvent[]>): Score;
+/** Quantizes every voice containing at least one of `eventIds`, per Task 4's reusable quantization engine. */
+export declare function quantizeCommand(eventIds: UUID[], options: QuantizeOptions, label: string): ScoreCommand;
+/** Transposes the given notes by `semitones`, re-spelling each per its own measure's key signature. */
+export declare function transposeCommand(eventIds: UUID[], semitones: number, label: string): ScoreCommand;
+//# sourceMappingURL=edit-commands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edit-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/edit-commands.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,KAAK,EACL,IAAI,EACL,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,IAAI,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkCF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAAE,EAClB,WAAW,EAAE,gBAAgB,EAC7B,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAgBD;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,SAAS,IAAI,EAAE,GACxB,cAAc,EAAE,CAiBlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,kBAAkB,EAAE,WAAW,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,GACpD,KAAK,CAqCP;AAuBD,8GAA8G;AAC9G,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAuCD,uGAAuG;AACvG,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,IAAI,EAAE,EAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACZ,YAAY,CAId"}

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

@@ -0,0 +1,185 @@
+/**
+ * Copy/paste, quantize, and transpose command factories (spec §7, §14,
+ * §24). Each factory wraps a pure `(Score) => Score` transform via
+ * `transformCommand`.
+ */
+import { createId } from '../score/ids.js';
+import { splitNoteAcrossMeasures } from '../score/ties.js';
+import { isNoteEvent } from '../../index.js';
+import { transposePitch } from '../pitch/transpose.js';
+import { quantizeEvents } from '../quantization/quantize.js';
+import { transformCommand } from './snapshot.js';
+import { insertNoteIntoTrack, reflowVoice, withTracks } from './reflow.js';
+function pasteEvents(score, notes, destination) {
+    const track = score.tracks.find(t => t.id === destination.trackId);
+    if (!track || notes.length === 0)
+        return score;
+    const originStart = Math.min(...notes.map(n => n.startTick));
+    const boundaries = track.measures.map(m => m.startTick);
+    let working = track;
+    for (const note of notes) {
+        const startTick = destination.anchorTick + (note.startTick - originStart);
+        const placeholder = {
+            ...note,
+            id: createId(),
+            startTick,
+            trackId: destination.trackId,
+            tieStart: undefined,
+            tieStop: undefined,
+        };
+        const segments = splitNoteAcrossMeasures(placeholder, boundaries);
+        for (const segment of segments) {
+            working = insertNoteIntoTrack(working, segment, destination.voiceIndex);
+        }
+    }
+    const tracks = score.tracks.map(t => (t.id === track.id ? working : t));
+    return withTracks(score, tracks);
+}
+/**
+ * Pastes a copied list of note events (e.g. from a prior "copy" of a
+ * selection) into `destination.trackId`/`voiceIndex`, anchored so the
+ * earliest-starting pasted note lands at `destination.anchorTick` and
+ * every other note keeps its relative offset. A pasted note that ends up
+ * crossing a measure boundary is split into tied segments, matching
+ * `moveNotesCommand`. Ids are regenerated so pasted notes never collide
+ * with their source.
+ */
+export function pasteEventsCommand(notes, destination, label) {
+    return transformCommand(label, score => pasteEvents(score, notes, destination));
+}
+// ---- quantizeCommand -----------------------------------------------------------
+/** Clips `event` to fit within `measure`'s span, or returns `null` if that leaves no positive duration. */
+function clipToMeasure(event, measureStart, measureEnd) {
+    const start = Math.max(event.startTick, measureStart);
+    const end = Math.min(event.startTick + event.durationTicks, measureEnd);
+    if (end <= start)
+        return null;
+    return { ...event, startTick: start, durationTicks: end - start };
+}
+/**
+ * The cheap, non-quantizing "which voices does this selection touch, and
+ * what are their current notes" pass of quantization: walks the score once
+ * and collects one `QuantizeTarget` per voice containing at least one of
+ * `eventIds`. Split out from `quantizeCommand`'s transform so the
+ * intent layer (`editing.ts`'s `quantizeSelection`, `interactions.ts`'s
+ * `commitQuantize`) can run this synchronously to decide *how much* work a
+ * quantize action actually implies (spec §29: route a manual quantize of
+ * >2000 events through `services/quantization/quantize-service.ts`'s
+ * worker) before committing to the expensive `quantizeEvents` call either
+ * on the main thread or off it — without duplicating this measure/voice
+ * walk in two places.
+ */
+export function collectQuantizeTargets(score, eventIds) {
+    const idSet = new Set(eventIds);
+    const targets = [];
+    for (const track of score.tracks) {
+        for (const measure of track.measures) {
+            for (const voice of measure.voices) {
+                if (!voice.events.some(e => idSet.has(e.id)))
+                    continue;
+                targets.push({
+                    trackId: track.id,
+                    measureId: measure.id,
+                    voiceId: voice.id,
+                    notes: voice.events.filter(isNoteEvent),
+                });
+            }
+        }
+    }
+    return targets;
+}
+/**
+ * Splices each target's already-quantized notes (`quantizedByVoiceId`,
+ * keyed by `QuantizeTarget.voiceId` — computed by the caller via
+ * `quantizeEvents`) back into `score`: clips each note back to its measure's span, then
+ * `reflowVoice` regenerates that voice's rests around the result. This
+ * keeps quantization measure-local (no cross-measure re-splitting), a
+ * deliberate Task 5 scope limitation documented in the original brief.
+ * A target whose `voiceId` has no entry in `quantizedByVoiceId` is treated
+ * as "nothing computed for it" (splices in an empty note list) — the
+ * sole caller (`quantize`, below) always populates every target's key
+ * before calling this.
+ */
+export function applyQuantizedGroups(score, targets, quantizedByVoiceId) {
+    const targetsByTrackMeasure = new Map();
+    for (const target of targets) {
+        const key = `${target.trackId}::${target.measureId}`;
+        const list = targetsByTrackMeasure.get(key);
+        if (list)
+            list.push(target);
+        else
+            targetsByTrackMeasure.set(key, [target]);
+    }
+    const tracks = score.tracks.map(track => {
+        const measures = track.measures.map(measure => {
+            const measureTargets = targetsByTrackMeasure.get(`${track.id}::${measure.id}`);
+            if (!measureTargets)
+                return measure;
+            let nextMeasure = measure;
+            const measureEnd = measure.startTick + measure.durationTicks;
+            for (const target of measureTargets) {
+                const quantizedNotes = (quantizedByVoiceId.get(target.voiceId) ?? [])
+                    .map(e => clipToMeasure(e, measure.startTick, measureEnd))
+                    .filter((e) => e !== null);
+                const withQuantized = {
+                    ...nextMeasure,
+                    voices: nextMeasure.voices.map(v => v.id === target.voiceId ? { ...v, events: quantizedNotes } : v),
+                };
+                nextMeasure = reflowVoice(withQuantized, target.voiceId, track.id);
+            }
+            return nextMeasure;
+        });
+        const trackChanged = measures.some((m, i) => m !== track.measures[i]);
+        return trackChanged ? { ...track, measures } : track;
+    });
+    return withTracks(score, tracks);
+}
+/**
+ * Quantizes the voice(s) containing any of `eventIds`, calling
+ * `quantizeEvents` synchronously for every touched voice.
+ *
+ * This is the only path. A >2000-event selection used to be routed through a
+ * worker instead, via a precomputed-groups variant of this command; that was
+ * removed once the offload was measured at 0.57ms of saved work against a
+ * structured clone of the whole event array in each direction.
+ */
+function quantize(score, eventIds, options) {
+    const targets = collectQuantizeTargets(score, eventIds);
+    const quantizedByVoiceId = new Map(targets.map(t => [t.voiceId, quantizeEvents(t.notes, options)]));
+    return applyQuantizedGroups(score, targets, quantizedByVoiceId);
+}
+/** Quantizes every voice containing at least one of `eventIds`, per Task 4's reusable quantization engine. */
+export function quantizeCommand(eventIds, options, label) {
+    return transformCommand(label, score => quantize(score, eventIds, options));
+}
+// ---- transposeCommand -----------------------------------------------------------
+function transpose(score, eventIds, semitones) {
+    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)))
+                    return voice;
+                return {
+                    ...voice,
+                    events: voice.events.map(event => isNoteEvent(event) && idSet.has(event.id)
+                        ? {
+                            ...event,
+                            pitch: transposePitch(event.pitch, semitones, measure.keySignature),
+                        }
+                        : event),
+                };
+            });
+            const measureChanged = voices.some((v, i) => v !== measure.voices[i]);
+            return measureChanged ? { ...measure, voices } : measure;
+        });
+        const trackChanged = measures.some((m, i) => m !== track.measures[i]);
+        return trackChanged ? { ...track, measures } : track;
+    });
+    return withTracks(score, tracks);
+}
+/** Transposes the given notes by `semitones`, re-spelling each per its own measure's key signature. */
+export function transposeCommand(eventIds, semitones, label) {
+    return transformCommand(label, score => transpose(score, eventIds, semitones));
+}
+//# sourceMappingURL=edit-commands.js.map

package/dist/domain/commands/edit-commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-commands.js","sourceRoot":"","sources":["../../../src/domain/commands/edit-commands.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAO3D,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAG7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAU3E,SAAS,WAAW,CAClB,KAAY,EACZ,KAA2B,EAC3B,WAA6B;IAE7B,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,WAAW,CAAC,OAAO,CAAC,CAAC;IACnE,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAE/C,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC7D,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAExD,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,WAAW,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC;QAC1E,MAAM,WAAW,GAAc;YAC7B,GAAG,IAAI;YACP,EAAE,EAAE,QAAQ,EAAE;YACd,SAAS;YACT,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,QAAQ,EAAE,SAAS;YACnB,OAAO,EAAE,SAAS;SACnB,CAAC;QACF,MAAM,QAAQ,GAAG,uBAAuB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QAClE,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,OAAO,GAAG,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE,OAAO,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAkB,EAClB,WAA6B,EAC7B,KAAa;IAEb,OAAO,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CACrC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,CACvC,CAAC;AACJ,CAAC;AAED,mFAAmF;AAEnF,2GAA2G;AAC3G,SAAS,aAAa,CACpB,KAAmB,EACnB,YAAoB,EACpB,UAAkB;IAElB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IACtD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACxE,IAAI,GAAG,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,GAAG,KAAK,EAAE,CAAC;AACpE,CAAC;AAmBD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAY,EACZ,QAAyB;IAEzB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChC,MAAM,OAAO,GAAqB,EAAE,CAAC;IACrC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;gBACnC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBAAE,SAAS;gBACvD,OAAO,CAAC,IAAI,CAAC;oBACX,OAAO,EAAE,KAAK,CAAC,EAAE;oBACjB,SAAS,EAAE,OAAO,CAAC,EAAE;oBACrB,OAAO,EAAE,KAAK,CAAC,EAAE;oBACjB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC;iBACxC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAY,EACZ,OAAkC,EAClC,kBAAqD;IAErD,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAA4B,CAAC;IAClE,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACrD,MAAM,IAAI,GAAG,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC5C,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;YACvB,qBAAqB,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;YAC5C,MAAM,cAAc,GAAG,qBAAqB,CAAC,GAAG,CAC9C,GAAG,KAAK,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,EAAE,CAC7B,CAAC;YACF,IAAI,CAAC,cAAc;gBAAE,OAAO,OAAO,CAAC;YAEpC,IAAI,WAAW,GAAG,OAAO,CAAC;YAC1B,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC;YAC7D,KAAK,MAAM,MAAM,IAAI,cAAc,EAAE,CAAC;gBACpC,MAAM,cAAc,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;qBAClE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;qBACzD,MAAM,CAAC,CAAC,CAAC,EAAqB,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;gBAChD,MAAM,aAAa,GAAG;oBACpB,GAAG,WAAW;oBACd,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACjC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,CAC/D;iBACF,CAAC;gBACF,WAAW,GAAG,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;YACrE,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACtE,OAAO,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC,CAAC,CAAC;IAEH,OAAO,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,QAAQ,CACf,KAAY,EACZ,QAAyB,EACzB,OAAwB;IAExB,MAAM,OAAO,GAAG,sBAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACxD,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAChC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAU,CAAC,CACzE,CAAC;IACF,OAAO,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC;AAClE,CAAC;AAED,8GAA8G;AAC9G,MAAM,UAAU,eAAe,CAC7B,QAAgB,EAChB,OAAwB,EACxB,KAAa;IAEb,OAAO,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED,oFAAoF;AAEpF,SAAS,SAAS,CAChB,KAAY,EACZ,QAAyB,EACzB,SAAiB;IAEjB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;QACtC,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;YAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBACxC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;oBAAE,OAAO,KAAK,CAAC;gBAC3D,OAAO;oBACL,GAAG,KAAK;oBACR,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAC/B,WAAW,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;wBACvC,CAAC,CAAC;4BACE,GAAG,KAAK;4BACR,KAAK,EAAE,cAAc,CACnB,KAAK,CAAC,KAAK,EACX,SAAS,EACT,OAAO,CAAC,YAAY,CACrB;yBACF;wBACH,CAAC,CAAC,KAAK,CACV;iBACF,CAAC;YACJ,CAAC,CAAC,CAAC;YACH,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YACtE,OAAO,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3D,CAAC,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACtE,OAAO,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACvD,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACnC,CAAC;AAED,uGAAuG;AACvG,MAAM,UAAU,gBAAgB,CAC9B,QAAgB,EAChB,SAAiB,EACjB,KAAa;IAEb,OAAO,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CACrC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CACtC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,73 @@
+import type { Accidental, Articulation, DurationName, Pitch, UUID } from '../../index.js';
+import type { ScoreCommand } from './types.js';
+export type AddNoteParams = {
+    trackId: UUID;
+    measureId: UUID;
+    voiceIndex: number;
+    pitch: Pitch;
+    startTick: number;
+    durationTicks: number;
+    velocity?: number;
+    articulation?: Articulation;
+};
+/**
+ * Adds a new note into `params.measureId`'s voice at `params.voiceIndex`,
+ * backfilling rests around it. If the new note overlaps an existing note
+ * in that voice, the overlap is resolved deterministically by
+ * `reflowVoice`'s "replace-on-overlap" rule (see `reflow.ts`): the new
+ * note wins, trimming or dropping whatever it overlaps.
+ *
+ * Only inserted into `params.measureId` itself: if `startTick +
+ * durationTicks` extends past that measure's end, the note is silently
+ * truncated to fit (by `reflowVoice`'s measure-clipping), not split into
+ * tied segments the way `moveNotesCommand`/`pasteEventsCommand` split a
+ * note that crosses a boundary. This is a deliberate, narrower behavior
+ * for `addNoteCommand` specifically (an add always targets one named
+ * measure, unlike a move/paste's computed destination) — callers that
+ * want boundary-spanning insertion should add the note measure-local and
+ * then use `moveNotesCommand`/`resizeNotesCommand` if it needs to extend
+ * further, or split it into per-measure `addNoteCommand` calls themselves.
+ */
+export declare function addNoteCommand(params: AddNoteParams, label: string): ScoreCommand;
+/**
+ * Deletes the given note events, backfilling rests so every affected
+ * measure stays full. If a deleted note was tied to a partner that isn't
+ * also being deleted, that partner's now-dangling tie flag is cleared.
+ */
+export declare function deleteEventsCommand(eventIds: UUID[], label: string): ScoreCommand;
+export type MoveNotesParams = {
+    deltaTicks: number;
+    deltaSemitones: number;
+};
+/**
+ * Moves the given notes by `deltaTicks` (clamped within their track's
+ * existing tick span) and transposes them by `deltaSemitones`. A note
+ * whose new position crosses a measure boundary is split into tied
+ * segments (Task 3's `splitNoteAcrossMeasures`); any pre-existing tie
+ * flags on the moved note are cleared first, since its former tie
+ * partner(s) are no longer necessarily adjacent after the move. If a
+ * moved note was tied to a partner that isn't also being moved, that
+ * partner's now-dangling tie flag is cleared too.
+ */
+export declare function moveNotesCommand(eventIds: UUID[], params: MoveNotesParams, label: string): ScoreCommand;
+/**
+ * Sets the given notes' duration to `durationTicks` (a raw tick length,
+ * e.g. from a piano-roll drag-resize), clamped to fit within each note's
+ * current measure (no cross-measure re-splitting), then reflows.
+ */
+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 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;
+/** 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

@@ -0,0 +1 @@
+{"version":3,"file":"note-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/note-commands.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EAEZ,KAAK,EAGL,IAAI,EACL,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AA+C/C,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;AAcD;;;;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;AAID,0DAA0D;AAC1D,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,IAAI,EAAE,EAChB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAED,8CAA8C;AAC9C,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,IAAI,EAAE,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAED,0FAA0F;AAC1F,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,IAAI,EAAE,EAChB,YAAY,EAAE,YAAY,GAAG,SAAS,EACtC,KAAK,EAAE,MAAM,GACZ,YAAY,CASd;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,IAAI,EAAE,EAChB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,GACZ,YAAY,CAOd;AAED,0DAA0D;AAC1D,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,IAAI,EAAE,EAChB,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,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

@@ -0,0 +1,292 @@
+/**
+ * Note-editing command factories (spec §7, §14). Each factory returns a
+ * `ScoreCommand` built via `transformCommand`, wrapping a pure
+ * `(Score) => Score` transform so undo (via Immer patches) is free and
+ * structurally guaranteed to be a deep-equal inverse of execute.
+ *
+ * Every transform here keeps measures valid: `reflowVoice` (see
+ * `reflow.ts`) fills gaps with rests and trims overflow after any note is
+ * added, removed, resized, or relocated, and `moveNotesCommand` splits a
+ * 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';
+// ---- shared traversal helpers ------------------------------------------------
+/**
+ * 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`).
+ */
+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)))
+                    return voice;
+                return {
+                    ...voice,
+                    events: voice.events.map(event => isNoteEvent(event) && idSet.has(event.id) ? updater(event) : event),
+                };
+            });
+            const measureChanged = voices.some((v, i) => v !== measure.voices[i]);
+            return measureChanged ? { ...measure, voices } : measure;
+        });
+        const trackChanged = measures.some((m, i) => m !== track.measures[i]);
+        return trackChanged ? { ...track, measures } : track;
+    });
+    return withTracks(score, tracks);
+}
+function addNote(score, params) {
+    const tracks = score.tracks.map(track => {
+        if (track.id !== params.trackId)
+            return track;
+        const measureExists = track.measures.some(m => m.id === params.measureId);
+        if (!measureExists)
+            return track;
+        const note = {
+            id: createId(),
+            pitch: params.pitch,
+            startTick: params.startTick,
+            durationTicks: params.durationTicks,
+            velocity: params.velocity ?? 80,
+            voiceId: '', // renumbered by insertNoteIntoTrack to the destination voice's id
+            trackId: track.id,
+            ...(params.articulation ? { articulation: params.articulation } : {}),
+        };
+        return insertNoteIntoTrack(track, note, params.voiceIndex);
+    });
+    return withTracks(score, tracks);
+}
+/**
+ * Adds a new note into `params.measureId`'s voice at `params.voiceIndex`,
+ * backfilling rests around it. If the new note overlaps an existing note
+ * in that voice, the overlap is resolved deterministically by
+ * `reflowVoice`'s "replace-on-overlap" rule (see `reflow.ts`): the new
+ * note wins, trimming or dropping whatever it overlaps.
+ *
+ * Only inserted into `params.measureId` itself: if `startTick +
+ * durationTicks` extends past that measure's end, the note is silently
+ * truncated to fit (by `reflowVoice`'s measure-clipping), not split into
+ * tied segments the way `moveNotesCommand`/`pasteEventsCommand` split a
+ * note that crosses a boundary. This is a deliberate, narrower behavior
+ * for `addNoteCommand` specifically (an add always targets one named
+ * measure, unlike a move/paste's computed destination) — callers that
+ * want boundary-spanning insertion should add the note measure-local and
+ * then use `moveNotesCommand`/`resizeNotesCommand` if it needs to extend
+ * further, or split it into per-measure `addNoteCommand` calls themselves.
+ */
+export function addNoteCommand(params, label) {
+    return transformCommand(label, score => addNote(score, params));
+}
+// ---- deleteEventsCommand -------------------------------------------------------
+function deleteEvents(score, eventIds) {
+    const idSet = new Set(eventIds);
+    // Clear tie flags left dangling on any surviving partner of a deleted
+    // 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));
+    return withTracks(detied, tracks);
+}
+/**
+ * Deletes the given note events, backfilling rests so every affected
+ * measure stays full. If a deleted note was tied to a partner that isn't
+ * also being deleted, that partner's now-dangling tie flag is cleared.
+ */
+export function deleteEventsCommand(eventIds, label) {
+    return transformCommand(label, score => deleteEvents(score, eventIds));
+}
+function moveNotesOnTrack(track, eventIds, params) {
+    const toMove = [];
+    track.measures.forEach(measure => {
+        measure.voices.forEach((voice, voiceIndex) => {
+            voice.events.forEach(event => {
+                if (isNoteEvent(event) && eventIds.has(event.id))
+                    toMove.push({ note: event, voiceIndex });
+            });
+        });
+    });
+    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);
+    const lastMeasure = working.measures[working.measures.length - 1];
+    const trackEnd = lastMeasure
+        ? lastMeasure.startTick + lastMeasure.durationTicks
+        : 0;
+    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 &&
+            clampedStart < m.startTick + m.durationTicks) ?? lastMeasure;
+        const newPitch = params.deltaSemitones !== 0
+            ? transposePitch(note.pitch, params.deltaSemitones, destMeasure?.keySignature)
+            : note.pitch;
+        const movedNote = {
+            ...note,
+            startTick: clampedStart,
+            pitch: newPitch,
+            tieStart: undefined,
+            tieStop: undefined,
+        };
+        const segments = splitNoteAcrossMeasures(movedNote, boundaries);
+        for (const segment of segments) {
+            working = insertNoteIntoTrack(working, segment, voiceIndex);
+        }
+    }
+    return working;
+}
+function moveNotes(score, eventIds, params) {
+    const idSet = new Set(eventIds);
+    // 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));
+    return withTracks(detied, tracks);
+}
+/**
+ * Moves the given notes by `deltaTicks` (clamped within their track's
+ * existing tick span) and transposes them by `deltaSemitones`. A note
+ * whose new position crosses a measure boundary is split into tied
+ * segments (Task 3's `splitNoteAcrossMeasures`); any pre-existing tie
+ * flags on the moved note are cleared first, since its former tie
+ * partner(s) are no longer necessarily adjacent after the move. If a
+ * moved note was tied to a partner that isn't also being moved, that
+ * partner's now-dangling tie flag is cleared too.
+ */
+export function moveNotesCommand(eventIds, params, label) {
+    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 => {
+            let nextMeasure = measure;
+            let changed = false;
+            for (const voice of measure.voices) {
+                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 => {
+                    if (!idSet.has(e.id))
+                        return e;
+                    const clamped = Math.max(1, Math.min(durationTicks, measureEnd - e.startTick));
+                    return { ...e, durationTicks: clamped };
+                });
+                const withResized = {
+                    ...nextMeasure,
+                    voices: nextMeasure.voices.map(v => v.id === voice.id ? { ...v, events: updatedNotes } : v),
+                };
+                nextMeasure = reflowVoice(withResized, voice.id, track.id);
+            }
+            return changed ? nextMeasure : measure;
+        });
+        const trackChanged = measures.some((m, i) => m !== track.measures[i]);
+        return trackChanged ? { ...track, measures } : track;
+    });
+    return withTracks(score, tracks);
+}
+/**
+ * Sets the given notes' duration to `durationTicks` (a raw tick length,
+ * e.g. from a piano-roll drag-resize), clamped to fit within each note's
+ * current measure (no cross-measure re-splitting), then reflows.
+ */
+export function resizeNotesCommand(eventIds, durationTicks, label) {
+    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)));
+}
+// ---- 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 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] })));
+}
+// ---- changeVoiceCommand -----------------------------------------------------------
+function changeVoice(score, eventIds, targetVoiceIndex) {
+    const idSet = new Set(eventIds);
+    const tracks = score.tracks.map(track => {
+        const measures = track.measures.map(measure => {
+            const matches = [];
+            measure.voices.forEach(voice => {
+                voice.events.forEach(e => {
+                    if (isNoteEvent(e) && idSet.has(e.id))
+                        matches.push(e);
+                });
+            });
+            if (matches.length === 0)
+                return measure;
+            let nextMeasure = measure;
+            for (const voice of measure.voices) {
+                if (!voice.events.some(e => idSet.has(e.id)))
+                    continue;
+                const remaining = voice.events
+                    .filter(isNoteEvent)
+                    .filter(e => !idSet.has(e.id));
+                const withRemoved = {
+                    ...nextMeasure,
+                    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 => ({
+                ...n,
+                voiceId: targetVoice.id,
+            }));
+            nextMeasure = {
+                ...nextMeasure,
+                voices: nextMeasure.voices.map((v, i) => i === targetVoiceIndex
+                    ? { ...v, events: [...existingNotes, ...movedNotes] }
+                    : v),
+            };
+            return reflowVoice(nextMeasure, targetVoice.id, track.id);
+        });
+        const trackChanged = measures.some((m, i) => m !== track.measures[i]);
+        return trackChanged ? { ...track, measures } : track;
+    });
+    return withTracks(score, tracks);
+}
+/** 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));
+}
+//# sourceMappingURL=note-commands.js.map