@scorelabs/core 1.0.10 → 1.0.13

package/dist/importers/index.d.ts

@@ -1 +1 @@
-export * from './MusicXMLParser';
+export * from './MusicXMLParser.js';

package/dist/importers/index.js

@@ -1 +1 @@
-export * from './MusicXMLParser';
+export * from './MusicXMLParser.js';

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './models/index.js';
 export * from './importers/index.js';
+export * from './constants.js';

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from './models/index.js';
 export * from './importers/index.js';
+export * from './constants.js';

package/dist/models/Measure.d.ts

@@ -1,6 +1,6 @@
-import { Note, NoteJSON } from './Note';
-import { NoteSet, NoteSetJSON } from './NoteSet';
-import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types';
+import { Note, NoteJSON } from './Note.js';
+import { NoteSet, NoteSetJSON } from './NoteSet.js';
+import { BarlineStyle, Clef, Duration, KeySignature, Repeat, Tempo, TimeSignature, Volta } from './types.js';
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -17,12 +17,22 @@ export declare class Measure {
     readonly tempo?: Tempo | undefined;
     readonly rehearsalMark?: string | undefined;
     readonly systemText?: string | undefined;
+    readonly multiMeasureRestCount?: number | undefined;
     readonly barlineStyle: BarlineStyle;
-    constructor(voices: NoteSet[][], timeSignature?: TimeSignature | undefined, keySignature?: KeySignature | undefined, systemBreak?: boolean, pageBreak?: boolean, repeats?: Repeat[], volta?: Volta | undefined, isPickup?: boolean, clef?: Clef | undefined, tempo?: Tempo | undefined, rehearsalMark?: string | undefined, systemText?: string | undefined, barlineStyle?: BarlineStyle);
+    readonly roadmapDirections?: string[] | undefined;
+    readonly systemDistance?: number | undefined;
+    readonly staffDistance?: number | undefined;
+    readonly topSystemDistance?: number | undefined;
+    /** Stable identifier for this measure. Preserved across all immutable updates. */
+    readonly uuid: string;
+    constructor(voices: NoteSet[][], timeSignature?: TimeSignature | undefined, keySignature?: KeySignature | undefined, systemBreak?: boolean, pageBreak?: boolean, repeats?: Repeat[], volta?: Volta | undefined, isPickup?: boolean, clef?: Clef | undefined, tempo?: Tempo | undefined, rehearsalMark?: string | undefined, systemText?: string | undefined, multiMeasureRestCount?: number | undefined, barlineStyle?: BarlineStyle, uuid?: string, roadmapDirections?: string[] | undefined, systemDistance?: number | undefined, staffDistance?: number | undefined, topSystemDistance?: number | undefined);
     get notes(): NoteSet[];
+    getNoteOffset(voiceIndex: number, noteIndex: number): number;
+    moveNoteToVoice(fromVoiceIndex: number, noteIndex: number, toVoiceIndex: number): Measure;
+    splitNote(voiceIndex: number, noteIndex: number, splitOffset: number): Measure;
     get hasStartRepeat(): boolean;
     get hasEndRepeat(): boolean;
-    changeNoteDuration(noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Measure;
+    changeNoteDuration(noteIndex: number, newDuration: Duration, dotCount?: number, voiceIndex?: number): Measure;
     getTotalDuration(voiceIndex?: number): number;
     static fromJSON(data: MeasureJSON): Measure;
     transpose(semitones: number): Measure;
@@ -45,12 +55,17 @@ export declare class Measure {
     withRehearsalMark(mark?: string): Measure;
     withSystemText(text?: string): Measure;
     withBarlineStyle(style: BarlineStyle): Measure;
+    withRoadmapDirections(roadmapDirections?: string[]): Measure;
+    withSystemDistance(systemDistance?: number): Measure;
+    withStaffDistance(staffDistance?: number): Measure;
+    withMultiMeasureRestCount(multiMeasureRestCount?: number): Measure;
     fillVoiceWithRests(voiceIndex: number, targetDuration: number): Measure;
     simplifyRests(voiceIndex?: number): Measure;
     private decomposeToRests;
     toJSON(): MeasureJSON;
 }
 export interface MeasureJSON {
+    uuid?: string;
     notes?: NoteJSON[];
     voices?: NoteSetJSON[][];
     timeSignature?: TimeSignature;
@@ -65,5 +80,10 @@ export interface MeasureJSON {
     tempo?: Tempo;
     rehearsalMark?: string;
     systemText?: string;
+    multiMeasureRestCount?: number;
+    roadmapDirections?: string[];
     barlineStyle?: BarlineStyle;
+    systemDistance?: number;
+    staffDistance?: number;
+    topSystemDistance?: number;
 }

package/dist/models/Measure.js

@@ -1,6 +1,17 @@
-import { Note } from './Note';
-import { NoteSet } from './NoteSet';
-import { BarlineStyle, DURATION_VALUES, Duration, decomposeDuration, } from './types';
+import { Note } from './Note.js';
+import { NoteSet } from './NoteSet.js';
+import { BarlineStyle, Duration, calculateDurationValue, decomposeDuration, } from './types.js';
+/** Generate a v4-like UUID that works in both browser and Node environments. */
+function generateUuid() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Fallback for older environments
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+}
 /**
  * Represents a single measure containing note sets, potentially in multiple voices.
  */
@@ -17,8 +28,15 @@ export class Measure {
     tempo;
     rehearsalMark;
     systemText;
+    multiMeasureRestCount;
     barlineStyle;
-    constructor(voices, timeSignature, keySignature, systemBreak = false, pageBreak = false, repeats = [], volta, isPickup = false, clef, tempo, rehearsalMark, systemText, barlineStyle = BarlineStyle.Regular) {
+    roadmapDirections;
+    systemDistance;
+    staffDistance;
+    topSystemDistance;
+    /** Stable identifier for this measure. Preserved across all immutable updates. */
+    uuid;
+    constructor(voices, timeSignature, keySignature, systemBreak = false, pageBreak = false, repeats = [], volta, isPickup = false, clef, tempo, rehearsalMark, systemText, multiMeasureRestCount, barlineStyle = BarlineStyle.Regular, uuid, roadmapDirections, systemDistance, staffDistance, topSystemDistance) {
         this.voices = voices;
         this.timeSignature = timeSignature;
         this.keySignature = keySignature;
@@ -31,7 +49,13 @@ export class Measure {
         this.tempo = tempo;
         this.rehearsalMark = rehearsalMark;
         this.systemText = systemText;
+        this.multiMeasureRestCount = multiMeasureRestCount;
         this.barlineStyle = barlineStyle;
+        this.roadmapDirections = roadmapDirections;
+        this.systemDistance = systemDistance;
+        this.staffDistance = staffDistance;
+        this.topSystemDistance = topSystemDistance;
+        this.uuid = uuid ?? generateUuid();
         if (this.voices.length === 0) {
             this.voices = [[]];
         }
@@ -39,27 +63,110 @@ export class Measure {
     get notes() {
         return this.voices[0] || [];
     }
+    getNoteOffset(voiceIndex, noteIndex) {
+        const voice = this.voices[voiceIndex];
+        if (!voice)
+            return 0;
+        let offset = 0;
+        for (let i = 0; i < noteIndex && i < voice.length; i++) {
+            offset += voice[i].getDurationValue();
+        }
+        return offset;
+    }
+    moveNoteToVoice(fromVoiceIndex, noteIndex, toVoiceIndex) {
+        if (fromVoiceIndex === toVoiceIndex)
+            return this;
+        const fromVoice = this.voices[fromVoiceIndex];
+        if (!fromVoice || noteIndex < 0 || noteIndex >= fromVoice.length)
+            return this;
+        const noteSetToMove = fromVoice[noteIndex];
+        if (noteSetToMove.isRest)
+            return this;
+        const onset = this.getNoteOffset(fromVoiceIndex, noteIndex);
+        // 1. Replace with rest in fromVoice first to get the source updated
+        let updatedMeasure = this.deleteNote(noteIndex, fromVoiceIndex);
+        // 2. Ensure toVoice exists and has rests up to total duration
+        const targetDur = this.timeSignature
+            ? (this.timeSignature.beats * 4) / this.timeSignature.beatType
+            : this.getTotalDuration(fromVoiceIndex);
+        updatedMeasure = updatedMeasure.fillVoiceWithRests(toVoiceIndex, targetDur);
+        // 3. Find the note/rest at 'onset' in toVoice and split if necessary
+        let toVoice = updatedMeasure.voices[toVoiceIndex];
+        let currentOffset = 0;
+        let targetNoteIndex = -1;
+        for (let i = 0; i < toVoice.length; i++) {
+            const dur = toVoice[i].getDurationValue();
+            if (Math.abs(currentOffset - onset) < 0.001) {
+                targetNoteIndex = i;
+                break;
+            }
+            if (onset > currentOffset + 0.001 && onset < currentOffset + dur - 0.001) {
+                // Need to split
+                updatedMeasure = updatedMeasure.splitNote(toVoiceIndex, i, onset - currentOffset);
+                toVoice = updatedMeasure.voices[toVoiceIndex]; // Update reference
+                // After split, the target should be at i + (number of segments added - 1)
+                // Let's just re-scan to be safe
+                currentOffset = 0;
+                for (let j = 0; j < toVoice.length; j++) {
+                    if (Math.abs(currentOffset - onset) < 0.001) {
+                        targetNoteIndex = j;
+                        break;
+                    }
+                    currentOffset += toVoice[j].getDurationValue();
+                }
+                break;
+            }
+            currentOffset += dur;
+        }
+        if (targetNoteIndex !== -1) {
+            // We found the correct position in the prepared target voice
+            updatedMeasure = updatedMeasure.replaceNoteSet(targetNoteIndex, noteSetToMove, toVoiceIndex);
+        }
+        return updatedMeasure;
+    }
+    splitNote(voiceIndex, noteIndex, splitOffset) {
+        const voice = this.voices[voiceIndex];
+        if (!voice || noteIndex < 0 || noteIndex >= voice.length)
+            return this;
+        const target = voice[noteIndex];
+        const duration = target.getDurationValue();
+        if (splitOffset <= 0 || splitOffset >= duration - 0.001)
+            return this;
+        const leftParts = decomposeDuration(splitOffset);
+        const rightParts = decomposeDuration(duration - splitOffset);
+        const leftNotes = leftParts.map((p) => target.withDuration(p.duration, p.dotCount).withTie(target.isRest ? false : true));
+        const rightNotes = rightParts.map((p, idx) => {
+            const isLast = idx === rightParts.length - 1;
+            return target
+                .withDuration(p.duration, p.dotCount)
+                .withTie(isLast ? !!target.notes[0].tie : !target.isRest);
+        });
+        const newVoice = [...voice];
+        newVoice.splice(noteIndex, 1, ...leftNotes, ...rightNotes);
+        const newVoices = [...this.voices];
+        newVoices[voiceIndex] = newVoice;
+        return this.withVoices(newVoices);
+    }
     get hasStartRepeat() {
-        return this.repeats.some((r) => r.type === "start");
+        return this.repeats.some((r) => r.type === 'start');
     }
     get hasEndRepeat() {
-        return this.repeats.some((r) => r.type === "end");
+        return this.repeats.some((r) => r.type === 'end');
     }
-    changeNoteDuration(noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+    changeNoteDuration(noteIndex, newDuration, dotCount = 0, voiceIndex = 0) {
         const voice = this.voices[voiceIndex];
         if (!voice || noteIndex < 0 || noteIndex >= voice.length)
             return this;
         const targetNoteSet = voice[noteIndex];
         const oldVal = targetNoteSet.getDurationValue();
-        const base = DURATION_VALUES[newDuration];
-        const newVal = isDotted ? base * 1.5 : base;
+        const newVal = calculateDurationValue(newDuration, dotCount);
         if (Math.abs(newVal - oldVal) < 0.001)
             return this;
         const updatedVoice = [...voice];
         if (newVal < oldVal) {
             const gap = oldVal - newVal;
-            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
-            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, dotCount);
+            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.dotCount)]));
             updatedVoice.splice(noteIndex + 1, 0, ...rests);
         }
         else {
@@ -70,7 +177,7 @@ export class Measure {
             }
             if (available < delta - 0.001)
                 return this;
-            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, isDotted);
+            updatedVoice[noteIndex] = targetNoteSet.withDuration(newDuration, dotCount);
             let consumed = 0;
             let removeCount = 0;
             const replacements = [];
@@ -85,7 +192,7 @@ export class Measure {
                 }
                 else {
                     const remaining = consumed + val - delta;
-                    replacements.push(...decomposeDuration(remaining).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)])));
+                    replacements.push(...decomposeDuration(remaining).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.dotCount)])));
                     removeCount++;
                     break;
                 }
@@ -94,7 +201,12 @@ export class Measure {
         }
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = updatedVoice;
-        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        let result = this.withVoices(newVoices);
+        // Skip simplification if we are explicitly changing a rest's duration,
+        // to allow the user to manually control rest fragmentation (e.g. splitting a whole rest into halves).
+        if (!targetNoteSet.isRest) {
+            result = result.simplifyRests(voiceIndex);
+        }
         if (this.timeSignature) {
             result = result.autoBeam(this.timeSignature);
         }
@@ -123,7 +235,8 @@ export class Measure {
         else {
             voices = [[]];
         }
-        return new Measure(voices, data.timeSignature, data.keySignature, data.systemBreak ?? false, data.pageBreak ?? false, data.repeats || (data.repeat ? [data.repeat] : []), data.volta, data.isPickup ?? false, data.clef, data.tempo, data.rehearsalMark, data.systemText, data.barlineStyle ?? BarlineStyle.Regular);
+        return new Measure(voices, data.timeSignature, data.keySignature, data.systemBreak ?? false, data.pageBreak ?? false, data.repeats || (data.repeat ? [data.repeat] : []), data.volta, data.isPickup ?? false, data.clef, data.tempo, data.rehearsalMark, data.systemText, data.multiMeasureRestCount, data.barlineStyle ?? BarlineStyle.Regular, data.uuid, // preserve existing uuid — undefined for old scores → generates new one
+        data.roadmapDirections, data.systemDistance, data.staffDistance, data.topSystemDistance);
     }
     transpose(semitones) {
         let newKeySignature;
@@ -164,7 +277,7 @@ export class Measure {
             for (let i = index + 1; i < updatedVoice.length; i++) {
                 available += updatedVoice[i].getDurationValue();
             }
-            // If there's enough space to consume, do it. 
+            // If there's enough space to consume, do it.
             // If not, we still replace it but it will overflow (which simplifyRests might fix or layout will handle)
             updatedVoice[index] = newNoteSet;
             let consumed = 0;
@@ -190,7 +303,12 @@ export class Measure {
         }
         const newVoices = [...this.voices];
         newVoices[voiceIndex] = updatedVoice;
-        let result = this.withVoices(newVoices).simplifyRests(voiceIndex);
+        let result = this.withVoices(newVoices);
+        // Only simplify rests if the duration was actually changed,
+        // otherwise preserve the user's current rhythm organization.
+        if (Math.abs(oldVal - newVal) >= 0.001) {
+            result = result.simplifyRests(voiceIndex);
+        }
         if (this.timeSignature) {
             result = result.autoBeam(this.timeSignature);
         }
@@ -235,7 +353,7 @@ export class Measure {
                         if (ts.beats === 4 || ts.beats === 2) {
                             // In 4/4 or 2/4, eighth notes are often beamed in groups of 2 beats (length 2.0)
                             // unless there are sixteenth notes which force 1-beat groupings.
-                            beamBeatLength = (lastGroupHasSixteenths || isSixteenth) ? 1.0 : 2.0;
+                            beamBeatLength = lastGroupHasSixteenths || isSixteenth ? 1.0 : 2.0;
                         }
                     }
                     else if (ts.beatType === 8) {
@@ -291,25 +409,25 @@ export class Measure {
         return this.withVoices(newVoices);
     }
     withTimeSignature(timeSignature) {
-        return new Measure(this.voices, timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withKeySignature(keySignature) {
-        return new Measure(this.voices, this.timeSignature, keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withClef(clef) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withTempo(tempo) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withSystemBreak(systemBreak) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withPageBreak(pageBreak) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withVoices(voices) {
-        return new Measure(voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withVoiceNotes(notes, voiceIndex = 0) {
         const newVoices = [...this.voices];
@@ -332,22 +450,34 @@ export class Measure {
         return this.withRepeats(newRepeats);
     }
     withRepeats(repeats) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withVolta(volta) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withPickup(isPickup) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withRehearsalMark(mark) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, mark, this.systemText, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, mark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withSystemText(text) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, text, this.barlineStyle);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, text, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     withBarlineStyle(style) {
-        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, style);
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, style, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
+    }
+    withRoadmapDirections(roadmapDirections) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, roadmapDirections, this.systemDistance, this.staffDistance);
+    }
+    withSystemDistance(systemDistance) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, systemDistance, this.staffDistance);
+    }
+    withStaffDistance(staffDistance) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, this.multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, staffDistance);
+    }
+    withMultiMeasureRestCount(multiMeasureRestCount) {
+        return new Measure(this.voices, this.timeSignature, this.keySignature, this.systemBreak, this.pageBreak, this.repeats, this.volta, this.isPickup, this.clef, this.tempo, this.rehearsalMark, this.systemText, multiMeasureRestCount, this.barlineStyle, this.uuid, this.roadmapDirections, this.systemDistance, this.staffDistance);
     }
     fillVoiceWithRests(voiceIndex, targetDuration) {
         const newVoices = [...this.voices];
@@ -358,7 +488,7 @@ export class Measure {
         const currentDuration = currentVoice.reduce((sum, ns) => sum + ns.getDurationValue(), 0);
         if (currentDuration < targetDuration - 0.001) {
             const gap = targetDuration - currentDuration;
-            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+            const rests = decomposeDuration(gap).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.dotCount)]));
             newVoices[voiceIndex] = [...currentVoice, ...rests];
         }
         return this.withVoices(newVoices);
@@ -368,9 +498,11 @@ export class Measure {
         if (!voice || voice.length === 0)
             return this;
         const totalDur = this.getTotalDuration(voiceIndex);
-        const expectedDur = this.timeSignature ? (this.timeSignature.beats * 4) / this.timeSignature.beatType : 4.0;
+        const expectedDur = this.timeSignature
+            ? (this.timeSignature.beats * 4) / this.timeSignature.beatType
+            : 4.0;
         // Special Case: If the whole measure is rests, just return a single whole rest (or appropriate duration)
-        const allRests = voice.every(ns => ns.isRest);
+        const allRests = voice.every((ns) => ns.isRest);
         if (allRests && Math.abs(totalDur - expectedDur) < 0.001) {
             const newVoice = [new NoteSet([new Note(Duration.Whole, undefined, true)])];
             const newVoices = [...this.voices];
@@ -399,10 +531,11 @@ export class Measure {
         return this.withVoices(newVoices);
     }
     decomposeToRests(value) {
-        return decomposeDuration(value).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.isDotted)]));
+        return decomposeDuration(value).map((d) => new NoteSet([new Note(d.duration, undefined, true, d.dotCount)]));
     }
     toJSON() {
         return {
+            uuid: this.uuid,
             voices: this.voices.map((v) => v.map((ns) => ns.toJSON())),
             timeSignature: this.timeSignature,
             keySignature: this.keySignature,
@@ -415,7 +548,12 @@ export class Measure {
             tempo: this.tempo,
             rehearsalMark: this.rehearsalMark,
             systemText: this.systemText,
+            multiMeasureRestCount: this.multiMeasureRestCount,
+            roadmapDirections: this.roadmapDirections,
             barlineStyle: this.barlineStyle,
+            systemDistance: this.systemDistance,
+            staffDistance: this.staffDistance,
+            topSystemDistance: this.topSystemDistance,
         };
     }
 }

package/dist/models/Note.d.ts

@@ -1,13 +1,10 @@
-import { Pitch } from './Pitch';
-import { Accidental, Arpeggio, Articulation, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, Hairpin, Lyric, NoteheadShape, Ornament, Ottava, Pedal, Slur, StemDirection, Tuplet } from './types';
-/**
- * Represents a single note or rest in a measure.
- */
+import { Pitch } from './Pitch.js';
+import { Accidental, AccidentalDisplay, Arpeggio, Articulation, BeamLevels, Bend, Bowing, Duration, Dynamic, FretboardDiagram, Glissando, GraceNote, Hairpin, Harmonic, Lyric, NoteheadShape, Ornament, OrnamentDetails, Ottava, Pedal, Placement, RestDisplay, Slur, StemDirection, TieSpan, Tuplet } from './types.js';
 export declare class Note {
     readonly duration: Duration;
     readonly pitch?: Pitch | undefined;
     readonly isRest: boolean;
-    readonly isDotted: boolean;
+    readonly dotCount: number;
     readonly accidental?: Accidental | undefined;
     readonly beamGroup?: number | undefined;
     readonly articulations: Articulation[];
@@ -17,6 +14,7 @@ export declare class Note {
     readonly tuplet?: Tuplet | undefined;
     readonly hairpin?: Hairpin | undefined;
     readonly isGrace: boolean;
+    readonly isCue: boolean;
     readonly lyric?: Lyric | undefined;
     readonly chord?: string | undefined;
     readonly glissando?: Glissando | undefined;
@@ -38,9 +36,21 @@ export declare class Note {
     readonly palmMute?: "start" | "stop" | undefined;
     readonly hammerOn?: "start" | "stop" | undefined;
     readonly pullOff?: "start" | "stop" | undefined;
+    readonly tieSpans: TieSpan[];
+    readonly slurs: Slur[];
+    readonly beamLevels?: BeamLevels | undefined;
+    readonly grace?: GraceNote | undefined;
+    readonly accidentalDisplay?: AccidentalDisplay | undefined;
+    readonly restDisplay?: RestDisplay | undefined;
+    readonly ornamentDetails?: OrnamentDetails | undefined;
+    readonly harmonic?: Harmonic | undefined;
+    readonly bend?: Bend | undefined;
+    readonly vibrato?: "start" | "stop" | "single" | undefined;
+    readonly placement?: Placement | undefined;
     constructor(duration: Duration, pitch?: Pitch | undefined, // undefined for rests
-    isRest?: boolean, isDotted?: boolean, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
-    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, lyric?: Lyric | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: Lyric[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined);
+    isRest?: boolean, dotCount?: number, accidental?: Accidental | undefined, beamGroup?: number | undefined, // Group ID for beamed notes
+    articulations?: Articulation[], dynamic?: Dynamic | undefined, tie?: boolean | undefined, slur?: Slur | undefined, tuplet?: Tuplet | undefined, hairpin?: Hairpin | undefined, isGrace?: boolean, isCue?: boolean, lyric?: Lyric | undefined, chord?: string | undefined, glissando?: Glissando | undefined, arpeggio?: Arpeggio | undefined, ottava?: Ottava | undefined, pedal?: Pedal | undefined, ornament?: Ornament | undefined, fret?: number | undefined, string?: number | undefined, fretboardDiagram?: FretboardDiagram | undefined, lyrics?: Lyric[] | undefined, staffText?: string | undefined, color?: string | undefined, notehead?: NoteheadShape | undefined, bowing?: Bowing | undefined, fingering?: number | undefined, stemDirection?: StemDirection | undefined, isStringCircled?: boolean | undefined, palmMute?: "start" | "stop" | undefined, hammerOn?: "start" | "stop" | undefined, pullOff?: "start" | "stop" | undefined, tieSpans?: TieSpan[], slurs?: Slur[], beamLevels?: BeamLevels | undefined, grace?: GraceNote | undefined, accidentalDisplay?: AccidentalDisplay | undefined, restDisplay?: RestDisplay | undefined, ornamentDetails?: OrnamentDetails | undefined, harmonic?: Harmonic | undefined, bend?: Bend | undefined, vibrato?: "start" | "stop" | "single" | undefined, placement?: Placement | undefined);
+    get isDotted(): boolean;
     /**
      * Get all lyrics as standardized objects
      */
@@ -58,6 +68,7 @@ export declare class Note {
      */
     isBeamable(): boolean;
     withGrace(isGrace: boolean): Note;
+    withCue(isCue: boolean): Note;
     withChord(chord?: string): Note;
     transpose(semitones: number): Note;
     transposeOctave(octaves: number): Note;
@@ -74,7 +85,8 @@ export declare class Note {
     withLyrics(lyrics: Lyric[]): Note;
     withHairpin(hairpin?: Hairpin): Note;
     withAccidental(accidental?: Accidental): Note;
-    withDuration(duration: Duration, isDotted?: boolean): Note;
+    withAccidentalDisplay(accidentalDisplay?: AccidentalDisplay): Note;
+    withDuration(duration: Duration, dotCount?: number): Note;
     withRest(isRest: boolean): Note;
     withFretboardDiagram(diagram?: FretboardDiagram): Note;
     withBeamGroup(beamGroup?: number): Note;
@@ -83,6 +95,7 @@ export declare class Note {
     withOttava(ottava?: Ottava): Note;
     withPedal(pedal?: Pedal): Note;
     withOrnament(ornament?: Ornament): Note;
+    withOrnamentDetails(ornamentDetails?: OrnamentDetails): Note;
     withTab(fret: number, string: number): Note;
     withStaffText(text?: string): Note;
     withColor(color?: string): Note;
@@ -94,6 +107,9 @@ export declare class Note {
     withPalmMute(palmMute?: 'start' | 'stop'): Note;
     withHammerOn(hammerOn?: 'start' | 'stop'): Note;
     withPullOff(pullOff?: 'start' | 'stop'): Note;
+    withHarmonic(harmonic?: Harmonic): Note;
+    withBend(bend?: Bend): Note;
+    withVibrato(vibrato?: 'start' | 'stop' | 'single'): Note;
     toJSON(): NoteJSON;
     static fromJSON(data: NoteJSON): Note;
 }
@@ -107,16 +123,21 @@ export interface NoteJSON {
     };
     isRest?: boolean;
     isDotted?: boolean;
+    dotCount?: number;
     accidental?: string;
     beamGroup?: number;
+    beamLevels?: BeamLevels;
     articulation?: string;
     articulations?: string[];
     dynamic?: string;
     tie?: boolean;
     slur?: Slur;
+    tieSpans?: TieSpan[];
+    slurs?: Slur[];
     tuplet?: Tuplet;
     hairpin?: Hairpin;
     isGrace?: boolean;
+    isCue?: boolean;
     lyric?: Lyric;
     chord?: string;
     glissando?: Glissando;
@@ -138,4 +159,12 @@ export interface NoteJSON {
     palmMute?: 'start' | 'stop';
     hammerOn?: 'start' | 'stop';
     pullOff?: 'start' | 'stop';
+    grace?: GraceNote;
+    accidentalDisplay?: AccidentalDisplay;
+    restDisplay?: RestDisplay;
+    ornamentDetails?: OrnamentDetails;
+    harmonic?: Harmonic;
+    bend?: Bend;
+    vibrato?: 'start' | 'stop' | 'single';
+    placement?: Placement;
 }