@tspro/web-music-score 5.2.0 → 5.4.0

package/dist/theory/index.mjs

@@ -1,24 +1,26 @@
-/* WebMusicScore v5.2.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
+/* WebMusicScore v5.4.0 | (c) 2023 PahkaSoft | MIT License | Includes: Tone.js (MIT License) */
 import {
   NoteLength,
   NoteLengthProps,
   RhythmProps,
   Tuplet,
+  isNoteLength,
+  isTupletRatio,
   validateNoteLength,
   validateTupletRatio
-} from "../chunk-XUGM7SCC.mjs";
+} from "../chunk-MHDBTCVG.mjs";
 import {
   __publicField
-} from "../chunk-LC5JMIVF.mjs";
+} from "../chunk-AUT4C6TY.mjs";
 
 // src/theory/chord.ts
-import { Utils as Utils6 } from "@tspro/ts-utils-lib";
+import { IndexArray, Utils as Utils4 } from "@tspro/ts-utils-lib";
 
 // src/theory/note.ts
-import { Utils as Utils2 } from "@tspro/ts-utils-lib";
+import { Guard as Guard2, UniMap } from "@tspro/ts-utils-lib";
 
 // src/theory/types.ts
-import { Utils } from "@tspro/ts-utils-lib";
+import { Guard, Utils } from "@tspro/ts-utils-lib";
 import { MusicError, MusicErrorType } from "@tspro/web-music-score/core";
 var SymbolSet = /* @__PURE__ */ ((SymbolSet2) => {
   SymbolSet2[SymbolSet2["Ascii"] = 0] = "Ascii";
@@ -33,7 +35,7 @@ var PitchNotation = /* @__PURE__ */ ((PitchNotation2) => {
 var PitchNotationList = Utils.Enum.getEnumValues(PitchNotation);
 var DefaultPitchNotation = 0 /* Scientific */;
 function validatePitchNotation(pn) {
-  if (Utils.Is.isEnumValue(pn, PitchNotation)) {
+  if (Guard.isEnumValue(pn, PitchNotation)) {
     return pn;
   } else {
     throw new MusicError(MusicErrorType.InvalidArg, `Invalid pitchNotation: ${pn}`);
@@ -51,7 +53,7 @@ var GuitarNoteLabel = /* @__PURE__ */ ((GuitarNoteLabel2) => {
 var DefaultGuitarNoteLabel = "Default" /* Default */;
 var GuitarNoteLabelList = Utils.Enum.getEnumValues(GuitarNoteLabel);
 function validateGuitarNoteLabel(label) {
-  if (Utils.Is.isEnumValue(label, GuitarNoteLabel)) {
+  if (Guard.isEnumValue(label, GuitarNoteLabel)) {
     return label;
   } else {
     throw new MusicError(MusicErrorType.Timesignature, `Invalid guitarNoteLabel: ${label}`);
@@ -151,19 +153,32 @@ var _Note = class _Note {
    * @returns - Note.
    */
   static getNote(noteName) {
-    let note = this.noteByNameCache.get(noteName);
-    if (note === void 0) {
+    return this.noteCache.getOrCreate(noteName, () => {
       let p = _Note.parseNote(noteName);
-      if (!p) {
-        throw new MusicError2(MusicErrorType2.Note, `Invalid noteName: ${noteName}`);
-      }
-      if (p.octave === void 0) {
-        throw new MusicError2(MusicErrorType2.Note, `Octave is required for note.`);
-      }
-      note = new _Note(p.noteLetter, p.accidental, p.octave);
-      this.noteByNameCache.set(noteName, note);
-    }
-    return note;
+      if (!p)
+        throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}".`);
+      if (p.octave === void 0)
+        throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}" (missing octave).`);
+      return new _Note(p.noteLetter, p.accidental, p.octave);
+    });
+  }
+  /**
+   * Test if given note name valid.
+   * @param noteName - Note name.
+   * @returns - True/false.
+   */
+  static isNote(noteName) {
+    let p = _Note.parseNote(noteName);
+    return p !== void 0 && p.octave !== void 0;
+  }
+  /**
+   * Validate given note name.
+   * @param noteName - Note name.
+   * @returns - True or throws.
+   */
+  static validateNote(noteName) {
+    if (this.isNote(noteName)) return true;
+    throw new MusicError2(MusicErrorType2.Note, `Invalid note "${noteName}"`);
   }
   /**
    * Get chromatic note. There are number of alternatives, this function uses simple logic to choose one.
@@ -171,21 +186,11 @@ var _Note = class _Note {
    * @returns - Note.
    */
   static getChromaticNote(chromaticId) {
-    let note = this.chromaticNoteCache.get(chromaticId);
-    if (note === void 0) {
+    return this.chromaticNoteCache.getOrCreate(chromaticId, () => {
       const NoteNameList = ["C/B#", "C#/Db", "D", "D#/Eb", "E/Fb", "F/E#", "F#/Gb", "G", "G#/Ab", "A", "A#/Bb", "B/Cb"];
       let noteName = NoteNameList[_Note.getChromaticClass(chromaticId)].split("/")[0] + _Note.getOctaveFromChromaticId(chromaticId);
-      let p = _Note.parseNote(noteName);
-      if (!p) {
-        throw new MusicError2(MusicErrorType2.Note, `Invalid noteName: ${noteName}`);
-      }
-      if (p.octave === void 0) {
-        throw new MusicError2(MusicErrorType2.Note, `Octave is required for note.`);
-      }
-      note = new _Note(p.noteLetter, p.accidental, p.octave);
-      this.chromaticNoteCache.set(chromaticId, note);
-    }
-    return note;
+      return _Note.getNote(noteName);
+    });
   }
   static getDiatonicClass(arg) {
     if (typeof arg === "number") {
@@ -354,7 +359,7 @@ var _Note = class _Note {
    * @returns - Valid diatonic id or throws.
    */
   static validateDiatonicId(diatonicId) {
-    if (Utils2.Is.isInteger(diatonicId)) {
+    if (Guard2.isInteger(diatonicId)) {
       return diatonicId;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicId: ${diatonicId}`);
@@ -366,7 +371,7 @@ var _Note = class _Note {
    * @returns - Valid diatonic class or throws.
    */
   static validateDiatonicClass(diatonicClass) {
-    if (Utils2.Is.isIntegerBetween(diatonicClass, 0, 6)) {
+    if (Guard2.isIntegerBetween(diatonicClass, 0, 6)) {
       return diatonicClass;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid diatonicClass: ${diatonicClass}`);
@@ -378,7 +383,7 @@ var _Note = class _Note {
    * @returns - Valid chromatic id, or throws.
    */
   static validateChromaticId(chromaticId) {
-    if (Utils2.Is.isInteger(chromaticId)) {
+    if (Guard2.isInteger(chromaticId)) {
       return chromaticId;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticId: ${chromaticId}`);
@@ -390,7 +395,7 @@ var _Note = class _Note {
    * @returns - Valid chromatic class, or throws.
    */
   static validatechromaticClass(chromaticClass) {
-    if (Utils2.Is.isIntegerBetween(chromaticClass, 0, 11)) {
+    if (Guard2.isIntegerBetween(chromaticClass, 0, 11)) {
       return chromaticClass;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid chromaticClass: ${chromaticClass}`);
@@ -414,7 +419,7 @@ var _Note = class _Note {
    * @returns - Valid octave or throws.
    */
   static validateOctave(octave) {
-    if (Utils2.Is.isInteger(octave)) {
+    if (Guard2.isInteger(octave)) {
       return octave;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid octave: ${octave}`);
@@ -426,7 +431,7 @@ var _Note = class _Note {
    * @returns - Valid accidental or thorws.
    */
   static validateAccidental(acc) {
-    if (Utils2.Is.isIntegerBetween(acc, -2, 2)) {
+    if (Guard2.isIntegerBetween(acc, -2, 2)) {
       return acc;
     } else {
       throw new MusicError2(MusicErrorType2.Note, `Invalid accidental: ${acc}`);
@@ -476,15 +481,15 @@ var _Note = class _Note {
     }
   }
 };
-__publicField(_Note, "noteByNameCache", /* @__PURE__ */ new Map());
-__publicField(_Note, "chromaticNoteCache", /* @__PURE__ */ new Map());
+__publicField(_Note, "noteCache", new UniMap());
+__publicField(_Note, "chromaticNoteCache", new UniMap());
 var Note = _Note;
 
 // src/theory/scale.ts
-import { Utils as Utils5 } from "@tspro/ts-utils-lib";
+import { Guard as Guard5, UniMap as UniMap3, SignedIndexArray, Utils as Utils3 } from "@tspro/ts-utils-lib";
 
 // src/theory/key-signature.ts
-import { Utils as Utils3 } from "@tspro/ts-utils-lib";
+import { Guard as Guard3 } from "@tspro/ts-utils-lib";
 import { MusicError as MusicError3, MusicErrorType as MusicErrorType3 } from "@tspro/web-music-score/core";
 function getAccidental(chromaticId, diatonicId) {
   let a = Note.getChromaticClass(chromaticId) - new Note(diatonicId, 0).chromaticClass;
@@ -505,7 +510,7 @@ function parseDegree(degree) {
   }
   let acc = (_b = Note.getAccidental((_a = m[1]) != null ? _a : "")) != null ? _b : 0;
   let deg = +m[2];
-  if (!Utils3.Is.isInteger(acc) || acc < -2 || acc > 2 || !Utils3.Is.isInteger(deg) || deg < 1) {
+  if (!Guard3.isInteger(acc) || acc < -2 || acc > 2 || !Guard3.isInteger(deg) || deg < 1) {
     throw new MusicError3(MusicErrorType3.KeySignature, `Invalid degree: ${degree}`);
   } else {
     return { deg, acc };
@@ -541,7 +546,7 @@ var _KeySignature = class _KeySignature {
     __publicField(this, "naturalScaleNotes");
     __publicField(this, "accidentalByDiatonicClass");
     __publicField(this, "orderedAccidentedNotes");
-    if (!Utils3.Is.isEnumValue(mode, Mode)) {
+    if (!Guard3.isEnumValue(mode, Mode)) {
       throw new MusicError3(MusicErrorType3.KeySignature, `Invalid mode: ${mode}`);
     }
     let intervals = [2, 2, 1, 2, 2, 2, 1];
@@ -659,9 +664,9 @@ __publicField(_KeySignature, "OrderOfFlats", "BEADGCF");
 var KeySignature = _KeySignature;
 
 // src/theory/interval.ts
-import { Utils as Utils4 } from "@tspro/ts-utils-lib";
+import { Guard as Guard4, UniMap as UniMap2, Utils as Utils2 } from "@tspro/ts-utils-lib";
 import { MusicError as MusicError4, MusicErrorType as MusicErrorType4 } from "@tspro/web-music-score/core";
-var IntervalQualityAbbrMap = /* @__PURE__ */ new Map([
+var IntervalQualityAbbrMap = new UniMap2([
   ["Major", "M"],
   ["minor", "m"],
   ["Perfect", "P"],
@@ -764,10 +769,10 @@ function validateIntervalQuality(q) {
   }
 }
 function formatQuantity(q) {
-  if (!Utils4.Is.isIntegerGte(q, 1)) {
+  if (!Guard4.isIntegerGte(q, 1)) {
     throw new MusicError4(MusicErrorType4.InvalidArg, `Invalid interval quantity: ${q}`);
   } else {
-    return Utils4.Math.toOrdinalNumber(q);
+    return Utils2.Math.toOrdinalNumber(q);
   }
 }
 var InvalidIntervalException = class extends Error {
@@ -837,9 +842,8 @@ var Interval = class _Interval {
    * @returns - Interval abbrevated string.
    */
   toAbbrString() {
-    var _a;
     let direction = this.direction === "Descending" ? "\u2193" : "";
-    let quality = (_a = IntervalQualityAbbrMap.get(this.quality)) != null ? _a : "?";
+    let quality = IntervalQualityAbbrMap.getOrDefault(this.quality, "?");
     let quantity = this.quantity;
     return direction + quality + quantity;
   }
@@ -945,7 +949,7 @@ var Scale = class extends KeySignature {
     __publicField(this, "scaleNotes");
     /** Degrees (or undefined) of chromatic classes. */
     __publicField(this, "chromaticClassDegree");
-    __publicField(this, "preferredChromaticNoteCache", /* @__PURE__ */ new Map());
+    __publicField(this, "preferredChromaticIdNoteCache", new SignedIndexArray());
     switch (scaleType) {
       case "Harmonic Minor" /* HarmonicMinor */:
         this.scaleDegrees = [1, 2, 3, 4, 5, 6, "#7"];
@@ -1010,7 +1014,7 @@ var Scale = class extends KeySignature {
    * @returns - Array of scale notes.
    */
   getScaleNotes(bottomNote, numOctaves) {
-    if (!Utils5.Is.isIntegerGte(numOctaves, 1)) {
+    if (!Guard5.isIntegerGte(numOctaves, 1)) {
       throw new MusicError5(MusicErrorType5.Scale, `Invalid numOctaves: ${numOctaves}`);
     }
     let scaleNoteList = [];
@@ -1039,7 +1043,7 @@ var Scale = class extends KeySignature {
     let chromaticIds = this.getScaleNotes("C4", 1).map((note) => note.chromaticId);
     let steps = [];
     for (let i = 0; i < chromaticIds.length - 1; i++) {
-      steps.push(Utils5.Math.mod(chromaticIds[i + 1] - chromaticIds[i], 12));
+      steps.push(Utils3.Math.mod(chromaticIds[i + 1] - chromaticIds[i], 12));
     }
     return steps;
   }
@@ -1086,6 +1090,7 @@ var Scale = class extends KeySignature {
       return interval;
     }
   }
+  // Can it be negative case?
   /**
    * Get preferred chromatic note from given chromatic id.
    * @param chromaticId - Chromatic id.
@@ -1093,7 +1098,7 @@ var Scale = class extends KeySignature {
    */
   getPreferredChromaticNote(chromaticId) {
     Note.validateChromaticId(chromaticId);
-    let note = this.preferredChromaticNoteCache.get(chromaticId);
+    let note = this.preferredChromaticIdNoteCache.get(chromaticId);
     if (note) {
       return note;
     }
@@ -1109,7 +1114,7 @@ var Scale = class extends KeySignature {
     });
     note = scaleNotes.find((note2) => Note.getChromaticClass(chromaticId) === note2.chromaticClass);
     if (note) {
-      this.preferredChromaticNoteCache.set(chromaticId, note);
+      this.preferredChromaticIdNoteCache.set(chromaticId, note);
       return note;
     }
     let diatonicIdMid = getNaturalDiatonicId(chromaticId);
@@ -1122,13 +1127,13 @@ var Scale = class extends KeySignature {
       for (let diatonicId = Math.max(0, diatonicIdStart); diatonicId <= diatonicIdEnd; diatonicId++) {
         note = new Note(diatonicId, acc);
         if (chromaticId === note.chromaticId) {
-          this.preferredChromaticNoteCache.set(chromaticId, note);
+          this.preferredChromaticIdNoteCache.set(chromaticId, note);
           return note;
         }
       }
     }
     note = Note.getChromaticNote(chromaticId);
-    this.preferredChromaticNoteCache.set(chromaticId, note);
+    this.preferredChromaticIdNoteCache.set(chromaticId, note);
     return note;
   }
 };
@@ -1248,7 +1253,7 @@ var ScaleFactoryList = [
 function getScaleFactoryList() {
   return ScaleFactoryList;
 }
-var ScaleFactoryMap = /* @__PURE__ */ new Map();
+var ScaleFactoryMap = new UniMap3();
 ScaleFactoryList.forEach((factory) => {
   if (factory instanceof ScaleFactory) {
     ScaleFactoryMap.set(factory.getType(), factory);
@@ -1263,7 +1268,7 @@ function getScaleFactory(scaleType) {
   }
 }
 function validateScaleType(scaleType) {
-  if (Utils5.Is.isEnumValue(scaleType, ScaleType)) {
+  if (Guard5.isEnumValue(scaleType, ScaleType)) {
     return scaleType;
   } else {
     throw new MusicError5(MusicErrorType5.Scale, `Invalid scaleType: "${scaleType}"`);
@@ -1307,18 +1312,15 @@ var OkayRootNoteList = [
   "B",
   "Cb"
 ].map((noteName) => Note.getNote(noteName + "0"));
-var okayRootNoteCache = /* @__PURE__ */ new Map();
+var okayRootNoteCache = new IndexArray();
 function getOkayRootNote(wantedRootNote) {
-  let cacheKey = wantedRootNote.chromaticClass;
-  let rootNote = okayRootNoteCache.get(cacheKey);
-  if (!rootNote) {
-    rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
+  return okayRootNoteCache.getOrCreate(wantedRootNote.chromaticClass, () => {
+    let rootNote = OkayRootNoteList.find((note) => isEqualNote(note, wantedRootNote));
     if (!rootNote) {
       throw new MusicError6(MusicErrorType6.InvalidArg, `Invalid chord root note: ${wantedRootNote.formatOmitOctave(1 /* Unicode */)}`);
     }
-    okayRootNoteCache.set(cacheKey, rootNote);
-  }
-  return rootNote;
+    return rootNote;
+  });
 }
 function getChordNoteByDegree(chordRootNote, degree) {
   let chordRootNoteStr = chordRootNote.formatOmitOctave(0 /* Ascii */);
@@ -1326,7 +1328,7 @@ function getChordNoteByDegree(chordRootNote, degree) {
   return ks.getNoteByDegree(degree);
 }
 function removeNoteDuplicates(notes) {
-  return Utils6.Arr.removeDuplicatesCmp(notes, isEqualNote);
+  return Utils4.Arr.removeDuplicates(notes, isEqualNote);
 }
 var ChordInfoList = [
   // Power chord
@@ -1524,7 +1526,7 @@ var Chord = class _Chord {
 };
 
 // src/theory/guitar.ts
-import { Utils as Utils7, LRUCache } from "@tspro/ts-utils-lib";
+import { Guard as Guard6, LRUCache } from "@tspro/ts-utils-lib";
 
 // src/theory/assets/tunings.json
 var tunings_default = {
@@ -1783,7 +1785,7 @@ var Handedness = /* @__PURE__ */ ((Handedness2) => {
 })(Handedness || {});
 var DefaultHandedness = 0 /* RightHanded */;
 function validateHandedness(h) {
-  if (Utils7.Is.isEnumValue(h, Handedness)) {
+  if (Guard6.isEnumValue(h, Handedness)) {
     return h;
   } else {
     throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid handedness: ${h}`);
@@ -1807,7 +1809,7 @@ function getTuningStrings(tuningName) {
       throw new MusicError7(MusicErrorType7.InvalidArg, `Invalid tuningName: ${tuningName}`);
     }
     tuningStrings = tuningData.strings.slice().reverse().map((noteName) => Note.getNote(noteName));
-    if (!Utils7.Is.isIntegerEq(tuningStrings.length, 6)) {
+    if (!Guard6.isIntegerEq(tuningStrings.length, 6)) {
       throw new MusicError7(MusicErrorType7.Unknown, `Tuning has ${tuningStrings.length} strings.`);
     }
     TuningStringsCache.set(tuningName, tuningStrings);
@@ -1816,7 +1818,7 @@ function getTuningStrings(tuningName) {
 }
 
 // src/theory/time-signature.ts
-import { Utils as Utils8 } from "@tspro/ts-utils-lib";
+import { Guard as Guard7 } from "@tspro/ts-utils-lib";
 import { MusicError as MusicError8, MusicErrorType as MusicErrorType8 } from "@tspro/web-music-score/core";
 var TimeSignatures = /* @__PURE__ */ ((TimeSignatures2) => {
   TimeSignatures2["_2_4"] = "2/4";
@@ -1850,25 +1852,25 @@ var TimeSignature = class {
     /** Beam groups (e.g. [[2], [2]] or [[2, 2], [2, 2]] (first try as [[4], [4]])). */
     __publicField(this, "beamGroupSizes", []);
     let beamGrouping;
-    if (Utils8.Is.isEnumValue(args[0], TimeSignatures)) {
+    if (Guard7.isEnumValue(args[0], TimeSignatures)) {
       let parts = args[0].split("/");
       this.beatCount = +parts[0];
       this.beatSize = +parts[1];
-      if (Utils8.Is.isEnumValue(args[1], BeamGrouping)) {
+      if (Guard7.isEnumValue(args[1], BeamGrouping)) {
         beamGrouping = args[1];
       }
-    } else if (Utils8.Is.isIntegerGte(args[0], 2) && Utils8.Is.isIntegerGte(args[1], 2)) {
+    } else if (Guard7.isIntegerGte(args[0], 2) && Guard7.isIntegerGte(args[1], 2)) {
       this.beatCount = args[0];
       this.beatSize = args[1];
-      if (Utils8.Is.isEnumValue(args[2], BeamGrouping)) {
+      if (Guard7.isEnumValue(args[2], BeamGrouping)) {
         beamGrouping = args[2];
       }
     } else {
       throw new MusicError8(MusicErrorType8.Timesignature, `Invalid args: ${args}`);
     }
-    if (!Utils8.Is.isIntegerGte(this.beatCount, 1)) {
+    if (!Guard7.isIntegerGte(this.beatCount, 1)) {
       throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beatCount: ${this.beatCount}`);
-    } else if (!Utils8.Is.isIntegerGte(this.beatSize, 1)) {
+    } else if (!Guard7.isIntegerGte(this.beatSize, 1)) {
       throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beatSize: ${this.beatSize}`);
     }
     let { noteLength, ticks } = NoteLengthProps.create(this.beatSize);
@@ -1883,7 +1885,7 @@ var TimeSignature = class {
     } else if (this.is(3, 8)) {
       this.beamGroupSizes = [[3]];
     } else if (this.is(5, 8)) {
-      if (!Utils8.Is.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
+      if (!Guard7.isUndefined(beamGrouping) && beamGrouping !== "2-3" /* _2_3 */ && beamGrouping !== "3-2" /* _3_2 */) {
         throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
       } else {
         this.beamGroupSizes = beamGrouping === "3-2" /* _3_2 */ ? [[3], [2]] : [[2], [3]];
@@ -1892,7 +1894,7 @@ var TimeSignature = class {
     } else if (this.is(6, 8)) {
       this.beamGroupSizes = [[3], [3]];
     } else if (this.is(7, 8)) {
-      if (!Utils8.Is.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
+      if (!Guard7.isUndefined(beamGrouping) && beamGrouping !== "2-2-3" /* _2_2_3 */ && beamGrouping !== "3-2-2" /* _3_2_2 */) {
         throw new MusicError8(MusicErrorType8.Timesignature, `Invalid beam grouping "${beamGrouping}" for time signature "${this.toString()}".`);
       } else {
         this.beamGroupSizes = beamGrouping === "3-2-2" /* _3_2_2 */ ? [[3], [2], [2]] : [[2], [2], [3]];
@@ -1994,6 +1996,8 @@ export {
   getScaleFactoryList,
   getTempoString,
   getTuningStrings,
+  isNoteLength,
+  isTupletRatio,
   validateGuitarNoteLabel,
   validateHandedness,
   validateIntervalQuality,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tspro/web-music-score",
-    "version": "5.2.0",
+    "version": "5.4.0",
     "author": "PahkaSoft",
     "license": "MIT",
     "private": false,
@@ -106,7 +106,7 @@
         "package.json"
     ],
     "dependencies": {
-        "@tspro/ts-utils-lib": "^1.8.0",
+        "@tspro/ts-utils-lib": "^2.1.0",
         "tone": "^15.1.22"
     },
     "peerDependencies": {
@@ -128,8 +128,9 @@
     "scripts": {
         "build": "tsup",
         "watch": "tsup --watch",
-        "build:dev (all workspaces)": "npm run build && npm run build:dev --workspaces --if-present",
-        "build:prod (all workspaces)": "npm run build && npm run build:prod --workspaces --if-present",
+        "build:all": "npm run build && npm run build:prod --workspaces --if-present",
+        "start:features-demo": "npm run start --workspace features-demo",
+        "start:guitar-app": "npm run start --workspace guitar-app",
         "docs": "typedoc"
     }
 }