@sudobility/music_types 0.11.20 → 0.11.21

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

@@ -0,0 +1,108 @@
+/**
+ * Moving notes to another track, another tick, or both.
+ *
+ * `moveNotesCommand` already relocates notes *within* a track. This is the
+ * cross-track case, and it takes the collision rule as a parameter so that a
+ * drag is **one** undo step: composing "clear the span" and "put them there"
+ * from two dispatches would make undo step back through the middle of a
+ * gesture the user experienced as one.
+ */
+import { isNoteEvent } from '../../index.js';
+import { transformCommand } from './snapshot.js';
+import { clearDanglingTies, insertNoteIntoTrack, removeNotesFromTrack, withTracks, } from './reflow.js';
+import { makeRoom } from './ripple-commands.js';
+/** Every note in `score` carrying one of `ids`, with the voice it sat in. */
+function collect(score, ids) {
+    const found = [];
+    for (const track of score.tracks) {
+        for (const measure of track.measures) {
+            measure.voices.forEach((voice, voiceIndex) => {
+                for (const event of voice.events) {
+                    if (isNoteEvent(event) && ids.has(event.id))
+                        found.push({ note: event, voiceIndex });
+                }
+            });
+        }
+    }
+    return found;
+}
+/** The last tick a note of `durationTicks` can start at and still fit in `track`. */
+function lastStart(track, durationTicks) {
+    const last = track.measures[track.measures.length - 1];
+    const end = last ? last.startTick + last.durationTicks : 0;
+    return Math.max(0, end - durationTicks);
+}
+/** Ids of notes on `track` sounding inside `[from, to)` in any of `voices`. */
+function occupantsOf(track, from, to, voices) {
+    const ids = [];
+    for (const measure of track.measures) {
+        measure.voices.forEach((voice, voiceIndex) => {
+            // Voice-scoped: clearing the span across *every* voice would delete the
+            // other line, which is a bug this codebase has already had once.
+            if (!voices.has(voiceIndex))
+                return;
+            for (const event of voice.events) {
+                if (!isNoteEvent(event))
+                    continue;
+                if (event.startTick < to &&
+                    event.startTick + event.durationTicks > from)
+                    ids.push(event.id);
+            }
+        });
+    }
+    return ids;
+}
+function relocateNotes(score, eventIds, params) {
+    const ids = new Set(eventIds);
+    const moving = collect(score, ids);
+    if (moving.length === 0)
+        return score;
+    if (!score.tracks.some(t => t.id === params.targetTrackId))
+        return score;
+    // Partners left behind must not keep a tie to a note that has gone.
+    const detied = clearDanglingTies(score, ids);
+    let working = withTracks(detied, detied.tracks.map(track => removeNotesFromTrack(track, ids)));
+    const target = working.tracks.find(t => t.id === params.targetTrackId);
+    const placed = moving.map(({ note, voiceIndex }) => ({
+        note,
+        voiceIndex,
+        startTick: Math.max(0, Math.min(note.startTick + params.deltaTicks, lastStart(target, note.durationTicks))),
+    }));
+    const from = Math.min(...placed.map(p => p.startTick));
+    const to = Math.max(...placed.map(p => p.startTick + p.note.durationTicks));
+    if (params.collision === 'replace') {
+        const voices = new Set(placed.map(p => p.voiceIndex));
+        const doomed = new Set(occupantsOf(target, from, to, voices));
+        if (doomed.size > 0) {
+            working = withTracks(working, working.tracks.map(t => t.id === params.targetTrackId ? removeNotesFromTrack(t, doomed) : t));
+        }
+    }
+    else if (params.collision === 'ripple') {
+        working = makeRoom(working, params.targetTrackId, from, to - from);
+    }
+    for (const { note, voiceIndex, startTick } of placed) {
+        working = withTracks(working, working.tracks.map(t => t.id === params.targetTrackId
+            ? insertNoteIntoTrack(t, {
+                ...note,
+                trackId: params.targetTrackId,
+                startTick,
+                // The note's former neighbours are not necessarily adjacent
+                // any more, so its tie flags cannot survive the move.
+                tieStart: undefined,
+                tieStop: undefined,
+            }, voiceIndex)
+            : t));
+    }
+    return working;
+}
+/**
+ * Moves `eventIds` onto `params.targetTrackId`, shifted by `params.deltaTicks`.
+ *
+ * Pitch is untouched: a note dragged from flute to cello sounds identical, and
+ * only its player changes. Notes are clamped into the target track rather than
+ * dropped when the shift runs past its end.
+ */
+export function relocateNotesCommand(eventIds, params, label) {
+    return transformCommand(label, score => relocateNotes(score, eventIds, params));
+}
+//# sourceMappingURL=relocate-commands.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relocate-commands.js","sourceRoot":"","sources":["../../../src/domain/commands/relocate-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,UAAU,GACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAahD,6EAA6E;AAC7E,SAAS,OAAO,CAAC,KAAY,EAAE,GAAsB;IACnD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjC,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;gBAC3C,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;oBACjC,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;wBACzC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC5C,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,qFAAqF;AACrF,SAAS,SAAS,CAAC,KAAY,EAAE,aAAqB;IACpD,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,aAAa,CAAC,CAAC;AAC1C,CAAC;AAED,+EAA+E;AAC/E,SAAS,WAAW,CAClB,KAAY,EACZ,IAAY,EACZ,EAAU,EACV,MAA2B;IAE3B,MAAM,GAAG,GAAW,EAAE,CAAC;IACvB,KAAK,MAAM,OAAO,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACrC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;YAC3C,wEAAwE;YACxE,iEAAiE;YACjE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC;gBAAE,OAAO;YACpC,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;gBACjC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;oBAAE,SAAS;gBAClC,IACE,KAAK,CAAC,SAAS,GAAG,EAAE;oBACpB,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,aAAa,GAAG,IAAI;oBAE5C,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACvB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,aAAa,CACpB,KAAY,EACZ,QAAyB,EACzB,MAA2B;IAE3B,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC9B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACnC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,aAAa,CAAC;QAAE,OAAO,KAAK,CAAC;IAEzE,oEAAoE;IACpE,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC7C,IAAI,OAAO,GAAG,UAAU,CACtB,MAAM,EACN,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAC7D,CAAC;IAEF,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,aAAa,CAAE,CAAC;IACxE,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC;QACnD,IAAI;QACJ,UAAU;QACV,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,CAAC,EACD,IAAI,CAAC,GAAG,CACN,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,UAAU,EAClC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,CAAC,CACtC,CACF;KACF,CAAC,CAAC,CAAC;IAEJ,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IACvD,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IAE5E,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;QAC9D,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACpB,OAAO,GAAG,UAAU,CAClB,OAAO,EACP,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACrB,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CACpE,CACF,CAAC;QACJ,CAAC;IACH,CAAC;SAAM,IAAI,MAAM,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;QACzC,OAAO,GAAG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;IACrE,CAAC;IAED,KAAK,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,MAAM,EAAE,CAAC;QACrD,OAAO,GAAG,UAAU,CAClB,OAAO,EACP,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACrB,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,aAAa;YAC3B,CAAC,CAAC,mBAAmB,CACjB,CAAC,EACD;gBACE,GAAG,IAAI;gBACP,OAAO,EAAE,MAAM,CAAC,aAAa;gBAC7B,SAAS;gBACT,4DAA4D;gBAC5D,sDAAsD;gBACtD,QAAQ,EAAE,SAAS;gBACnB,OAAO,EAAE,SAAS;aACnB,EACD,UAAU,CACX;YACH,CAAC,CAAC,CAAC,CACN,CACF,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAClC,QAAgB,EAChB,MAA2B,EAC3B,KAAa;IAEb,OAAO,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CACrC,aAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CACvC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,44 @@
+import type { ScoreCommand } from './types.js';
+import type { Articulation, Pitch, Score, UUID } from '../../index.js';
+export type RippleInsertParams = {
+    trackId: UUID;
+    measureId: UUID;
+    voiceIndex: number;
+    pitch: Pitch;
+    startTick: number;
+    durationTicks: number;
+    articulation?: Articulation;
+};
+/**
+ * `score` with `ticks` of empty time opened up at `atTick` on `trackId`.
+ *
+ * Shared by note entry and paste: both need the same "push this track's later
+ * music out of the way, growing the score if it runs off the end" behaviour,
+ * and duplicating it would let the two drift.
+ */
+export declare function makeRoom(score: Score, trackId: UUID, atTick: number, ticks: number): Score;
+/**
+ * `score` with `ticks` of time removed at `fromTick` on `trackId` — everything
+ * after the gap slides earlier to close it.
+ *
+ * The inverse of `makeRoom`, and what "move the notes behind up" means after a
+ * cut. Measures are deliberately NOT removed: the piece keeps its length and
+ * gains rests at the end, because dropping a bar is a structural edit the user
+ * did not ask for, and it would misalign every other track.
+ *
+ * Notes that start inside the removed span are left where they are rather than
+ * dragged backwards past `fromTick`. A cut removes them first, so in practice
+ * there are none; guarding anyway keeps this honest if it is ever called on a
+ * span that still has content.
+ */
+export declare function closeGap(score: Score, trackId: UUID, fromTick: number, ticks: number): Score;
+/**
+ * Writes a note at `startTick`, moving everything at or after it on the same
+ * track later by the note's own duration.
+ *
+ * Only that track moves. The edited part deliberately shifts against its
+ * accompaniment — that is what inserting into one part means, and it is the
+ * reason the mode exists.
+ */
+export declare function insertWithRippleCommand(params: RippleInsertParams, label: string): ScoreCommand;
+//# sourceMappingURL=ripple-commands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ripple-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/ripple-commands.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,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,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AA4BF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,IAAI,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,KAAK,CAkBP;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,IAAI,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,KAAK,CAkBP;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,MAAM,GACZ,YAAY,CAsBd"}

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

@@ -0,0 +1,104 @@
+/**
+ * Insert that pushes existing music out of the way, rather than overwriting it.
+ *
+ * Separate from `addNoteCommand`, which is measure-local by design ("an add
+ * always targets one named measure"): a ripple spans measures and can lengthen
+ * the score, so folding it into that command would break the contract its
+ * callers rely on.
+ */
+import { appendMeasure } from '../score/factory.js';
+import { allNotes, scoreEndTick } from '../score/queries.js';
+import { addNoteCommand, moveNotesCommand } from './note-commands.js';
+import { transformCommand } from './snapshot.js';
+/**
+ * Room for `neededTicks` more music on `trackId`, adding measures to EVERY
+ * track when the shifted tail would pass the final barline.
+ *
+ * All tracks, not just the edited one: measures are per-track, but the layout
+ * takes each measure's width as the maximum density across tracks at that
+ * index, so a track with more measures than its neighbours would misalign
+ * every barline beneath it.
+ */
+function growToFit(score, trackId, neededTicks) {
+    const lastNoteEnd = allNotes(score)
+        .filter(note => note.trackId === trackId)
+        .reduce((end, note) => Math.max(end, note.startTick + note.durationTicks), 0);
+    let next = score;
+    // Bounded by the arithmetic, not by trust: each pass adds a whole measure,
+    // so the shortfall strictly shrinks.
+    while (lastNoteEnd + neededTicks > scoreEndTick(next)) {
+        next = appendMeasure(next);
+    }
+    return next;
+}
+/**
+ * `score` with `ticks` of empty time opened up at `atTick` on `trackId`.
+ *
+ * Shared by note entry and paste: both need the same "push this track's later
+ * music out of the way, growing the score if it runs off the end" behaviour,
+ * and duplicating it would let the two drift.
+ */
+export function makeRoom(score, trackId, atTick, ticks) {
+    const grown = growToFit(score, trackId, ticks);
+    // Gathered by id rather than by span: `moveNotesCommand` is the primitive
+    // that already knows how to re-place notes and reflow their measures.
+    const displaced = allNotes(grown)
+        .filter(note => note.trackId === trackId && note.startTick >= atTick)
+        .map(note => note.id);
+    if (displaced.length === 0)
+        return grown;
+    return moveNotesCommand(displaced, {
+        deltaTicks: ticks,
+        deltaSemitones: 0,
+    }, 'Move notes').execute(grown);
+}
+/**
+ * `score` with `ticks` of time removed at `fromTick` on `trackId` — everything
+ * after the gap slides earlier to close it.
+ *
+ * The inverse of `makeRoom`, and what "move the notes behind up" means after a
+ * cut. Measures are deliberately NOT removed: the piece keeps its length and
+ * gains rests at the end, because dropping a bar is a structural edit the user
+ * did not ask for, and it would misalign every other track.
+ *
+ * Notes that start inside the removed span are left where they are rather than
+ * dragged backwards past `fromTick`. A cut removes them first, so in practice
+ * there are none; guarding anyway keeps this honest if it is ever called on a
+ * span that still has content.
+ */
+export function closeGap(score, trackId, fromTick, ticks) {
+    if (ticks <= 0)
+        return score;
+    const displaced = allNotes(score)
+        .filter(note => note.trackId === trackId && note.startTick >= fromTick + ticks)
+        .map(note => note.id);
+    if (displaced.length === 0)
+        return score;
+    return moveNotesCommand(displaced, {
+        deltaTicks: -ticks,
+        deltaSemitones: 0,
+    }, 'Move notes').execute(score);
+}
+/**
+ * Writes a note at `startTick`, moving everything at or after it on the same
+ * track later by the note's own duration.
+ *
+ * Only that track moves. The edited part deliberately shifts against its
+ * accompaniment — that is what inserting into one part means, and it is the
+ * reason the mode exists.
+ */
+export function insertWithRippleCommand(params, label) {
+    return transformCommand(label, score => {
+        const shifted = makeRoom(score, params.trackId, params.startTick, params.durationTicks);
+        return addNoteCommand({
+            trackId: params.trackId,
+            measureId: params.measureId,
+            voiceIndex: params.voiceIndex,
+            pitch: params.pitch,
+            startTick: params.startTick,
+            durationTicks: params.durationTicks,
+            ...(params.articulation ? { articulation: params.articulation } : {}),
+        }, 'Add note').execute(shifted);
+    });
+}
+//# sourceMappingURL=ripple-commands.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ripple-commands.js","sourceRoot":"","sources":["../../../src/domain/commands/ripple-commands.ts"],"names":[],"mappings":"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"}

package/dist/domain/commands/snapshot.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generic `ScoreCommand` builders backed by Immer patches (Task 5 brief).
+ * `snapshotCommand` records, at each `execute` call, the forward/inverse
+ * patches between the score it's given and the result of running `mutate`
+ * over an Immer draft of it; `undo` replays the inverse patches. Because
+ * Immer's patches are derived mechanically from the actual before/after
+ * trees, `execute` then `undo` is guaranteed to reproduce a deep-equal
+ * score for *any* `mutate`, however structurally involved — command
+ * factories don't need to hand-write inverse logic.
+ *
+ * `execute` is re-run (recomputing patches against whatever score it's
+ * given) every time it's called, so a command replayed via
+ * `HistoryManager.redo` after an intervening `undo` still produces correct
+ * patches for a subsequent `undo`, as long as `undo` is always called with
+ * the exact score `execute` most recently returned (the standard linear
+ * undo-stack contract `HistoryManager` relies on).
+ */
+import type { Draft } from 'immer';
+import type { Score } from '../../index.js';
+import type { CommandKind, ScoreCommand } from './types.js';
+/**
+ * Builds a `ScoreCommand` whose forward/inverse changes are computed by
+ * running `mutate` over an Immer draft of the score. `label` is fixed at
+ * construction time (per `ScoreCommand`); `mutate` may close over whatever
+ * parameters the command needs (event ids, new values, etc.), captured at
+ * construction.
+ */
+export declare function snapshotCommand(label: string, mutate: (draft: Draft<Score>) => void, kind?: CommandKind): ScoreCommand;
+/**
+ * Convenience wrapper over `snapshotCommand` for the common case where a
+ * command's actual logic is easiest to write as an ordinary pure
+ * `(Score) => Score` function (most factories in this module): `transform`
+ * runs against a plain snapshot of the current draft (via Immer's
+ * `current`), and its result is adopted wholesale as the new draft state,
+ * so `mutate`'s Immer-facing bookkeeping stays out of each factory.
+ */
+export declare function transformCommand(label: string, transform: (score: Score) => Score, kind?: CommandKind): ScoreCommand;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/domain/commands/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,KAAK,EAAS,MAAM,OAAO,CAAC;AAQ1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI5D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,EACrC,IAAI,GAAE,WAAuB,GAC5B,YAAY,CAkBd;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,EAClC,IAAI,GAAE,WAAuB,GAC5B,YAAY,CASd"}

package/dist/domain/commands/snapshot.js

@@ -0,0 +1,44 @@
+import { applyPatches, current, enablePatches, produceWithPatches, } from 'immer';
+import { createId } from '../score/ids.js';
+enablePatches();
+/**
+ * Builds a `ScoreCommand` whose forward/inverse changes are computed by
+ * running `mutate` over an Immer draft of the score. `label` is fixed at
+ * construction time (per `ScoreCommand`); `mutate` may close over whatever
+ * parameters the command needs (event ids, new values, etc.), captured at
+ * construction.
+ */
+export function snapshotCommand(label, mutate, kind = 'content') {
+    let inversePatches = null;
+    return {
+        id: createId(),
+        label,
+        timestamp: Date.now(),
+        kind,
+        execute(score) {
+            const [next, , inverse] = produceWithPatches(score, mutate);
+            inversePatches = inverse;
+            return next;
+        },
+        undo(score) {
+            if (!inversePatches)
+                return score;
+            return applyPatches(score, inversePatches);
+        },
+    };
+}
+/**
+ * Convenience wrapper over `snapshotCommand` for the common case where a
+ * command's actual logic is easiest to write as an ordinary pure
+ * `(Score) => Score` function (most factories in this module): `transform`
+ * runs against a plain snapshot of the current draft (via Immer's
+ * `current`), and its result is adopted wholesale as the new draft state,
+ * so `mutate`'s Immer-facing bookkeeping stays out of each factory.
+ */
+export function transformCommand(label, transform, kind = 'content') {
+    return snapshotCommand(label, draft => {
+        const next = transform(current(draft));
+        Object.assign(draft, next);
+    }, kind);
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/domain/commands/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../../src/domain/commands/snapshot.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,YAAY,EACZ,OAAO,EACP,aAAa,EACb,kBAAkB,GACnB,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAI3C,aAAa,EAAE,CAAC;AAEhB;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAa,EACb,MAAqC,EACrC,OAAoB,SAAS;IAE7B,IAAI,cAAc,GAAmB,IAAI,CAAC;IAE1C,OAAO;QACL,EAAE,EAAE,QAAQ,EAAE;QACd,KAAK;QACL,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;QACrB,IAAI;QACJ,OAAO,CAAC,KAAY;YAClB,MAAM,CAAC,IAAI,EAAE,AAAD,EAAG,OAAO,CAAC,GAAG,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC5D,cAAc,GAAG,OAAO,CAAC;YACzB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,KAAY;YACf,IAAI,CAAC,cAAc;gBAAE,OAAO,KAAK,CAAC;YAClC,OAAO,YAAY,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAa,EACb,SAAkC,EAClC,OAAoB,SAAS;IAE7B,OAAO,eAAe,CACpB,KAAK,EACL,KAAK,CAAC,EAAE;QACN,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAU,CAAC,CAAC;QAChD,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC,EACD,IAAI,CACL,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,38 @@
+import type { CreateTrackOptions } from '../score/factory.js';
+import type { Clef, KeySignature, Measure, ScoreMetadata, TimeSignature, Track, UUID } from '../../index.js';
+import type { ScoreCommand } from './types.js';
+/** Appends one fully-rested measure to every track (reuses Task 3's `appendMeasure`). */
+export declare function addMeasureCommand(label: string): ScoreCommand;
+/** Removes the measure at `measureIndex` from every track, retracking subsequent measures' ticks. */
+export declare function deleteMeasureCommand(measureIndex: number, label: string): ScoreCommand;
+/** Builds a fully-rested measure matching an existing measure's position/signatures, for a newly added track. */
+export declare function restMeasureLike(reference: Measure, trackId: UUID): Measure;
+/** Adds a new track, fully-rested with the same measure layout (count/signatures) as the score's first existing track. */
+export declare function addTrackCommand(options: CreateTrackOptions, label: string): ScoreCommand;
+/** Removes the track with id `trackId`. */
+export declare function deleteTrackCommand(trackId: UUID, label: string): ScoreCommand;
+/**
+ * Changes one measure's time signature (on every track that has a measure
+ * with that id — normally exactly one, but the search covers every track
+ * defensively). Recomputes the measure's `durationTicks`, reflows its
+ * voices to fit the new length, and retracks every subsequent measure via
+ * `rebuildMeasureTicks`.
+ */
+export declare function changeTimeSignatureCommand(measureId: UUID, timeSignature: TimeSignature, label: string): ScoreCommand;
+/** Changes one measure's key signature. Existing note spellings are left as-is. */
+export declare function changeKeySignatureCommand(measureId: UUID, keySignature: KeySignature, label: string): ScoreCommand;
+/** Changes a track's clef, reinterpreting its program if it crosses into or out of percussion. */
+export declare function changeClefCommand(trackId: UUID, clef: Clef, label: string): ScoreCommand;
+export type ChangeTempoParams = {
+    tempoEventId?: UUID;
+    tick: number;
+    bpm: number;
+};
+/** Updates an existing tempo event (`tempoEventId` given) or inserts a new one, keeping `tempoMap` sorted by tick. */
+export declare function changeTempoCommand(params: ChangeTempoParams, label: string): ScoreCommand;
+/** Patches score metadata (title/composer/description); `createdAt` is immutable, `updatedAt` is always refreshed. */
+export declare function changeMetadataCommand(patch: Partial<Omit<ScoreMetadata, 'createdAt'>>, label: string): ScoreCommand;
+export type TrackPropsPatch = Partial<Omit<Track, 'id' | 'measures'>>;
+/** Patches a track's non-structural properties (name, instrument, MIDI program/channel, clef, volume, pan, mute, solo). */
+export declare function changeTrackPropsCommand(trackId: UUID, patch: TrackPropsPatch, label: string): ScoreCommand;
+//# sourceMappingURL=structure-commands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structure-commands.d.ts","sourceRoot":"","sources":["../../../src/domain/commands/structure-commands.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D,OAAO,KAAK,EACV,IAAI,EACJ,YAAY,EACZ,OAAO,EAEP,aAAa,EAEb,aAAa,EACb,KAAK,EACL,IAAI,EACL,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,YAAY,CAAC;AAM5D,yFAAyF;AACzF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAE7D;AAYD,qGAAqG;AACrG,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAID,iHAAiH;AACjH,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,GAAG,OAAO,CAyB1E;AAeD,0HAA0H;AAC1H,wBAAgB,eAAe,CAC7B,OAAO,EAAE,kBAAkB,EAC3B,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAOD,2CAA2C;AAC3C,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAE7E;AA4BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,IAAI,EACf,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAiBD,mFAAmF;AACnF,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,IAAI,EACf,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,MAAM,GACZ,YAAY,CAId;AAqCD,kGAAkG;AAClG,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,IAAI,EACb,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAID,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,IAAI,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAsBF,sHAAsH;AACtH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAkBD,sHAAsH;AACtH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,EAChD,KAAK,EAAE,MAAM,GACZ,YAAY,CAEd;AAID,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC;AA+BtE,2HAA2H;AAC3H,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,MAAM,GACZ,YAAY,CAMd"}

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

@@ -0,0 +1,220 @@
+/**
+ * Structural (measure/track/score-property) command factories (spec §7,
+ * §14). Each factory wraps a pure `(Score) => Score` transform via
+ * `transformCommand`, matching the note-commands.ts pattern.
+ */
+import { appendMeasure, createTrack, rebuildMeasureTicks, } from '../score/factory.js';
+import { gmKitAt } from '../instruments/gm-kit.js';
+import { gmInstrument } from '../instruments/gm.js';
+import { createId } from '../score/ids.js';
+import { measureDurationTicks } from '../time/ticks.js';
+import { transformCommand } from './snapshot.js';
+import { reflowVoice, touchMetadata, withTracks } from './reflow.js';
+// ---- addMeasureCommand / deleteMeasureCommand ----------------------------------
+/** Appends one fully-rested measure to every track (reuses Task 3's `appendMeasure`). */
+export function addMeasureCommand(label) {
+    return transformCommand(label, score => appendMeasure(score));
+}
+function deleteMeasure(score, measureIndex) {
+    const tracks = score.tracks.map(track => {
+        const filtered = track.measures.filter(m => m.index !== measureIndex);
+        return filtered.length === track.measures.length
+            ? track
+            : { ...track, measures: filtered };
+    });
+    return rebuildMeasureTicks(withTracks(score, tracks));
+}
+/** Removes the measure at `measureIndex` from every track, retracking subsequent measures' ticks. */
+export function deleteMeasureCommand(measureIndex, label) {
+    return transformCommand(label, score => deleteMeasure(score, measureIndex));
+}
+// ---- addTrackCommand / deleteTrackCommand --------------------------------------
+/** Builds a fully-rested measure matching an existing measure's position/signatures, for a newly added track. */
+export function restMeasureLike(reference, trackId) {
+    const voiceId = createId();
+    return {
+        id: createId(),
+        index: reference.index,
+        startTick: reference.startTick,
+        durationTicks: reference.durationTicks,
+        timeSignature: reference.timeSignature,
+        keySignature: reference.keySignature,
+        voices: [
+            {
+                id: voiceId,
+                name: 'Voice 1',
+                events: [
+                    {
+                        id: createId(),
+                        startTick: reference.startTick,
+                        durationTicks: reference.durationTicks,
+                        voiceId,
+                        trackId,
+                    },
+                ],
+            },
+        ],
+    };
+}
+function addTrack(score, options) {
+    const track = createTrack(options);
+    const referenceTrack = score.tracks[0];
+    const measures = referenceTrack
+        ? referenceTrack.measures.map(m => restMeasureLike(m, track.id))
+        : [];
+    return {
+        ...score,
+        tracks: [...score.tracks, { ...track, measures }],
+        metadata: touchMetadata(score.metadata),
+    };
+}
+/** Adds a new track, fully-rested with the same measure layout (count/signatures) as the score's first existing track. */
+export function addTrackCommand(options, label) {
+    return transformCommand(label, score => addTrack(score, options));
+}
+function deleteTrack(score, trackId) {
+    const tracks = score.tracks.filter(t => t.id !== trackId);
+    return withTracks(score, tracks);
+}
+/** Removes the track with id `trackId`. */
+export function deleteTrackCommand(trackId, label) {
+    return transformCommand(label, score => deleteTrack(score, trackId));
+}
+// ---- changeTimeSignatureCommand / changeKeySignatureCommand -------------------
+function changeTimeSignature(score, measureId, timeSignature) {
+    const tracks = score.tracks.map(track => {
+        const index = track.measures.findIndex(m => m.id === measureId);
+        if (index === -1)
+            return track;
+        const measure = track.measures[index];
+        const durationTicks = measureDurationTicks(timeSignature, score.ppq);
+        let updated = { ...measure, timeSignature, durationTicks };
+        for (const voice of updated.voices) {
+            updated = reflowVoice(updated, voice.id, track.id);
+        }
+        const measures = track.measures.slice();
+        measures[index] = updated;
+        return { ...track, measures };
+    });
+    return rebuildMeasureTicks(withTracks(score, tracks));
+}
+/**
+ * Changes one measure's time signature (on every track that has a measure
+ * with that id — normally exactly one, but the search covers every track
+ * defensively). Recomputes the measure's `durationTicks`, reflows its
+ * voices to fit the new length, and retracks every subsequent measure via
+ * `rebuildMeasureTicks`.
+ */
+export function changeTimeSignatureCommand(measureId, timeSignature, label) {
+    return transformCommand(label, score => changeTimeSignature(score, measureId, timeSignature));
+}
+function changeKeySignature(score, measureId, keySignature) {
+    const tracks = score.tracks.map(track => {
+        const index = track.measures.findIndex(m => m.id === measureId);
+        if (index === -1)
+            return track;
+        const measures = track.measures.slice();
+        measures[index] = { ...measures[index], keySignature };
+        return { ...track, measures };
+    });
+    return withTracks(score, tracks);
+}
+/** Changes one measure's key signature. Existing note spellings are left as-is. */
+export function changeKeySignatureCommand(measureId, keySignature, label) {
+    return transformCommand(label, score => changeKeySignature(score, measureId, keySignature));
+}
+// ---- changeClefCommand -----------------------------------------------------------
+function changeClef(score, trackId, clef) {
+    const tracks = score.tracks.map(t => t.id === trackId ? { ...t, clef, ...programForClef(t, clef) } : t);
+    return withTracks(score, tracks);
+}
+/**
+ * The program a track should carry once its clef is `clef`.
+ *
+ * `midiProgram` addresses a drum kit on a percussion track and an instrument
+ * anywhere else, so crossing that boundary reinterprets the number it already
+ * holds. Going in, it is snapped to the kit whose region it falls in; coming
+ * out, it is reset to Acoustic Grand, because a kit address as an instrument is
+ * whatever program happens to sit there — Brush becomes a violin. `name` is
+ * deliberately left alone: it is the user's, unlike `instrumentName`, which
+ * describes the sound and so has to follow it.
+ */
+function programForClef(track, clef) {
+    const wasPercussion = track.clef === 'percussion';
+    const isPercussion = clef === 'percussion';
+    if (wasPercussion === isPercussion)
+        return {};
+    if (isPercussion) {
+        const kit = gmKitAt(track.midiProgram);
+        return { midiProgram: kit.program, instrumentName: kit.name };
+    }
+    const instrument = gmInstrument(0);
+    return {
+        midiProgram: 0,
+        instrumentName: instrument?.name ?? 'Acoustic Grand Piano',
+    };
+}
+/** Changes a track's clef, reinterpreting its program if it crosses into or out of percussion. */
+export function changeClefCommand(trackId, clef, label) {
+    return transformCommand(label, score => changeClef(score, trackId, clef));
+}
+function changeTempo(score, params) {
+    const tempoMap = params.tempoEventId
+        ? score.tempoMap.map(e => e.id === params.tempoEventId
+            ? { ...e, tick: params.tick, bpm: params.bpm }
+            : e)
+        : [
+            ...score.tempoMap,
+            { id: createId(), tick: params.tick, bpm: params.bpm },
+        ];
+    const sorted = [...tempoMap].sort((a, b) => a.tick - b.tick);
+    return {
+        ...score,
+        tempoMap: sorted,
+        metadata: touchMetadata(score.metadata),
+    };
+}
+/** Updates an existing tempo event (`tempoEventId` given) or inserts a new one, keeping `tempoMap` sorted by tick. */
+export function changeTempoCommand(params, label) {
+    return transformCommand(label, score => changeTempo(score, params));
+}
+// ---- changeMetadataCommand --------------------------------------------------------
+function changeMetadata(score, patch) {
+    return {
+        ...score,
+        metadata: {
+            ...score.metadata,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        },
+    };
+}
+/** Patches score metadata (title/composer/description); `createdAt` is immutable, `updatedAt` is always refreshed. */
+export function changeMetadataCommand(patch, label) {
+    return transformCommand(label, score => changeMetadata(score, patch));
+}
+function changeTrackProps(score, trackId, patch) {
+    const tracks = score.tracks.map(t => t.id === trackId ? { ...t, ...patch } : t);
+    return withTracks(score, tracks);
+}
+/**
+ * The track properties that are mixing rather than music.
+ *
+ * `changeTrackPropsCommand` carries a partial patch and serves both purposes —
+ * `{ muted }` is mixing, `{ name }` and `{ midiProgram }` are the score — so
+ * the content/mix classification cannot be made on the command's type. It is
+ * made here, where the patch is, rather than in a switch elsewhere that would
+ * have to be kept in step with this list.
+ */
+const MIX_PROPS = new Set(['volume', 'pan', 'muted', 'solo']);
+/** A patch is mix only if *every* key in it is. An empty patch changes nothing, so it counts as mix. */
+function trackPatchKind(patch) {
+    return Object.keys(patch).every(key => MIX_PROPS.has(key))
+        ? 'mix'
+        : 'content';
+}
+/** Patches a track's non-structural properties (name, instrument, MIDI program/channel, clef, volume, pan, mute, solo). */
+export function changeTrackPropsCommand(trackId, patch, label) {
+    return transformCommand(label, score => changeTrackProps(score, trackId, patch), trackPatchKind(patch));
+}
+//# sourceMappingURL=structure-commands.js.map