@libraz/libcantus 0.9.1 → 0.9.3

package/src/analyze/functional/function.ts

@@ -0,0 +1,184 @@
+/**
+ * Harmonic function (tonic / subdominant / dominant), diatonicity, parallel-key
+ * mirroring, and full chord analysis.
+ *
+ * Roots are pitch classes measured against the key tonic, so borrowed and
+ * chromatic chords are handled by their semitone offset rather than requiring a
+ * spelled key signature.
+ */
+
+import type { KeyScale } from '../../core/types.js';
+import type { Chord, ChordQuality } from '../../theory/chord/index.js';
+import { chordPitchClasses, makeChord } from '../../theory/chord/index.js';
+import { isScaleTone, MAJOR_MASK, NATURAL_MINOR_MASK } from '../../theory/scale/index.js';
+import { type BorrowedSource, borrowedSource } from './borrowed.js';
+import { degreeRootPc, isNeapolitan, mod12 } from './internal.js';
+import { chordToRoman } from './roman.js';
+
+/**
+ * The three broad harmonic functions of tonal music.
+ *
+ * @category Functional Harmony
+ */
+export type HarmonicFunction = 'tonic' | 'subdominant' | 'dominant';
+
+/** Harmonic function of each semitone offset above the tonic (major context). */
+const FUNCTION_BY_OFFSET: readonly HarmonicFunction[] = [
+  'tonic', // 0  I
+  'subdominant', // 1  bII (Neapolitan)
+  'subdominant', // 2  ii
+  'tonic', // 3  bIII
+  'tonic', // 4  iii
+  'subdominant', // 5  IV
+  'dominant', // 6  #IV / bV
+  'dominant', // 7  V
+  'subdominant', // 8  bVI
+  'tonic', // 9  vi
+  'subdominant', // 10 bVII
+  'dominant', // 11 vii
+];
+
+/**
+ * Whether a key's scale has a minor third and no major third (a minor key).
+ *
+ * @category Functional Harmony
+ */
+export function isMinorKey(key: KeyScale): boolean {
+  const hasMinorThird = (key.modeMask12 >> 3) & 1;
+  const hasMajorThird = (key.modeMask12 >> 4) & 1;
+  return Boolean(hasMinorThird) && !hasMajorThird;
+}
+
+/**
+ * The harmonic function of a chord in a key, from its root's offset above the
+ * tonic. The mapping follows common-practice major-key function and is a useful
+ * approximation in minor and for borrowed chords.
+ *
+ * @param chord The chord.
+ * @param key The prevailing key.
+ * @returns The harmonic function.
+ * @category Functional Harmony
+ */
+export function functionOf(chord: Chord, key: KeyScale): HarmonicFunction {
+  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? 'tonic';
+}
+
+/**
+ * The result of {@link analyzeChord}: function, borrowing, and Roman numeral.
+ *
+ * @category Functional Harmony
+ */
+export type ChordAnalysis = {
+  function: HarmonicFunction;
+  borrowed: boolean;
+  source: BorrowedSource;
+  roman: string;
+};
+
+/**
+ * Whether every pitch class of a chord belongs to the key's scale.
+ *
+ * The test is strict against the key's own mode mask: in a natural-minor key
+ * the harmonic-minor dominant (major V) is *not* diatonic, since the raised
+ * leading tone lies outside the mask. Borrowing predicates treat that case as
+ * an in-key alteration separately (see {@link isBorrowedChord}).
+ *
+ * @param chord The chord to test.
+ * @param key The prevailing key.
+ * @returns True if all chord pitch classes are scale tones.
+ * @category Functional Harmony
+ */
+export function isDiatonic(chord: Chord, key: KeyScale): boolean {
+  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
+}
+
+/**
+ * The parallel key: same tonic, opposite mode.
+ *
+ * A key with a minor third (natural/harmonic/melodic minor, dorian, phrygian)
+ * maps to the parallel major; any other key maps to the parallel natural minor.
+ *
+ * @param key The key to mirror.
+ * @returns The parallel major or natural-minor key on the same tonic.
+ * @category Functional Harmony
+ */
+export function parallelKey(key: KeyScale): KeyScale {
+  return {
+    rootPc: mod12(key.rootPc),
+    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK,
+  };
+}
+
+/** Diminished-family qualities: diminished triad, dim7, half-diminished. */
+function isDiminishedQuality(quality: ChordQuality): boolean {
+  return quality === 'dim' || quality === 'dim7' || quality === 'm7b5';
+}
+
+/** Whether the chord's interval template carries a major third above the root. */
+function hasMajorThird(chord: Chord): boolean {
+  return chord.intervals.some((interval) => mod12(interval) === 4);
+}
+
+/**
+ * Quality-aware harmonic function, refining the offset table where chord
+ * quality disambiguates: diminished chords on the leading tone or the raised
+ * subdominant resolve by semitone and act as dominants; the Neapolitan and the
+ * major-third chords on bVI/bVII borrowed from the parallel minor act as
+ * subdominant (predominant) harmony. All other chords keep {@link functionOf}.
+ */
+function qualityAwareFunction(chord: Chord, key: KeyScale): HarmonicFunction {
+  const offset = mod12(chord.rootPc - key.rootPc);
+  if (isDiminishedQuality(chord.quality) && (offset === 11 || offset === 6)) {
+    return 'dominant';
+  }
+  if (isNeapolitan(chord, key)) {
+    return 'subdominant';
+  }
+  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
+    return 'subdominant';
+  }
+  return functionOf(chord, key);
+}
+
+/**
+ * Analyze a chord in a key: harmonic function, borrowing, and Roman numeral.
+ *
+ * The function is quality-aware (see the predicates behind it), the source
+ * follows {@link borrowedSource}, and the numeral comes from
+ * {@link chordToRoman}. `borrowed` is true whenever a source is identified —
+ * including the Neapolitan, which the stricter parallel-mode predicate
+ * {@link isBorrowedChord} does not count.
+ *
+ * @param chord The chord to analyze.
+ * @param key The prevailing key.
+ * @returns The chord analysis.
+ * @example
+ * ```ts
+ * import { analyzeChord, makeChord, majorKey } from '@libraz/libcantus';
+ * analyzeChord(makeChord(7, 'dom7'), majorKey(0));
+ * // { function: 'dominant', borrowed: false, source: null, roman: 'V7' }
+ * ```
+ * @category Functional Harmony
+ */
+export function analyzeChord(chord: Chord, key: KeyScale): ChordAnalysis {
+  const source = borrowedSource(chord, key);
+  return {
+    function: qualityAwareFunction(chord, key),
+    borrowed: source !== null,
+    source,
+    roman: chordToRoman(chord, key),
+  };
+}
+
+/**
+ * The secondary dominant (V7) that tonicizes a scale degree.
+ *
+ * @param targetDegree 0-based scale degree to tonicize.
+ * @param key The prevailing key.
+ * @returns A dominant-seventh chord a fifth above the target's root.
+ * @category Functional Harmony
+ */
+export function secondaryDominant(targetDegree: number, key: KeyScale): Chord {
+  const targetRoot = degreeRootPc(targetDegree + 1, key);
+  return makeChord(mod12(targetRoot + 7), 'dom7');
+}

package/src/analyze/functional/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Functional harmony: Roman-numeral parsing and formatting, harmonic function
+ * (tonic / subdominant / dominant), cadence detection, and borrowed chords.
+ *
+ * Roots are pitch classes measured against the key tonic, so borrowed and
+ * chromatic chords are handled by their semitone offset rather than requiring a
+ * spelled key signature.
+ */
+
+export type { BorrowedSource } from './borrowed.js';
+export { borrowedSource, isBorrowedChord } from './borrowed.js';
+export type { Cadence } from './cadence.js';
+export { detectCadence } from './cadence.js';
+export type { ChordAnalysis, HarmonicFunction } from './function.js';
+export {
+  analyzeChord,
+  functionOf,
+  isDiatonic,
+  isMinorKey,
+  parallelKey,
+  secondaryDominant,
+} from './function.js';
+export { chordToRoman, romanToChord } from './roman.js';

package/src/analyze/functional/internal.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared helpers for the functional-harmony modules.
+ *
+ * Roots are pitch classes measured against the key tonic, so borrowed and
+ * chromatic chords are handled by their semitone offset rather than requiring a
+ * spelled key signature.
+ */
+
+import type { KeyScale } from '../../core/types.js';
+import type { Chord } from '../../theory/chord/index.js';
+import { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';
+
+export function mod12(n: number): number {
+  return ((n % 12) + 12) % 12;
+}
+
+/** Diatonic pitch class of a 1-based scale degree in a key. */
+export function degreeRootPc(degreeNumber: number, key: KeyScale): number {
+  const tones = scaleTonesInDegreeOrder(key);
+  if (tones.length === 0) {
+    return mod12(key.rootPc);
+  }
+  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);
+}
+
+/** Whether a chord is the Neapolitan: a major triad on the flat second degree. */
+export function isNeapolitan(chord: Chord, key: KeyScale): boolean {
+  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === 'maj';
+}

package/src/{functional/index.ts → analyze/functional/roman.ts}

@@ -1,37 +1,16 @@
 /**
- * Functional harmony: Roman-numeral parsing and formatting, harmonic function
- * (tonic / subdominant / dominant), and cadence detection.
+ * Roman-numeral parsing and formatting.
  *
- * Roots are pitch classes measured against the key tonic, so borrowed and
- * chromatic chords are handled by their semitone offset rather than requiring a
- * spelled key signature.
+ * The {@link ROMAN_STYLE} table is the single source of truth for both
+ * directions, so {@link chordToRoman} and {@link romanToChord} stay mutual
+ * inverses by construction.
  */
 
-import type { Chord, ChordQuality } from '../chord/index.js';
-import { chordPitchClasses, makeChord } from '../chord/index.js';
-import {
-  HARMONIC_MINOR_MASK,
-  isScaleTone,
-  MAJOR_MASK,
-  majorKey,
-  NATURAL_MINOR_MASK,
-  scaleTonesInDegreeOrder,
-} from '../scale/index.js';
-import type { KeyScale } from '../types.js';
-
-/**
- * The three broad harmonic functions of tonal music.
- *
- * @category Functional Harmony
- */
-export type HarmonicFunction = 'tonic' | 'subdominant' | 'dominant';
-
-/**
- * A recognized cadence type, or null when a chord pair forms none.
- *
- * @category Functional Harmony
- */
-export type Cadence = 'authentic' | 'plagal' | 'half' | 'deceptive' | null;
+import type { KeyScale } from '../../core/types.js';
+import type { Chord, ChordQuality } from '../../theory/chord/index.js';
+import { makeChord } from '../../theory/chord/index.js';
+import { majorKey, scaleTonesInDegreeOrder } from '../../theory/scale/index.js';
+import { degreeRootPc, mod12 } from './internal.js';
 
 /** Roman numeral glyphs indexed by degree number - 1. */
 const ROMAN = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII'] as const;
@@ -63,46 +42,6 @@ const OFFSET_SPELLING: readonly [number, string][] = [
   [7, ''],
 ];
 
-/** Harmonic function of each semitone offset above the tonic (major context). */
-const FUNCTION_BY_OFFSET: readonly HarmonicFunction[] = [
-  'tonic', // 0  I
-  'subdominant', // 1  bII (Neapolitan)
-  'subdominant', // 2  ii
-  'tonic', // 3  bIII
-  'tonic', // 4  iii
-  'subdominant', // 5  IV
-  'dominant', // 6  #IV / bV
-  'dominant', // 7  V
-  'subdominant', // 8  bVI
-  'tonic', // 9  vi
-  'subdominant', // 10 bVII
-  'dominant', // 11 vii
-];
-
-function mod12(n: number): number {
-  return ((n % 12) + 12) % 12;
-}
-
-/**
- * Whether a key's scale has a minor third and no major third (a minor key).
- *
- * @category Functional Harmony
- */
-export function isMinorKey(key: KeyScale): boolean {
-  const hasMinorThird = (key.modeMask12 >> 3) & 1;
-  const hasMajorThird = (key.modeMask12 >> 4) & 1;
-  return Boolean(hasMinorThird) && !hasMajorThird;
-}
-
-/** Diatonic pitch class of a 1-based scale degree in a key. */
-function degreeRootPc(degreeNumber: number, key: KeyScale): number {
-  const tones = scaleTonesInDegreeOrder(key);
-  if (tones.length === 0) {
-    return mod12(key.rootPc);
-  }
-  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);
-}
-
 /** Choose a seventh-chord quality from a triad label and the numeral case. */
 function seventhQuality(base: 'maj' | 'min' | 'dim' | 'aug', halfDim: boolean): ChordQuality {
   if (halfDim) {
@@ -222,11 +161,20 @@ function parseSimpleRoman(
     return { rootPc, quality: canonical, inversion: 0 };
   }
 
-  const isDim = /o|°|dim/.test(suffix);
-  const isAug = /\+|aug/.test(suffix);
-  const isHalfDim = /ø/.test(suffix);
-  const explicitMaj7 = /maj7|M7/.test(suffix);
-  const figures = suffix.replace(/maj7|M7/g, '').replace(/[^0-9]/g, '');
+  // Non-canonical spellings are limited to a complete quality marker followed
+  // by an optional major-seventh marker and a recognized figured bass. Never
+  // search substrings: `Vfoo` must not become diminished merely because it
+  // contains an "o", and unknown trailing text must be rejected in full.
+  const parsedSuffix = /^(o|°|dim|ø|\+|aug)?(maj7|M7)?(65|64|43|42|7|6|2)?$/.exec(suffix);
+  if (!parsedSuffix) {
+    throw new Error(`Unsupported suffix "${suffix}" in Roman numeral: ${text}`);
+  }
+  const qualityMarker = parsedSuffix[1] ?? '';
+  const isDim = qualityMarker === 'o' || qualityMarker === '°' || qualityMarker === 'dim';
+  const isAug = qualityMarker === '+' || qualityMarker === 'aug';
+  const isHalfDim = qualityMarker === 'ø';
+  const explicitMaj7 = parsedSuffix[2] !== undefined;
+  const figures = parsedSuffix[3] ?? '';
 
   // Reject figure strings that are neither a known figured-bass inversion nor a
   // canonical quality suffix rather than silently degrading to a root triad.
@@ -452,260 +400,3 @@ export function chordToRoman(chord: Chord, key: KeyScale): string {
   }
   return `${accidental}${cased}${suffix}`;
 }
-
-/**
- * The harmonic function of a chord in a key, from its root's offset above the
- * tonic. The mapping follows common-practice major-key function and is a useful
- * approximation in minor and for borrowed chords.
- *
- * @param chord The chord.
- * @param key The prevailing key.
- * @returns The harmonic function.
- * @category Functional Harmony
- */
-export function functionOf(chord: Chord, key: KeyScale): HarmonicFunction {
-  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? 'tonic';
-}
-
-/**
- * The origin of a recognized non-diatonic chord, or null when none applies.
- *
- * @category Functional Harmony
- */
-export type BorrowedSource = 'parallel-minor' | 'parallel-major' | 'neapolitan' | null;
-
-/**
- * The result of {@link analyzeChord}: function, borrowing, and Roman numeral.
- *
- * @category Functional Harmony
- */
-export type ChordAnalysis = {
-  function: HarmonicFunction;
-  borrowed: boolean;
-  source: BorrowedSource;
-  roman: string;
-};
-
-/**
- * Whether every pitch class of a chord belongs to the key's scale.
- *
- * The test is strict against the key's own mode mask: in a natural-minor key
- * the harmonic-minor dominant (major V) is *not* diatonic, since the raised
- * leading tone lies outside the mask. Borrowing predicates treat that case as
- * an in-key alteration separately (see {@link isBorrowedChord}).
- *
- * @param chord The chord to test.
- * @param key The prevailing key.
- * @returns True if all chord pitch classes are scale tones.
- * @category Functional Harmony
- */
-export function isDiatonic(chord: Chord, key: KeyScale): boolean {
-  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));
-}
-
-/**
- * The parallel key: same tonic, opposite mode.
- *
- * A key with a minor third (natural/harmonic/melodic minor, dorian, phrygian)
- * maps to the parallel major; any other key maps to the parallel natural minor.
- *
- * @param key The key to mirror.
- * @returns The parallel major or natural-minor key on the same tonic.
- * @category Functional Harmony
- */
-export function parallelKey(key: KeyScale): KeyScale {
-  return {
-    rootPc: mod12(key.rootPc),
-    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK,
-  };
-}
-
-/**
- * In a minor key, whether a non-diatonic chord is explained by the harmonic
- * minor scale on the same tonic (major V, V7, the raised-leading-tone viio).
- * Such chords are in-key chromatic alterations, not modal interchange.
- */
-function isHarmonicMinorAlteration(chord: Chord, key: KeyScale): boolean {
-  return (
-    isMinorKey(key) &&
-    isDiatonic(chord, { rootPc: mod12(key.rootPc), modeMask12: HARMONIC_MINOR_MASK })
-  );
-}
-
-/** Whether a chord is the Neapolitan: a major triad on the flat second degree. */
-function isNeapolitan(chord: Chord, key: KeyScale): boolean {
-  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === 'maj';
-}
-
-/**
- * Whether a chord is borrowed from the parallel mode (modal interchange).
- *
- * True when the chord is not diatonic to `key` but is diatonic to its
- * {@link parallelKey} — e.g. iv, bVI, or bVII in a major key, or the Picardy
- * tonic and major IV in a minor key. Two non-diatonic families are excluded:
- * chords diatonic to neither mode (they are chromatic, not borrowed), and, in
- * a minor key, chords explained by the harmonic minor scale (the major
- * dominant and raised-leading-tone chords), which are in-key alterations
- * rather than interchange even though they happen to fit the parallel major.
- *
- * @param chord The chord to test.
- * @param key The prevailing key.
- * @returns True if the chord is borrowed from the parallel mode.
- * @category Functional Harmony
- */
-export function isBorrowedChord(chord: Chord, key: KeyScale): boolean {
-  if (isDiatonic(chord, key)) {
-    return false;
-  }
-  if (isHarmonicMinorAlteration(chord, key)) {
-    return false;
-  }
-  return isDiatonic(chord, parallelKey(key));
-}
-
-/**
- * Identify where a non-diatonic chord comes from.
- *
- * The Neapolitan (major triad on b2) is recognized first, since it sits
- * outside both parallel modes; parallel-mode borrowing follows the
- * {@link isBorrowedChord} rules. Diatonic chords, harmonic-minor alterations,
- * and unrecognized chromatic chords all yield null.
- *
- * @param chord The chord to classify.
- * @param key The prevailing key.
- * @returns The borrowing source, or null.
- * @category Functional Harmony
- */
-export function borrowedSource(chord: Chord, key: KeyScale): BorrowedSource {
-  if (isDiatonic(chord, key)) {
-    return null;
-  }
-  if (isNeapolitan(chord, key)) {
-    return 'neapolitan';
-  }
-  if (isBorrowedChord(chord, key)) {
-    return isMinorKey(key) ? 'parallel-major' : 'parallel-minor';
-  }
-  return null;
-}
-
-/** Diminished-family qualities: diminished triad, dim7, half-diminished. */
-function isDiminishedQuality(quality: ChordQuality): boolean {
-  return quality === 'dim' || quality === 'dim7' || quality === 'm7b5';
-}
-
-/** Whether the chord's interval template carries a major third above the root. */
-function hasMajorThird(chord: Chord): boolean {
-  return chord.intervals.some((interval) => mod12(interval) === 4);
-}
-
-/**
- * Quality-aware harmonic function, refining the offset table where chord
- * quality disambiguates: diminished chords on the leading tone or the raised
- * subdominant resolve by semitone and act as dominants; the Neapolitan and the
- * major-third chords on bVI/bVII borrowed from the parallel minor act as
- * subdominant (predominant) harmony. All other chords keep {@link functionOf}.
- */
-function qualityAwareFunction(chord: Chord, key: KeyScale): HarmonicFunction {
-  const offset = mod12(chord.rootPc - key.rootPc);
-  if (isDiminishedQuality(chord.quality) && (offset === 11 || offset === 6)) {
-    return 'dominant';
-  }
-  if (isNeapolitan(chord, key)) {
-    return 'subdominant';
-  }
-  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {
-    return 'subdominant';
-  }
-  return functionOf(chord, key);
-}
-
-/**
- * Analyze a chord in a key: harmonic function, borrowing, and Roman numeral.
- *
- * The function is quality-aware (see the predicates behind it), the source
- * follows {@link borrowedSource}, and the numeral comes from
- * {@link chordToRoman}. `borrowed` is true whenever a source is identified —
- * including the Neapolitan, which the stricter parallel-mode predicate
- * {@link isBorrowedChord} does not count.
- *
- * @param chord The chord to analyze.
- * @param key The prevailing key.
- * @returns The chord analysis.
- * @example
- * ```ts
- * import { analyzeChord, makeChord, majorKey } from '@libraz/libcantus';
- * analyzeChord(makeChord(7, 'dom7'), majorKey(0));
- * // { function: 'dominant', borrowed: false, source: null, roman: 'V7' }
- * ```
- * @category Functional Harmony
- */
-export function analyzeChord(chord: Chord, key: KeyScale): ChordAnalysis {
-  const source = borrowedSource(chord, key);
-  return {
-    function: qualityAwareFunction(chord, key),
-    borrowed: source !== null,
-    source,
-    roman: chordToRoman(chord, key),
-  };
-}
-
-/**
- * Classify the cadence formed by moving from one chord to the next.
- *
- * - authentic: V (dominant a fifth above the tonic) to I
- * - plagal: IV (a fourth above the tonic) to I
- * - deceptive: V to the submediant (diatonic vi or borrowed bVI in major, VI in
- *   minor)
- * - half: any chord other than the dominant itself to V
- *
- * A static V-to-V repeat with no root motion is not a cadence and yields null.
- *
- * @param from The penultimate chord.
- * @param to The final chord.
- * @param key The prevailing key.
- * @returns The cadence type, or null.
- * @example
- * ```ts
- * import { detectCadence, makeChord, majorKey } from '@libraz/libcantus';
- * detectCadence(makeChord(7, 'maj'), makeChord(0, 'maj'), majorKey(0)); // => 'authentic'
- * ```
- * @category Functional Harmony
- */
-export function detectCadence(from: Chord, to: Chord, key: KeyScale): Cadence {
-  const tonic = mod12(key.rootPc);
-  const fromOffset = mod12(from.rootPc - tonic);
-  const toOffset = mod12(to.rootPc - tonic);
-  // Deceptive targets: the diatonic submediant (vi at offset 9 in major, VI at
-  // offset 8 in minor) plus, in a major key, the borrowed flat-submediant bVI
-  // at offset 8.
-  const deceptiveTargets = isMinorKey(key) ? [8] : [8, 9];
-  if (fromOffset === 7 && toOffset === 0) {
-    return 'authentic';
-  }
-  if (fromOffset === 5 && toOffset === 0) {
-    return 'plagal';
-  }
-  if (fromOffset === 7 && deceptiveTargets.includes(toOffset)) {
-    return 'deceptive';
-  }
-  // A move to the dominant is a half cadence, but a no-root-motion V-to-V repeat
-  // is not a cadence at all.
-  if (toOffset === 7 && fromOffset !== 7) {
-    return 'half';
-  }
-  return null;
-}
-
-/**
- * The secondary dominant (V7) that tonicizes a scale degree.
- *
- * @param targetDegree 0-based scale degree to tonicize.
- * @param key The prevailing key.
- * @returns A dominant-seventh chord a fifth above the target's root.
- * @category Functional Harmony
- */
-export function secondaryDominant(targetDegree: number, key: KeyScale): Chord {
-  const targetRoot = degreeRootPc(targetDegree + 1, key);
-  return makeChord(mod12(targetRoot + 7), 'dom7');
-}

package/src/analyze/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Public API of the analyze layer. Re-exports every analyze-layer module;
+ * also available from the package root.
+ */
+export type {
+  ArrangementAnalysis,
+  ArrangementOptions,
+  ArrangementTrack,
+  Conflict,
+  TensionPoint,
+  TrackAnalysis,
+  TrackRole,
+} from './arrange/index.js';
+export { analyzeArrangement, tensionCurve } from './arrange/index.js';
+export type { ChordMatch, DetectChordOptions, KeyMatch } from './detect/index.js';
+export { detectChord, detectChordBest, detectKey } from './detect/index.js';
+export type {
+  BorrowedSource,
+  Cadence,
+  ChordAnalysis,
+  HarmonicFunction,
+} from './functional/index.js';
+export {
+  analyzeChord,
+  borrowedSource,
+  chordToRoman,
+  detectCadence,
+  functionOf,
+  isBorrowedChord,
+  isDiatonic,
+  isMinorKey,
+  parallelKey,
+  romanToChord,
+  secondaryDominant,
+} from './functional/index.js';
+export type {
+  CadenceHit,
+  ChordSegment,
+  ChordTimeline,
+  ChordTimelineOptions,
+  ChordTimelineResult,
+} from './timeline/index.js';
+export {
+  chordTimelineFromChords,
+  chordTimelineFromNotes,
+  detectCadences,
+} from './timeline/index.js';
+export type { AnalyzedNote, TheoryLabel, VoiceNote } from './voice/index.js';
+export { analyzeVoice } from './voice/index.js';