@musodojo/music-theory-data 17.0.0 → 19.0.1

package/README.md

@@ -13,9 +13,9 @@ more.**
 ## Verified Note Collections
 
 - ✅ Diatonic Modes
-- 🛠️ Pentatonic Variants
-- 🛠️ Major Variants
-- 🛠️ Minor Variants
+- ✅ Pentatonic Variants
+- ✅ Major Variants
+- ✅ Minor Variants
 - 🛠️ Dominant Variants
 - ✅ Harmonic Minor Modes
 - ✅ Melodic Minor Modes
@@ -38,16 +38,16 @@ more.**
 
 ### Deno / JSR
 
-Import directly from JSR in your Deno project:
+Install the package from the JSR registry:
 
-```ts
-import * as music_theory_data from "@musodojo/music-theory-data";
+```bash
+deno add jsr:@musodojo/music-theory-data
 ```
 
-or
+Then import it into your project:
 
 ```ts
-import * as music_theory_data from "jsr:@musodojo/music-theory-data";
+import * as music_theory_data from "@musodojo/music-theory-data";
 ```
 
 ### Node.js / npm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@musodojo/music-theory-data",
-  "version": "17.0.0",
+  "version": "19.0.1",
   "description": "The musician-friendly TypeScript library for modes, scales, chords, and more.",
   "keywords": [
     "music",

package/src/data/labels/note-labels.ts

@@ -1,4 +1,4 @@
-export type NoteInteger = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export type RootNoteInteger = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
 
 const _noteLetters = [
   "C",
@@ -53,15 +53,16 @@ export const noteNames: readonly NoteName[] = enharmonicNoteNameGroups.flat();
 
 export const noteNamesSet: ReadonlySet<NoteName> = new Set(noteNames);
 
-export const noteNameToIntegerMap: ReadonlyMap<NoteName, NoteInteger> = (() => {
-  const map = new Map<NoteName, NoteInteger>();
-  _enharmonicNoteNameGroups.forEach((group, index) => {
-    group.forEach((note) => {
-      map.set(note, index as NoteInteger);
+export const noteNameToIntegerMap: ReadonlyMap<NoteName, RootNoteInteger> =
+  (() => {
+    const map = new Map<NoteName, RootNoteInteger>();
+    _enharmonicNoteNameGroups.forEach((group, index) => {
+      group.forEach((note) => {
+        map.set(note, index as RootNoteInteger);
+      });
     });
-  });
-  return map;
-})();
+    return map;
+  })();
 
 const _enharmonicRootNoteGroups = [
   ["C", "B♯"],
@@ -87,15 +88,16 @@ export const rootNotes: readonly RootNote[] = enharmonicRootNoteGroups.flat();
 
 export const rootNotesSet: ReadonlySet<RootNote> = new Set(rootNotes);
 
-export const rootNoteToIntegerMap: ReadonlyMap<RootNote, NoteInteger> = (() => {
-  const map = new Map<RootNote, NoteInteger>();
-  enharmonicRootNoteGroups.forEach((group, index) => {
-    group.forEach((note) => {
-      map.set(note, index as NoteInteger);
+export const rootNoteToIntegerMap: ReadonlyMap<RootNote, RootNoteInteger> =
+  (() => {
+    const map = new Map<RootNote, RootNoteInteger>();
+    enharmonicRootNoteGroups.forEach((group, index) => {
+      group.forEach((note) => {
+        map.set(note, index as RootNoteInteger);
+      });
     });
-  });
-  return map;
-})();
+    return map;
+  })();
 
 export type SimpleIntervalNumber =
   | "1"

package/src/data/note-collections/diatonic-modes.ts

@@ -1,8 +1,9 @@
-import type { ScaleCollection } from "../../types/note-collections.d.ts";
+import type { ModalScaleCollection } from "../../types/note-collections.d.ts";
 
-const ionian: ScaleCollection = {
+const ionian: ModalScaleCollection = {
   category: "scale",
   rotation: 0,
+  parentScale: "ionian",
   primaryName: "Major",
   names: [
     "Major",
@@ -41,9 +42,10 @@ const ionian: ScaleCollection = {
   patternShort: ["W", "W", "H", "W", "W", "W", "H"],
 } as const;
 
-const dorian: ScaleCollection = {
+const dorian: ModalScaleCollection = {
   category: "scale",
   rotation: 1,
+  parentScale: "ionian",
   primaryName: "Dorian",
   names: [
     "Dorian",
@@ -80,9 +82,10 @@ const dorian: ScaleCollection = {
   patternShort: ["W", "H", "W", "W", "W", "H", "W"],
 } as const;
 
-const phrygian: ScaleCollection = {
+const phrygian: ModalScaleCollection = {
   category: "scale",
   rotation: 2,
+  parentScale: "ionian",
   primaryName: "Phrygian",
   names: [
     "Phrygian",
@@ -117,9 +120,10 @@ const phrygian: ScaleCollection = {
   patternShort: ["H", "W", "W", "W", "H", "W", "W"],
 } as const;
 
-const lydian: ScaleCollection = {
+const lydian: ModalScaleCollection = {
   category: "scale",
   rotation: 3,
+  parentScale: "ionian",
   primaryName: "Lydian",
   names: ["Lydian", "Major ♯4", "Lydian Mode"],
   intervals: ["1", "2", "3", "♯4", "5", "6", "7", "8"],
@@ -148,9 +152,10 @@ const lydian: ScaleCollection = {
   patternShort: ["W", "W", "W", "H", "W", "W", "H"],
 } as const;
 
-const mixolydian: ScaleCollection = {
+const mixolydian: ModalScaleCollection = {
   category: "scale",
   rotation: 4,
+  parentScale: "ionian",
   primaryName: "Mixolydian",
   names: [
     "Mixolydian",
@@ -185,9 +190,10 @@ const mixolydian: ScaleCollection = {
   patternShort: ["W", "W", "H", "W", "W", "H", "W"],
 } as const;
 
-const aeolian: ScaleCollection = {
+const aeolian: ModalScaleCollection = {
   category: "scale",
   rotation: 5,
+  parentScale: "ionian",
   primaryName: "Minor",
   names: [
     "Minor",
@@ -223,9 +229,10 @@ const aeolian: ScaleCollection = {
   patternShort: ["W", "H", "W", "W", "H", "W", "W"],
 } as const;
 
-const locrian: ScaleCollection = {
+const locrian: ModalScaleCollection = {
   category: "scale",
   rotation: 6,
+  parentScale: "ionian",
   primaryName: "Locrian",
   names: [
     "Locrian",
@@ -270,5 +277,5 @@ const _diatonicModes = {
 
 export type DiatonicModeKey = keyof typeof _diatonicModes;
 
-export const diatonicModes: Record<DiatonicModeKey, ScaleCollection> =
+export const diatonicModes: Record<DiatonicModeKey, ModalScaleCollection> =
   _diatonicModes;

package/src/data/note-collections/diminished-variants.ts

@@ -1,7 +1,7 @@
 import type {
   ChordCollection,
+  ModalScaleCollection,
   NoteCollection,
-  ScaleCollection,
 } from "../../types/note-collections.d.ts";
 
 const diminishedTriad: ChordCollection = {
@@ -40,9 +40,10 @@ const halfDiminished7: ChordCollection = {
   patternShort: ["m3", "m3", "M3"],
 } as const;
 
-const wholeHalfDiminished: ScaleCollection = {
+const wholeHalfDiminished: ModalScaleCollection = {
   category: "scale",
   rotation: 0,
+  parentScale: "wholeHalfDiminished",
   primaryName: "Whole Half Diminished",
   names: ["Whole Half Diminished"],
   intervals: ["1", "2", "♭3", "4", "♭5", "♭6", "6", "7", "8"],
@@ -53,9 +54,10 @@ const wholeHalfDiminished: ScaleCollection = {
   patternShort: ["W", "H", "W", "H", "W", "H", "W", "H"],
 } as const;
 
-const halfWholeDiminished: ScaleCollection = {
+const halfWholeDiminished: ModalScaleCollection = {
   category: "scale",
   rotation: 1,
+  parentScale: "wholeHalfDiminished",
   primaryName: "Half Whole Diminished",
   names: ["Half Whole Diminished", "Dominant Diminished"],
   intervals: ["1", "♭2", "♭3", "3", "♯4", "5", "6", "♭7", "8"],

package/src/data/note-collections/dominant-variants.ts

@@ -1,7 +1,7 @@
 import type {
   ChordCollection,
+  NonModalScaleCollection,
   NoteCollection,
-  ScaleCollection,
 } from "../../types/note-collections.d.ts";
 
 const dominant7: ChordCollection = {
@@ -105,7 +105,7 @@ const dominant13: ChordCollection = {
   patternShort: ["M3", "m3", "m3", "M3", "m3", "m3"],
 } as const;
 
-const dominantPentatonic: ScaleCollection = {
+const dominantPentatonic: NonModalScaleCollection = {
   category: "scale",
   primaryName: "Dominant Pentatonic",
   names: ["Dominant Pentatonic"],

package/src/data/note-collections/harmonic-minor-modes.ts

@@ -1,8 +1,9 @@
-import type { ScaleCollection } from "../../types/note-collections.d.ts";
+import type { ModalScaleCollection } from "../../types/note-collections.d.ts";
 
-const harmonicMinor: ScaleCollection = {
+const harmonicMinor: ModalScaleCollection = {
   category: "scale",
   rotation: 0,
+  parentScale: "harmonicMinor",
   primaryName: "Harmonic Minor",
   names: [
     "Harmonic Minor",
@@ -34,9 +35,10 @@ const harmonicMinor: ScaleCollection = {
   patternShort: ["W", "H", "W", "W", "H", "A2", "H"],
 } as const;
 
-const locrianNatural6: ScaleCollection = {
+const locrianNatural6: ModalScaleCollection = {
   category: "scale",
   rotation: 1,
+  parentScale: "harmonicMinor",
   primaryName: "Locrian ♮6",
   names: ["Locrian ♮6", "Locrian Natural Sixth", "Locrian Raised Sixth"],
   intervals: ["1", "♭2", "♭3", "4", "♭5", "6", "♭7", "8"],
@@ -61,9 +63,10 @@ const locrianNatural6: ScaleCollection = {
   patternShort: ["H", "W", "W", "H", "A2", "H", "W"],
 } as const;
 
-const ionianSharp5: ScaleCollection = {
+const ionianSharp5: ModalScaleCollection = {
   category: "scale",
   rotation: 2,
+  parentScale: "harmonicMinor",
   primaryName: "Ionian ♯5",
   names: [
     "Ionian ♯5",
@@ -100,9 +103,10 @@ const ionianSharp5: ScaleCollection = {
   patternShort: ["W", "W", "H", "A2", "H", "W", "H"],
 } as const;
 
-const dorianSharp4: ScaleCollection = {
+const dorianSharp4: ModalScaleCollection = {
   category: "scale",
   rotation: 3,
+  parentScale: "harmonicMinor",
   primaryName: "Dorian ♯4",
   names: [
     "Dorian ♯4",
@@ -133,9 +137,10 @@ const dorianSharp4: ScaleCollection = {
   patternShort: ["W", "H", "A2", "H", "W", "H", "W"],
 } as const;
 
-const phrygianDominant: ScaleCollection = {
+const phrygianDominant: ModalScaleCollection = {
   category: "scale",
   rotation: 4,
+  parentScale: "harmonicMinor",
   primaryName: "Phrygian Dominant",
   names: [
     "Phrygian Dominant",
@@ -172,9 +177,10 @@ const phrygianDominant: ScaleCollection = {
   patternShort: ["H", "A2", "H", "W", "H", "W", "W"],
 } as const;
 
-const lydianSharp2: ScaleCollection = {
+const lydianSharp2: ModalScaleCollection = {
   category: "scale",
   rotation: 5,
+  parentScale: "harmonicMinor",
   primaryName: "Lydian ♯2",
   names: [
     "Lydian ♯2",
@@ -204,9 +210,10 @@ const lydianSharp2: ScaleCollection = {
   patternShort: ["A2", "H", "W", "H", "W", "W", "H"],
 } as const;
 
-const superLocrianDoubleFlat7: ScaleCollection = {
+const superLocrianDoubleFlat7: ModalScaleCollection = {
   category: "scale",
   rotation: 6,
+  parentScale: "harmonicMinor",
   primaryName: "Super Locrian 𝄫7",
   names: [
     "Super Locrian 𝄫7",
@@ -248,5 +255,7 @@ export const _harmonicMinorModes = {
 
 export type HarmonicMinorModeKey = keyof typeof _harmonicMinorModes;
 
-export const harmonicMinorModes: Record<HarmonicMinorModeKey, ScaleCollection> =
-  _harmonicMinorModes;
+export const harmonicMinorModes: Record<
+  HarmonicMinorModeKey,
+  ModalScaleCollection
+> = _harmonicMinorModes;

package/src/data/note-collections/major-variants.ts

@@ -61,7 +61,7 @@ const major9: ChordCollection = {
   primaryName: "M9",
   names: ["M9", "maj9", "Major 9th", "Major Ninth", "Δ9"],
   intervals: ["1", "3", "5", "7", "9"],
-  integers: [0, 2, 4, 7, 11],
+  integers: [0, 4, 7, 11, 14],
   type: ["major", "chord", "arpeggio", "pentad"],
   characteristics: [
     "stable",
@@ -81,7 +81,7 @@ const majorAdd9: ChordCollection = {
   primaryName: "add9",
   names: ["add9", "maj(add9)", "M(add9)", "Major add 9"],
   intervals: ["1", "3", "5", "9"],
-  integers: [0, 2, 4, 7],
+  integers: [0, 4, 7, 14],
   type: ["major", "chord", "arpeggio", "tetrad"],
   characteristics: [
     "stable",
@@ -101,7 +101,7 @@ const major6Add9: ChordCollection = {
   primaryName: "6/9",
   names: ["6/9", "M6/9", "maj6/9", "Major 6/9", "6add9", "Major add 6 add 9"],
   intervals: ["1", "3", "5", "6", "9"],
-  integers: [0, 2, 4, 7, 9],
+  integers: [0, 4, 7, 9, 14],
   type: ["major", "chord", "arpeggio", "pentad"],
   characteristics: [
     "stable",

package/src/data/note-collections/melodic-minor-modes.ts

@@ -1,8 +1,9 @@
-import type { ScaleCollection } from "../../types/note-collections.d.ts";
+import type { ModalScaleCollection } from "../../types/note-collections.d.ts";
 
-const melodicMinor: ScaleCollection = {
+const melodicMinor: ModalScaleCollection = {
   category: "scale",
   rotation: 0,
+  parentScale: "melodicMinor",
   primaryName: "Melodic Minor",
   names: [
     "Melodic Minor",
@@ -33,9 +34,10 @@ const melodicMinor: ScaleCollection = {
   patternShort: ["W", "H", "W", "W", "W", "W", "H"],
 } as const;
 
-const dorianFlat2: ScaleCollection = {
+const dorianFlat2: ModalScaleCollection = {
   category: "scale",
   rotation: 1,
+  parentScale: "melodicMinor",
   primaryName: "Dorian ♭2",
   names: [
     "Dorian ♭2",
@@ -59,9 +61,10 @@ const dorianFlat2: ScaleCollection = {
   patternShort: ["H", "W", "W", "W", "W", "H", "W"],
 } as const;
 
-const lydianAugmented: ScaleCollection = {
+const lydianAugmented: ModalScaleCollection = {
   category: "scale",
   rotation: 2,
+  parentScale: "melodicMinor",
   primaryName: "Lydian Augmented",
   names: ["Lydian Augmented", "Lydian ♯5", "Lydian Sharp Fifth"],
   intervals: ["1", "2", "3", "♯4", "♯5", "6", "7", "8"],
@@ -86,9 +89,10 @@ const lydianAugmented: ScaleCollection = {
   patternShort: ["W", "W", "W", "W", "H", "W", "H"],
 } as const;
 
-const lydianDominant: ScaleCollection = {
+const lydianDominant: ModalScaleCollection = {
   category: "scale",
   rotation: 3,
+  parentScale: "melodicMinor",
   primaryName: "Lydian Dominant",
   names: [
     "Lydian Dominant",
@@ -116,9 +120,10 @@ const lydianDominant: ScaleCollection = {
   patternShort: ["W", "W", "W", "H", "W", "H", "W"],
 } as const;
 
-const mixolydianFlat6: ScaleCollection = {
+const mixolydianFlat6: ModalScaleCollection = {
   category: "scale",
   rotation: 4,
+  parentScale: "melodicMinor",
   primaryName: "Mixolydian ♭6",
   names: [
     "Mixolydian ♭6",
@@ -143,9 +148,10 @@ const mixolydianFlat6: ScaleCollection = {
   patternShort: ["W", "W", "H", "W", "H", "W", "W"],
 } as const;
 
-const aeolianFlat5: ScaleCollection = {
+const aeolianFlat5: ModalScaleCollection = {
   category: "scale",
   rotation: 5,
+  parentScale: "melodicMinor",
   primaryName: "Aeolian ♭5",
   names: [
     "Aeolian ♭5",
@@ -170,9 +176,10 @@ const aeolianFlat5: ScaleCollection = {
   patternShort: ["W", "H", "W", "H", "W", "W", "W"],
 } as const;
 
-const altered: ScaleCollection = {
+const altered: ModalScaleCollection = {
   category: "scale",
   rotation: 6,
+  parentScale: "melodicMinor",
   primaryName: "Altered Scale",
   names: [
     "Altered Scale",
@@ -208,5 +215,7 @@ export const _melodicMinorModes = {
 
 export type MelodicMinorModeKey = keyof typeof _melodicMinorModes;
 
-export const melodicMinorModes: Record<MelodicMinorModeKey, ScaleCollection> =
-  _melodicMinorModes;
+export const melodicMinorModes: Record<
+  MelodicMinorModeKey,
+  ModalScaleCollection
+> = _melodicMinorModes;

package/src/data/note-collections/minor-variants.ts

@@ -46,12 +46,35 @@ const minor7: ChordCollection = {
   patternShort: ["m3", "M3", "m3"],
 } as const;
 
+const minorMajor7: ChordCollection = {
+  category: "chord",
+  primaryName: "m(M7)",
+  names: [
+    "m(M7)",
+    "min(M7)",
+    "Minor (Major 7th)",
+    "Minor Major Seventh",
+    "mM7",
+    "-M7",
+    "-(maj7)",
+  ],
+  intervals: ["1", "♭3", "5", "7"],
+  integers: [0, 3, 7, 11],
+  type: ["minor", "chord", "arpeggio", "tetrad"],
+  characteristics: [
+    "smooth",
+    "jazzy",
+  ],
+  pattern: ["minor third", "major third", "major third"],
+  patternShort: ["m3", "M3", "M3"],
+};
+
 const minor9: ChordCollection = {
   category: "chord",
   primaryName: "m9",
   names: ["m9", "min9", "Minor 9th", "Minor Ninth", "-9"],
   intervals: ["1", "♭3", "5", "♭7", "9"],
-  integers: [0, 2, 3, 7, 10],
+  integers: [0, 3, 7, 10, 14],
   type: ["minor", "chord", "arpeggio", "pentad"],
   characteristics: ["rich", "lush", "sophisticated", "common in jazz"],
   pattern: ["minor third", "major third", "minor third", "major third"],
@@ -63,7 +86,7 @@ const minorAdd9: ChordCollection = {
   primaryName: "m(add9)",
   names: ["m(add9)", "min(add9)", "Minor add 9"],
   intervals: ["1", "♭3", "5", "9"],
-  integers: [0, 2, 3, 7],
+  integers: [0, 3, 7, 14],
   type: ["minor", "chord", "arpeggio", "tetrad"],
   characteristics: [
     "open",
@@ -78,9 +101,9 @@ const minorAdd9: ChordCollection = {
 const minor6Add9: ChordCollection = {
   category: "chord",
   primaryName: "m6/9",
-  names: ["m6/9", "min6/9", "Minor 6/9"],
+  names: ["m6/9", "min6/9", "Minor 6/9", "-6/9"],
   intervals: ["1", "♭3", "5", "6", "9"],
-  integers: [0, 2, 3, 7, 9],
+  integers: [0, 3, 7, 9, 14],
   type: ["minor", "chord", "arpeggio", "pentad"],
   characteristics: [
     "rich",
@@ -96,6 +119,7 @@ export const _minorVariants = {
   minor,
   minor6,
   minor7,
+  minorMajor7,
   minor9,
   minorAdd9,
   minor6Add9,

package/src/data/note-collections/other-collections.ts

@@ -49,11 +49,8 @@ const chromatic: ScaleCollection = {
 
 const wholeTone: ScaleCollection = {
   category: "scale",
-  rotation: 0,
   primaryName: "Whole Tone Scale",
-  names: [
-    "Whole Tone Scale",
-  ],
+  names: ["Whole Tone Scale"],
   intervals: ["1", "2", "3", "♯4", "♯5", "♯6", "8"],
   integers: [0, 2, 4, 6, 8, 10],
   type: ["whole tone", "scale", "symmetrical", "hexatonic"],

package/src/data/note-collections/pentatonic-variants.ts

@@ -1,8 +1,9 @@
-import type { ScaleCollection } from "../../types/note-collections.d.ts";
+import type { ModalScaleCollection } from "../../types/note-collections.d.ts";
 
-const majorPentatonic: ScaleCollection = {
+const majorPentatonic: ModalScaleCollection = {
   category: "scale",
   rotation: 0,
+  parentScale: "majorPentatonic",
   primaryName: "Major Pentatonic",
   names: ["Major Pentatonic"],
   intervals: ["1", "2", "3", "5", "6", "8"],
@@ -20,48 +21,52 @@ const majorPentatonic: ScaleCollection = {
   patternShort: ["W", "W", "m3", "W", "m3"],
 } as const;
 
-const suspendedPentatonic: ScaleCollection = {
+const suspendedPentatonic: ModalScaleCollection = {
   category: "scale",
   rotation: 1,
+  parentScale: "majorPentatonic",
   primaryName: "Suspended Pentatonic",
   names: ["Suspended Pentatonic", "Egyptian Pentatonic"],
   intervals: ["1", "2", "4", "5", "♭7", "8"],
   integers: [0, 2, 5, 7, 10],
   type: ["suspended", "pentatonic", "scale", "gapped scale"],
   characteristics: ["open", "stable", "neutral", "neither major nor minor"],
-  pattern: ["whole", "minor third", "whole", "minor third"],
-  patternShort: ["W", "m3", "W", "m3"],
+  pattern: ["whole", "minor third", "whole", "minor third", "whole"],
+  patternShort: ["W", "m3", "W", "m3", "W"],
 } as const;
 
-const bluesMinorPentatonic: ScaleCollection = {
+const bluesMinorPentatonic: ModalScaleCollection = {
   category: "scale",
   rotation: 2,
+  parentScale: "majorPentatonic",
   primaryName: "Blues Minor Pentatonic",
   names: ["Blues Minor Pentatonic"],
-  intervals: ["1", "♭3", "4", "♭5", "♭7", "8"],
+  intervals: ["1", "♭3", "4", "♭6", "♭7", "8"],
   integers: [0, 3, 5, 8, 10],
   type: ["minor", "pentatonic", "scale", "gapped scale", "blues"],
-  characteristics: ["bluesy", "tense", "minor with a blue note"],
-  pattern: ["minor third", "whole", "half", "minor third"],
-  patternShort: ["m3", "W", "H", "m3"],
+  characteristics: ["bluesy", "tense"],
+  pattern: ["minor third", "whole", "minor third", "whole", "whole"],
+  patternShort: ["m3", "W", "m3", "W", "W"],
 } as const;
 
-const bluesMajorPentatonic: ScaleCollection = {
+const bluesMajorPentatonic: ModalScaleCollection = {
   category: "scale",
   rotation: 3,
+  parentScale: "majorPentatonic",
   primaryName: "Blues Major Pentatonic",
   names: ["Blues Major Pentatonic"],
-  intervals: ["1", "2", "♭3", "5", "6", "8"],
+  intervals: ["1", "2", "4", "5", "6", "8"],
   integers: [0, 2, 5, 7, 9],
   type: ["major", "pentatonic", "scale", "gapped scale", "blues"],
-  characteristics: ["bluesy", "country", "major with a blue note"],
-  pattern: ["whole", "half", "major third", "whole"],
-  patternShort: ["W", "H", "M3", "W"],
+  characteristics: ["bluesy", "country"],
+  pattern: ["whole", "minor third", "whole", "whole", "minor third"],
+  patternShort: ["W", "m3", "W", "W", "m3"],
 } as const;
 
-const minorPentatonic: ScaleCollection = {
+const minorPentatonic: ModalScaleCollection = {
   category: "scale",
   rotation: 4,
+  parentScale: "majorPentatonic",
   primaryName: "Minor Pentatonic",
   names: ["Minor Pentatonic"],
   intervals: ["1", "♭3", "4", "5", "♭7", "8"],
@@ -88,5 +93,7 @@ export const _pentatonicVariants = {
 
 export type PentatonicVariantKey = keyof typeof _pentatonicVariants;
 
-export const pentatonicVariants: Record<PentatonicVariantKey, ScaleCollection> =
-  _pentatonicVariants;
+export const pentatonicVariants: Record<
+  PentatonicVariantKey,
+  ModalScaleCollection
+> = _pentatonicVariants;

package/src/types/midi.d.ts

@@ -1,5 +1,3 @@
-export type OctaveNumber = -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-
 export type MidiNoteNumber =
   | 0
   | 1

package/src/types/note-collections.d.ts

@@ -1,4 +1,4 @@
-import type { Interval, NoteInteger } from "../data/labels/note-labels.ts";
+import type { Interval } from "../data/labels/note-labels.ts";
 
 export type CollectionCategory = "scale" | "chord";
 
@@ -20,10 +20,11 @@ interface NoteCollectionBase {
    */
   readonly intervals: readonly Interval[];
   /**
-   * The set of pitch classes as integers (0-11), representing semitones from the root.
-   * This set never includes the octave.
+   * The set of semitone values from the root.
+   * - For **scales**, this is a pitch class set (0-11) and does not include the octave.
+   * - For **chords**, this can include values > 11 to represent extensions (e.g., 14 for a 9th).
    */
-  readonly integers: readonly NoteInteger[];
+  readonly integers: readonly number[];
   /**
    * An array of tags used for classification and filtering.
    * e.g., ["major", "scale", "heptatonic", "diatonic mode"]
@@ -48,20 +49,29 @@ interface NoteCollectionBase {
   readonly patternShort: readonly string[];
 }
 
-export interface ScaleCollection extends NoteCollectionBase {
+/** A scale that can be thought of as a mode of a parent scale (e.g., Ionian, Dorian, Lydian Augmented). */
+interface ModalScaleCollection extends NoteCollectionBase {
   /**
    * The fundamental classification of the collection. For scales, this is always "scale".
-   * This influences the interpretation of other properties:
-   * - `intervals` conventionally includes the octave ("8").
-   * - `pattern` represents steps between consecutive notes.
    */
   readonly category: "scale";
   /**
-   * The rotation index relative to a parent scale (e.g., for diatonic modes).
-   * Ionian is 0, Dorian is 1, etc. This property is optional and only applies
-   * to collections that are modes of another scale.
+   * The rotation index for a parent scale is always 0.
+   * The rotation index relative to a parent scale. e.g., Dorian is 1.
    */
-  readonly rotation?: number;
+  readonly rotation: number;
+  /**
+   * The key-name (e.g., "ionian") of the parent scale from which this mode is derived.
+   * The parent scale has itself as parentScale!
+   */
+  readonly parentScale: string;
+}
+
+/** A scale that is not a mode of another scale in this collection. */
+interface NonModalScaleCollection extends NoteCollectionBase {
+  readonly category: "scale";
+  readonly rotation?: never;
+  readonly parentScale?: never;
 }
 
 export interface ChordCollection extends NoteCollectionBase {
@@ -69,4 +79,8 @@ export interface ChordCollection extends NoteCollectionBase {
   readonly rotation?: never;
 }
 
+export type ScaleCollection =
+  | ModalScaleCollection
+  | NonModalScaleCollection;
+
 export type NoteCollection = ScaleCollection | ChordCollection;

package/src/utils/chords.ts

@@ -100,11 +100,6 @@ export function getChordDetailsForDiatonicMode(
   diatonicModeKey: DiatonicModeKey,
 ): ChordDetails[] {
   const mode = diatonicModes[diatonicModeKey];
-  if (mode.rotation === undefined) {
-    throw new Error(
-      `Mode "${diatonicModeKey}" is missing the 'rotation' property.`,
-    );
-  }
   const rotation = mode.rotation;
   const rotatedTriads = rotateArray(diatonicTriads, rotation);
   const rotatedSeventhChords = rotateArray(diatonicSeventhChords, rotation);
@@ -121,11 +116,6 @@ export function getChordDetailsForHarmonicMinorMode(
   harmonicMinorModeKey: HarmonicMinorModeKey,
 ): ChordDetails[] {
   const mode = harmonicMinorModes[harmonicMinorModeKey];
-  if (mode.rotation === undefined) {
-    throw new Error(
-      `Mode "${harmonicMinorModeKey}" is missing the 'rotation' property.`,
-    );
-  }
   const rotation = mode.rotation;
   const rotatedTriads = rotateArray(harmonicMinorTriads, rotation);
   const rotatedSeventhChords = rotateArray(
@@ -145,11 +135,6 @@ export function getChordDetailsForMelodicMinorMode(
   melodicMinorModeKey: MelodicMinorModeKey,
 ): ChordDetails[] {
   const mode = melodicMinorModes[melodicMinorModeKey];
-  if (mode.rotation === undefined) {
-    throw new Error(
-      `Mode "${melodicMinorModeKey}" is missing the 'rotation' property.`,
-    );
-  }
   const rotation = mode.rotation;
   const rotatedTriads = rotateArray(melodicMinorTriads, rotation);
   const rotatedSeventhChords = rotateArray(melodicMinorSeventhChords, rotation);

package/src/utils/midi-note-sequences.ts

@@ -1,6 +1,6 @@
 import type { Interval } from "../data/labels/note-labels.ts";
 import type { MidiNoteNumber, MidiNoteSequence } from "../types/midi.d.ts";
-import { rootMidiAndIntervalToMidi } from "./midi.ts";
+import { noteMidiAndIntervalToMidi } from "./midi.ts";
 
 export type MidiNoteSequenceDirection =
   | "ascending"
@@ -50,7 +50,7 @@ function getMonotonicMidiNoteSequence(
       intervalIndex = (startFromIndex + i) % intervalsLength;
       octaveOffset = Math.floor((startFromIndex + i) / intervalsLength) * 12;
       const interval = intervals[intervalIndex];
-      const note = rootMidiAndIntervalToMidi(rootNoteMidi, interval);
+      const note = noteMidiAndIntervalToMidi(rootNoteMidi, interval);
       if (note === undefined) {
         throw new Error(
           `Could not calculate MIDI note for interval ${interval} at index ${intervalIndex}`,
@@ -75,7 +75,7 @@ function getMonotonicMidiNoteSequence(
         Math.max(0, Math.ceil((i - startFromIndex) / intervalsLength)) * 12;
       const interval = intervals[intervalIndex];
       // Subtract octaveOffset from root before applying interval
-      const note = rootMidiAndIntervalToMidi(
+      const note = noteMidiAndIntervalToMidi(
         (rootNoteMidi - octaveOffset) as MidiNoteNumber,
         interval,
       );

package/src/utils/midi.ts

@@ -1,50 +1,51 @@
 import {
   type Interval,
   intervalToIntegerMap,
-  type NoteInteger,
   type NoteName,
   noteNameToIntegerMap,
 } from "../data/labels/note-labels.ts";
 
-import type { MidiNoteNumber, OctaveNumber } from "../types/midi.d.ts";
+import type { MidiNoteNumber } from "../types/midi.d.ts";
 
-export function rootIntegerAndIntervalToMidi(
-  rootNoteInteger: NoteInteger,
+export function noteIntegerAndIntervalToMidi(
+  noteInteger: number,
+  noteOctaveNumber: number,
   interval: Interval,
-  rootNoteOctaveNumber: OctaveNumber = 4,
 ): MidiNoteNumber | undefined {
-  const intervalValue = intervalToIntegerMap.get(interval);
-  if (intervalValue === undefined) return undefined;
-  return (rootNoteOctaveNumber + 1) * 12 + rootNoteInteger +
-    intervalValue as MidiNoteNumber;
+  const intervalInteger = intervalToIntegerMap.get(interval);
+  if (intervalInteger === undefined) return undefined;
+  return (noteOctaveNumber + 1) * 12 + noteInteger +
+    intervalInteger as MidiNoteNumber;
 }
 
-export function rootMidiAndIntervalToMidi(
-  rootNoteMidi: MidiNoteNumber,
+export function noteNameAndIntervalToMidi(
+  noteName: NoteName,
+  noteOctaveNumber: number,
   interval: Interval,
 ): MidiNoteNumber | undefined {
-  const intervalValue = intervalToIntegerMap.get(interval);
-  if (intervalValue === undefined) return undefined;
-  return rootNoteMidi + intervalValue as MidiNoteNumber;
+  const noteInteger = noteNameToIntegerMap.get(noteName);
+  if (noteInteger === undefined) return undefined;
+  return noteIntegerAndIntervalToMidi(
+    noteInteger,
+    noteOctaveNumber,
+    interval,
+  );
 }
 
-export function noteNameToMidi(
-  noteName: NoteName,
-  octaveNumber: OctaveNumber = 4,
+export function noteMidiAndIntervalToMidi(
+  noteMidi: MidiNoteNumber,
+  interval: Interval,
 ): MidiNoteNumber | undefined {
-  const noteValue = noteNameToIntegerMap.get(noteName);
-  if (noteValue === undefined) return undefined;
-  return noteValue + (octaveNumber + 1) * 12 as MidiNoteNumber;
+  const intervalValue = intervalToIntegerMap.get(interval);
+  if (intervalValue === undefined) return undefined;
+  return noteMidi + intervalValue as MidiNoteNumber;
 }
 
-export function noteNameAndIntervalToMidi(
+export function noteNameToMidi(
   noteName: NoteName,
-  interval: Interval,
-  octaveNumber: OctaveNumber = 4,
+  noteOctaveNumber: number,
 ): MidiNoteNumber | undefined {
   const noteValue = noteNameToIntegerMap.get(noteName);
   if (noteValue === undefined) return undefined;
-  const intervalValue = intervalToIntegerMap.get(interval);
-  if (intervalValue === undefined) return undefined;
-  return noteValue + (octaveNumber + 1) * 12 as MidiNoteNumber;
+  return noteValue + (noteOctaveNumber + 1) * 12 as MidiNoteNumber;
 }

package/src/utils/note-names.ts

@@ -2,13 +2,13 @@ import {
   enharmonicNoteNameGroups,
   type Interval,
   intervalToIntegerMap,
-  type NoteInteger,
   type NoteLetter,
   noteLetters,
   type NoteName,
   noteNamesSet,
   noteNameToIntegerMap,
   type RootNote,
+  type RootNoteInteger,
   rootNotesSet,
 } from "../data/labels/note-labels.ts";
 import {
@@ -122,18 +122,12 @@ export function normalizeRootNoteString(name: string): RootNote | undefined {
   return undefined;
 }
 
-export function noteNameToInteger(
-  noteName: NoteName,
-): NoteInteger | undefined {
-  return noteNameToIntegerMap.get(noteName);
-}
-
-export function noteNameStringToInteger(
+export function getNoteIntegerFromString(
   noteName: string,
-): NoteInteger | undefined {
+): RootNoteInteger | undefined {
   const normalized = normalizeNoteNameString(noteName);
   if (!normalized) return undefined;
-  return noteNameToInteger(normalized);
+  return noteNameToIntegerMap.get(normalized);
 }
 
 export function getNoteNamesFromRootAndIntervals(
@@ -141,7 +135,7 @@ export function getNoteNamesFromRootAndIntervals(
   intervals: readonly Interval[],
   options: TransformIntervalsOptions = {},
 ): NoteName[] {
-  const rootNoteInteger = noteNameToInteger(rootNote);
+  const rootNoteInteger = noteNameToIntegerMap.get(rootNote);
   if (rootNoteInteger === undefined) return [];
   const rootNoteLetter = rootNote.charAt(0).toUpperCase();
   const rootNoteLetterIndex = noteLetters.indexOf(rootNoteLetter as NoteLetter);