@scorelabs/core 1.0.10 → 1.0.13

package/dist/models/Score.d.ts

@@ -1,8 +1,8 @@
-import { Measure } from './Measure';
-import { NoteSet } from './NoteSet';
-import { Part, PartJSON } from './Part';
-import { Staff } from './Staff';
-import { Clef, Duration, Genre, KeySignature, TimeSignature } from './types';
+import { Measure } from './Measure.js';
+import { NoteSet } from './NoteSet.js';
+import { Part, PartJSON } from './Part.js';
+import { Staff } from './Staff.js';
+import { Clef, Duration, Genre, KeySignature, TimeSignature } from './types.js';
 /**
  * Represents a complete musical score.
  */
@@ -14,18 +14,19 @@ export declare class Score {
     readonly parts: Part[];
     readonly bpm: number;
     readonly tempoDuration: Duration;
-    readonly tempoIsDotted: boolean;
     readonly copyright: string;
     readonly lyricist: string;
     readonly swing: boolean;
     readonly subtitle: string;
     readonly genre: Genre;
     readonly tempoText: string;
-    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre, tempoText?: string);
+    readonly tempoDotCount: number;
+    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre, tempoText?: string, tempoDotCount?: number);
     withTitle(title: string): Score;
     withComposer(composer: string): Score;
     withSubtitle(subtitle: string): Score;
     withGenre(genre: Genre): Score;
+    withBpm(bpm: number): Score;
     getMeasureCount(): number;
     getTimeSignatureAt(measureIndex: number): TimeSignature;
     getKeySignatureAt(measureIndex: number): KeySignature;
@@ -55,9 +56,10 @@ export declare class Score {
     private reflowStaff;
     replaceMeasure(partIndex: number, staffIndex: number, measureIndex: number, newMeasure: Measure, autoBeam?: boolean): Score;
     deleteNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, voiceIndex?: number): Score;
-    changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Score;
+    changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, dotCount?: number, voiceIndex?: number): Score;
+    moveNoteToVoice(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, fromVoiceIndex: number, toVoiceIndex: number): Score;
     pasteNotes(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, notesToPaste: NoteSet[]): Score;
-    withTempo(bpm: number, duration: Duration, isDotted: boolean): Score;
+    withTempo(bpm: number, duration: Duration, dotCount?: number): Score;
     withTempoText(text: string): Score;
     withSwing(swing: boolean): Score;
     withLyricist(lyricist: string): Score;
@@ -70,6 +72,7 @@ export declare class Score {
     replaceStaff(partIndex: number, staffIndex: number, newStaff: Staff): Score;
     addMeasure(index: number, measure: Measure): Score;
     deleteMeasure(index: number): Score;
+    deleteMeasures(startIndex: number, endIndex: number): Score;
     getPlaybackSequence(): number[];
 }
 export interface ScoreJSON {
@@ -80,6 +83,7 @@ export interface ScoreJSON {
     parts: PartJSON[];
     bpm?: number;
     tempoDuration?: Duration;
+    tempoDotCount?: number;
     tempoIsDotted?: boolean;
     copyright?: string;
     lyricist?: string;

package/dist/models/Score.js

@@ -1,6 +1,6 @@
-import { Measure } from './Measure';
-import { Part } from './Part';
-import { Duration, Genre, decomposeDuration } from './types';
+import { Measure } from './Measure.js';
+import { Part } from './Part.js';
+import { Duration, Genre, decomposeDuration } from './types.js';
 /**
  * Represents a complete musical score.
  */
@@ -12,14 +12,14 @@ export class Score {
     parts;
     bpm;
     tempoDuration;
-    tempoIsDotted;
     copyright;
     lyricist;
     swing;
     subtitle;
     genre;
     tempoText;
-    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, tempoIsDotted = false, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown, tempoText = '') {
+    tempoDotCount;
+    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown, tempoText = '', tempoDotCount = 0) {
         this.title = title;
         this.composer = composer;
         this.timeSignature = timeSignature;
@@ -27,25 +27,28 @@ export class Score {
         this.parts = parts;
         this.bpm = bpm;
         this.tempoDuration = tempoDuration;
-        this.tempoIsDotted = tempoIsDotted;
         this.copyright = copyright;
         this.lyricist = lyricist;
         this.swing = swing;
         this.subtitle = subtitle;
         this.genre = genre;
         this.tempoText = tempoText;
+        this.tempoDotCount = tempoDotCount;
     }
     withTitle(title) {
-        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withComposer(composer) {
-        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withSubtitle(subtitle) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withGenre(genre) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, genre, this.tempoText, this.tempoDotCount);
+    }
+    withBpm(bpm) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     getMeasureCount() {
         return this.parts[0]?.getMeasureCount() ?? 0;
@@ -88,7 +91,7 @@ export class Score {
     }
     static fromJSON(data) {
         const parts = data.parts.map((p) => Part.fromJSON(p));
-        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.tempoIsDotted ?? false, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown, data.tempoText ?? '');
+        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown, data.tempoText ?? '', data.tempoDotCount ?? (data.tempoIsDotted ? 1 : 0));
     }
     transpose(semitones) {
         const semitoneToFifths = {
@@ -112,7 +115,7 @@ export class Score {
             newFifths -= 12;
         while (newFifths < -7)
             newFifths += 12;
-        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     replaceNote(partIndex, staffIndex, measureIndex, noteIndex, newNote, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -122,16 +125,15 @@ export class Score {
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
     withKeySignature(keySig) {
-        return new Score(this.title, this.composer, this.timeSignature, keySig, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, keySig, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withTimeSignature(timeSig) {
-        return new Score(this.title, this.composer, timeSig, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, timeSig, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     updateMeasureSignatures(measureIndex, signatures, autoBeam = true) {
-        let score = this;
-        for (let pIdx = 0; pIdx < this.parts.length; pIdx++) {
-            for (let sIdx = 0; sIdx < this.parts[pIdx].staves.length; sIdx++) {
-                const currentMsr = score.parts[pIdx].staves[sIdx].measures[measureIndex];
+        const newParts = this.parts.map((part) => {
+            const newStaves = part.staves.map((staff) => {
+                const currentMsr = staff.measures[measureIndex];
                 if (currentMsr) {
                     let updatedMsr = currentMsr;
                     if (signatures.keySignature !== undefined) {
@@ -143,45 +145,51 @@ export class Score {
                     if (signatures.clef !== undefined) {
                         updatedMsr = updatedMsr.withClef(signatures.clef);
                     }
-                    score = score.replaceMeasure(pIdx, sIdx, measureIndex, updatedMsr, autoBeam);
+                    if (autoBeam) {
+                        const ts = signatures.timeSignature ?? this.getTimeSignatureAt(measureIndex);
+                        updatedMsr = updatedMsr.autoBeam(ts);
+                    }
+                    const newMeasures = [...staff.measures];
+                    newMeasures[measureIndex] = updatedMsr;
+                    return staff.withMeasures(newMeasures);
                 }
-            }
-        }
+                return staff;
+            });
+            return part.withStaves(newStaves);
+        });
+        const newScore = this.withParts(newParts);
         if (signatures.timeSignature !== undefined) {
-            score = score.reflow(measureIndex, autoBeam);
+            return newScore.reflow(measureIndex, autoBeam);
         }
-        return score;
+        return newScore;
     }
     /**
      * Reflows the notes starting from a specific measure index.
      * This is useful when time signatures change and notes need to be redistributed.
      */
     reflow(fromMeasureIndex, autoBeam = true) {
-        let currentScore = this;
         const allStaves = this.getAllStaves();
-        for (const { partIndex, staffIndex } of allStaves) {
-            currentScore = currentScore.reflowStaff(partIndex, staffIndex, fromMeasureIndex, autoBeam);
-        }
+        const scoreAfterReflow = allStaves.reduce((accScore, { partIndex, staffIndex }) => accScore.reflowStaff(partIndex, staffIndex, fromMeasureIndex, autoBeam), this);
         // Harmonize measure count across all staves
-        const maxMeasures = Math.max(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
-        const minMeasures = Math.min(...currentScore.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        const maxMeasures = Math.max(...scoreAfterReflow.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
+        const minMeasures = Math.min(...scoreAfterReflow.parts.flatMap((p) => p.staves.map((s) => s.measures.length)));
         if (maxMeasures !== minMeasures) {
-            for (let pIdx = 0; pIdx < currentScore.parts.length; pIdx++) {
-                for (let sIdx = 0; sIdx < currentScore.parts[pIdx].staves.length; sIdx++) {
-                    const staff = currentScore.parts[pIdx].staves[sIdx];
+            return scoreAfterReflow.parts.reduce((accScore1, part, pIdx) => {
+                return part.staves.reduce((accScore2, staff, sIdx) => {
                     if (staff.measures.length < maxMeasures) {
-                        let updatedMsrs = [...staff.measures];
+                        const updatedMsrs = [...staff.measures];
                         for (let i = staff.measures.length; i < maxMeasures; i++) {
-                            const ts = currentScore.getTimeSignatureAt(i);
+                            const ts = accScore2.getTimeSignatureAt(i);
                             const targetDur = ts.beats * (4 / ts.beatType);
                             updatedMsrs.push(new Measure([[]]).fillVoiceWithRests(0, targetDur));
                         }
-                        currentScore = currentScore.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMsrs));
+                        return accScore2.replaceStaff(pIdx, sIdx, staff.withMeasures(updatedMsrs));
                     }
-                }
-            }
+                    return accScore2;
+                }, accScore1);
+            }, scoreAfterReflow);
         }
-        return currentScore;
+        return scoreAfterReflow;
     }
     isTied(ns) {
         return !!ns.notes[0].tie;
@@ -201,10 +209,10 @@ export class Score {
         const staff = this.parts[pIdx].staves[sIdx];
         const measures = staff.measures;
         const maxVoices = Math.max(...measures.map((m) => m.voices.length), 1);
-        let updatedMeasures = [...measures];
+        const updatedMeasures = [...measures];
         for (let vIdx = 0; vIdx < maxVoices; vIdx++) {
             // 1. Collect notes and merge tied notes into logical streams
-            let stream = [];
+            const stream = [];
             for (let mIdx = fromMeasureIndex; mIdx < measures.length; mIdx++) {
                 const msr = measures[mIdx];
                 const voice = msr.voices[vIdx] || [];
@@ -251,7 +259,7 @@ export class Score {
                     const newNoteSets = parts.map((p, idx) => {
                         const isLastOfLogical = Math.abs(toTake - logicalNote.duration) < 0.001 && idx === parts.length - 1;
                         return logicalNote.ns
-                            .withDuration(p.duration, p.isDotted)
+                            .withDuration(p.duration, p.dotCount)
                             .withTie(isLastOfLogical ? !!logicalNote.ns.notes[0].tie : true);
                     });
                     msr = msr.withVoices(msr.voices.map((v, i) => (i === vIdx ? [...v, ...newNoteSets] : v)));
@@ -295,7 +303,7 @@ export class Score {
         }
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceMeasure(staffIndex, measureIndex, measureToUse);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     deleteNote(partIndex, staffIndex, measureIndex, noteIndex, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -304,88 +312,99 @@ export class Score {
         const updatedMeasure = measure.deleteNote(noteIndex, voiceIndex);
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
-    changeNoteDuration(partIndex, staffIndex, measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(partIndex, staffIndex, measureIndex, noteIndex, newDuration, dotCount = 0, voiceIndex = 0) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
+        const updatedMeasure = measure.changeNoteDuration(noteIndex, newDuration, dotCount, voiceIndex);
+        return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
+    }
+    moveNoteToVoice(partIndex, staffIndex, measureIndex, noteIndex, fromVoiceIndex, toVoiceIndex) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
-        const updatedMeasure = measure.changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        if (!measure)
+            return this;
+        const updatedMeasure = measure.moveNoteToVoice(fromVoiceIndex, noteIndex, toVoiceIndex);
         return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
     }
     pasteNotes(partIndex, staffIndex, measureIndex, noteIndex, notesToPaste) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
-        let newScore = this;
-        let currentMeasureIdx = measureIndex;
-        let currentNoteIdx = noteIndex;
-        const queue = [...notesToPaste];
-        while (queue.length > 0) {
-            const noteToPaste = queue.shift();
-            const part = newScore.parts[partIndex];
+        const state = {
+            score: this,
+            mIdx: measureIndex,
+            nIdx: noteIndex,
+            queue: [...notesToPaste],
+        };
+        while (state.queue.length > 0) {
+            const noteToPaste = state.queue.shift();
+            const part = state.score.parts[partIndex];
             if (!part)
                 break;
             const staff = part.staves[staffIndex];
-            if (!staff || currentMeasureIdx >= staff.measures.length)
+            if (!staff || state.mIdx >= staff.measures.length)
                 break;
-            const measure = staff.measures[currentMeasureIdx];
-            if (currentNoteIdx >= measure.notes.length) {
-                currentMeasureIdx++;
-                currentNoteIdx = 0;
-                queue.unshift(noteToPaste);
+            const measure = staff.measures[state.mIdx];
+            if (state.nIdx >= measure.notes.length) {
+                state.mIdx++;
+                state.nIdx = 0;
+                state.queue.unshift(noteToPaste);
                 continue;
             }
             let available = 0;
-            for (let i = currentNoteIdx; i < measure.notes.length; i++)
+            for (let i = state.nIdx; i < measure.notes.length; i++)
                 available += measure.notes[i].getDurationValue();
             const needed = noteToPaste.getDurationValue();
             if (needed <= available + 0.001) {
-                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste.duration, noteToPaste.isDotted);
-                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste);
-                currentNoteIdx++;
+                state.score = state.score.changeNoteDuration(partIndex, staffIndex, state.mIdx, state.nIdx, noteToPaste.duration, noteToPaste.dotCount);
+                state.score = state.score.replaceNote(partIndex, staffIndex, state.mIdx, state.nIdx, noteToPaste);
+                state.nIdx++;
             }
             else {
                 const parts = decomposeDuration(available);
                 if (parts.length === 0) {
-                    currentMeasureIdx++;
-                    currentNoteIdx = 0;
-                    queue.unshift(noteToPaste);
+                    state.mIdx++;
+                    state.nIdx = 0;
+                    state.queue.unshift(noteToPaste);
                     continue;
                 }
                 const fillPart = parts[0];
                 const filledNote = noteToPaste
-                    .withDuration(fillPart.duration, fillPart.isDotted)
+                    .withDuration(fillPart.duration, fillPart.dotCount)
                     .withTie(true);
-                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, fillPart.duration, fillPart.isDotted);
-                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, filledNote);
+                state.score = state.score.changeNoteDuration(partIndex, staffIndex, state.mIdx, state.nIdx, fillPart.duration, fillPart.dotCount);
+                state.score = state.score.replaceNote(partIndex, staffIndex, state.mIdx, state.nIdx, filledNote);
                 const remainderParts = decomposeDuration(needed - fillPart.val);
                 const remainderNotes = remainderParts.map((p, idx) => {
                     const isLast = idx === remainderParts.length - 1;
                     return noteToPaste
-                        .withDuration(p.duration, p.isDotted)
-                        .withTie(isLast ? !!noteToPaste.tie : true);
+                        .withDuration(p.duration, p.dotCount)
+                        .withTie(isLast ? !!noteToPaste.notes[0].tie : true);
                 });
-                queue.unshift(...remainderNotes);
-                currentNoteIdx++;
+                state.queue.unshift(...remainderNotes);
+                state.nIdx++;
             }
         }
-        return newScore;
+        return state.score;
     }
-    withTempo(bpm, duration, isDotted) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, isDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+    withTempo(bpm, duration, dotCount = 0) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, dotCount);
     }
     withTempoText(text) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, text);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, text, this.tempoDotCount);
     }
     withSwing(swing) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withLyricist(lyricist) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.copyright, lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withCopyright(copyright) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     withParts(parts) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, parts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     toJSON() {
         return {
@@ -396,13 +415,13 @@ export class Score {
             parts: this.parts.map((p) => p.toJSON()),
             bpm: this.bpm,
             tempoDuration: this.tempoDuration,
-            tempoIsDotted: this.tempoIsDotted,
             copyright: this.copyright,
             lyricist: this.lyricist,
             swing: this.swing,
             subtitle: this.subtitle,
             genre: this.genre,
             tempoText: this.tempoText,
+            tempoDotCount: this.tempoDotCount,
         };
     }
     replacePart(partIndex, newPart) {
@@ -410,92 +429,111 @@ export class Score {
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newPart;
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     addPart(newPart) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     removePart(partIndex) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = this.parts.filter((_, i) => i !== partIndex);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     replaceStaff(partIndex, staffIndex, newStaff) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceStaff(staffIndex, newStaff);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     addMeasure(index, measure) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
     }
     deleteMeasure(index) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText, this.tempoDotCount);
+    }
+    deleteMeasures(startIndex, endIndex) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let currentScore = this;
+        const start = Math.min(startIndex, endIndex);
+        const end = Math.max(startIndex, endIndex);
+        for (let i = end; i >= start; i--) {
+            currentScore = currentScore.deleteMeasure(i);
+        }
+        return currentScore;
     }
     getPlaybackSequence() {
         const measures = this.parts[0]?.staves[0]?.measures || [];
         const sequence = [];
         let i = 0;
         const startRepeatStack = [0]; // Implicit start at 0
-        let justJumpedTo = -1;
-        const repeatCount = new Map();
+        const iterationMap = new Map(); // startMeasureIndex -> currentIteration
+        iterationMap.set(0, 1);
+        const repeatJumpCount = new Map(); // endMeasureIndex -> count
         let safetyCounter = 0;
         const MAX_SEQUENCE = 10000;
+        let activeVoltaNumbers = [];
+        let pendingPop = false;
         while (i < measures.length && safetyCounter < MAX_SEQUENCE) {
             safetyCounter++;
             const m = measures[i];
-            // Handle Start Repeats
+            // If we finished a repeat pass but the next measure still has a volta, 
+            // we delay popping the stack so the volta logic can see the correct iteration count.
+            if (pendingPop && !m.volta) {
+                if (startRepeatStack.length > 1) {
+                    startRepeatStack.pop();
+                }
+                pendingPop = false;
+            }
+            // 1. Handle Start Repeat
             if (m.repeats.some((r) => r.type === 'start')) {
-                // Only push if we didn't just jump here (avoid re-pushing on loop reentry)
-                if (i !== justJumpedTo) {
+                if (startRepeatStack[startRepeatStack.length - 1] !== i) {
                     startRepeatStack.push(i);
+                    iterationMap.set(i, 1);
                 }
             }
-            // Reset jump flag after processing start repeats check
-            if (i !== justJumpedTo)
-                justJumpedTo = -1;
-            const endRepeat = m.repeats.find((r) => r.type === 'end');
-            let iteration = 1;
-            // Calculate current iteration for Volta logic
-            if (endRepeat)
-                iteration = (repeatCount.get(i) || 0) + 1;
-            else {
-                let nextEndIdx = -1;
-                for (let j = i; j < measures.length; j++) {
-                    if (measures[j].repeats.some((r) => r.type === 'end')) {
-                        nextEndIdx = j;
-                        break;
-                    }
+            // 2. Identify current repetition context
+            const currentStartIdx = startRepeatStack[startRepeatStack.length - 1];
+            const iteration = iterationMap.get(currentStartIdx) || 1;
+            // 3. Volta Logic
+            if (m.volta) {
+                if (m.volta.type === 'start' || m.volta.type === 'both') {
+                    activeVoltaNumbers = m.volta.numbers;
                 }
-                if (nextEndIdx !== -1)
-                    iteration = (repeatCount.get(nextEndIdx) || 0) + 1;
             }
-            if (m.volta && !m.volta.numbers.includes(iteration)) {
-                i++;
-                continue;
+            const effectiveNumbers = (m.volta && m.volta.numbers.length > 0)
+                ? m.volta.numbers
+                : activeVoltaNumbers;
+            const hasVoltaContext = m.volta || activeVoltaNumbers.length > 0;
+            const shouldSkip = hasVoltaContext &&
+                effectiveNumbers.length > 0 &&
+                !effectiveNumbers.includes(iteration);
+            if (!shouldSkip) {
+                sequence.push(i);
             }
-            sequence.push(i);
+            // 4. Reset volta if stopped
+            if (m.volta && (m.volta.type === 'stop' || m.volta.type === 'both')) {
+                activeVoltaNumbers = [];
+            }
+            // 5. Handle End Repeat
+            const endRepeat = m.repeats.find((r) => r.type === 'end');
             if (endRepeat) {
                 const maxTimes = endRepeat.times || 2;
-                const currentCount = repeatCount.get(i) || 0;
+                const currentCount = repeatJumpCount.get(i) || 0;
                 if (currentCount + 1 < maxTimes) {
-                    repeatCount.set(i, currentCount + 1);
-                    // Jump to the nearest start repeat
-                    const target = startRepeatStack[startRepeatStack.length - 1];
-                    i = target;
-                    justJumpedTo = target;
-                    continue;
+                    repeatJumpCount.set(i, currentCount + 1);
+                    iterationMap.set(currentStartIdx, iteration + 1);
+                    i = currentStartIdx;
+                    activeVoltaNumbers = []; // Reset volta context when jumping back
+                    pendingPop = false;
+                    continue; // Jump back
                 }
                 else {
-                    // Finished loop
-                    repeatCount.set(i, 0);
-                    // Pop the start repeat if we have one (keeping the implicit 0)
-                    if (startRepeatStack.length > 1) {
-                        startRepeatStack.pop();
-                    }
-                    // Do not pop 0, so unmatched repeats will default to 0
+                    // Finished this repeat group
+                    repeatJumpCount.set(i, 0);
+                    pendingPop = true;
+                    activeVoltaNumbers = [];
                 }
             }
             i++;

package/dist/models/Staff.d.ts

@@ -1,7 +1,7 @@
-import { Measure, MeasureJSON } from './Measure';
-import { Note } from './Note';
-import { Pitch } from './Pitch';
-import { Clef, Duration } from './types';
+import { Measure, MeasureJSON } from './Measure.js';
+import { Note } from './Note.js';
+import { Pitch } from './Pitch.js';
+import { Clef, Duration } from './types.js';
 /**
  * Represents a single staff (one set of 5 lines with a clef).
  */
@@ -17,7 +17,7 @@ export declare class Staff {
     replaceNote(measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Staff;
     replaceMeasure(measureIndex: number, newMeasure: Measure): Staff;
     deleteNote(measureIndex: number, noteIndex: number, voiceIndex?: number): Staff;
-    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Staff;
+    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, dotCount?: number, voiceIndex?: number): Staff;
     toJSON(): StaffJSON;
     withClef(clef: Clef): Staff;
     withLineCount(lineCount: number): Staff;

package/dist/models/Staff.js

@@ -1,5 +1,5 @@
-import { Measure } from './Measure';
-import { Pitch } from './Pitch';
+import { Measure } from './Measure.js';
+import { Pitch } from './Pitch.js';
 /**
  * Represents a single staff (one set of 5 lines with a clef).
  */
@@ -46,11 +46,11 @@ export class Staff {
         newMeasures[measureIndex] = newMeasures[measureIndex].deleteNote(noteIndex, voiceIndex);
         return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
     }
-    changeNoteDuration(measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(measureIndex, noteIndex, newDuration, dotCount = 0, voiceIndex = 0) {
         if (measureIndex < 0 || measureIndex >= this.measures.length)
             return this;
         const newMeasures = [...this.measures];
-        newMeasures[measureIndex] = newMeasures[measureIndex].changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        newMeasures[measureIndex] = newMeasures[measureIndex].changeNoteDuration(noteIndex, newDuration, dotCount, voiceIndex);
         return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
     }
     toJSON() {