@libraz/libcantus 0.9.2 → 0.9.4

package/dist/model/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/model/index.ts","../../src/theory/scale/degrees.ts","../../src/theory/scale/masks.ts","../../src/theory/scale/key.ts","../../src/theory/chord/index.ts","../../src/analyze/detect/index.ts","../../src/analyze/functional/internal.ts","../../src/analyze/functional/roman.ts","../../src/analyze/functional/function.ts","../../src/analyze/functional/borrowed.ts","../../src/analyze/functional/cadence.ts","../../src/generate/reharmony/index.ts","../../src/theory/chordscale/index.ts","../../src/core/pitch/index.ts","../../src/theory/spelling/index.ts","../../src/theory/symbol/index.ts","../../src/theory/counterpoint/index.ts","../../src/theory/voicing/internal.ts","../../src/theory/voicing/satb.ts","../../src/theory/voicing/leading.ts","../../src/theory/voicing/styled.ts","../../src/model/shared.ts","../../src/model/note.ts","../../src/model/progression.ts","../../src/model/chord.ts","../../src/model/interval.ts","../../src/model/key.ts"],"sourcesContent":["/**\n * Fluent, immutable object model over the functional core.\n *\n * Each class wraps one of the library's plain data types (spelled notes,\n * chords, key/scales) and delegates every operation to the existing pure\n * functions. All instances are immutable: fields are read-only, transforming\n * methods return new instances, and getters hand out defensive copies of any\n * mutable data.\n */\n\nexport { Chord } from './chord.js';\nexport { Interval } from './interval.js';\nexport { Key } from './key.js';\nexport { Note } from './note.js';\nexport { Progression } from './progression.js';\n","import type { KeyScale } from '../../core/types.js';\n\n/** Reduce a pitch (or pitch class) to a pitch class in [0, 11]. */\nfunction pitchClass(pitch: number): number {\n  return ((Math.trunc(pitch) % 12) + 12) % 12;\n}\n\n/** Scale offset of a pitch relative to the key root, in [0, 11]. */\nfunction scaleOffset(pitch: number, key: KeyScale): number {\n  return (pitchClass(pitch) - pitchClass(key.rootPc) + 12) % 12;\n}\n\n/**\n * Test whether a pitch belongs to the scale.\n *\n * @param pitch MIDI pitch or bare pitch class.\n * @param key The key/scale to test against.\n * @returns True if the pitch class is a member of the scale.\n *\n * @example\n * ```ts\n * import { majorKey, isScaleTone } from '@libraz/libcantus';\n * const key = majorKey(0); // C major\n * isScaleTone(64, key); // true — E is in C major\n * isScaleTone(61, key); // false — C# is not\n * ```\n *\n * @category Scales\n */\nexport function isScaleTone(pitch: number, key: KeyScale): boolean {\n  return ((key.modeMask12 >> scaleOffset(pitch, key)) & 1) === 1;\n}\n\n/**\n * Find the nearest MIDI pitch whose pitch class is in the scale.\n *\n * The search expands symmetrically outward from `pitch`. On a tie (equal\n * distance above and below) the lower pitch is returned.\n *\n * @param pitch MIDI pitch to snap.\n * @param key The key/scale to snap to.\n * @returns The nearest in-scale MIDI pitch.\n *\n * @category Scales\n */\nexport function nearestScaleTone(pitch: number, key: KeyScale): number {\n  const base = Math.round(pitch);\n  for (let distance = 0; distance < 12; distance += 1) {\n    const lower = base - distance;\n    if (isScaleTone(lower, key)) {\n      return lower;\n    }\n    const higher = base + distance;\n    if (isScaleTone(higher, key)) {\n      return higher;\n    }\n  }\n  return base;\n}\n\n/**\n * Get the 0-based scale degree of a pitch.\n *\n * @param pitch MIDI pitch or bare pitch class.\n * @param key The key/scale to measure against.\n * @returns The 0-based degree, or -1 if the pitch is not in the scale.\n *\n * @category Scales\n */\nexport function pitchToScaleDegree(pitch: number, key: KeyScale): number {\n  const offset = scaleOffset(pitch, key);\n  if (((key.modeMask12 >> offset) & 1) === 0) {\n    return -1;\n  }\n  let degree = 0;\n  for (let n = 0; n < offset; n += 1) {\n    if (((key.modeMask12 >> n) & 1) === 1) {\n      degree += 1;\n    }\n  }\n  return degree;\n}\n\n/**\n * List the pitch classes of a key's scale.\n *\n * @param key The key/scale to enumerate.\n * @returns The member pitch classes, sorted ascending in [0, 11].\n *\n * @category Scales\n */\nexport function diatonicPitchClasses(key: KeyScale): number[] {\n  const root = pitchClass(key.rootPc);\n  const pcs: number[] = [];\n  for (let n = 0; n < 12; n += 1) {\n    if (((key.modeMask12 >> n) & 1) === 1) {\n      pcs.push((root + n) % 12);\n    }\n  }\n  return pcs.sort((a, b) => a - b);\n}\n\n/**\n * List the pitch classes of a key's scale in ascending scale-degree order.\n *\n * Degree 0 is the root; degrees follow the mask bits in offset order rather\n * than sorted pitch-class order.\n *\n * @param key The key/scale to enumerate.\n * @returns The member pitch classes ordered by scale degree.\n *\n * @category Scales\n */\nexport function scaleTonesInDegreeOrder(key: KeyScale): number[] {\n  const root = pitchClass(key.rootPc);\n  const pcs: number[] = [];\n  for (let n = 0; n < 12; n += 1) {\n    if (((key.modeMask12 >> n) & 1) === 1) {\n      pcs.push((root + n) % 12);\n    }\n  }\n  return pcs;\n}\n","/**\n * Build a 12-bit mode mask from a list of semitone offsets above the root.\n *\n * Bit 0 (the root) is always set, enforcing the `KeyScale` invariant that the\n * root is a scale tone even when the offset list omits 0.\n *\n * @category Scales\n */\nexport function maskFromOffsets(offsets: readonly number[]): number {\n  let mask = 1;\n  for (const offset of offsets) {\n    mask |= 1 << (((offset % 12) + 12) % 12);\n  }\n  return mask;\n}\n\n/**\n * Mode mask for the major (Ionian) scale: offsets {0, 2, 4, 5, 7, 9, 11}.\n *\n * @category Scales\n */\nexport const MAJOR_MASK = 0b101010110101;\n\n/**\n * Mode mask for the natural minor (Aeolian) scale: offsets {0, 2, 3, 5, 7, 8, 10}.\n *\n * @category Scales\n */\nexport const NATURAL_MINOR_MASK = 0b010110101101;\n\n/**\n * Harmonic minor: natural minor with a raised seventh — offsets {0,2,3,5,7,8,11}.\n *\n * @category Scales\n */\nexport const HARMONIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 8, 11]);\n\n/**\n * Ascending melodic minor: offsets {0,2,3,5,7,9,11}.\n *\n * @category Scales\n */\nexport const MELODIC_MINOR_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 11]);\n\n/**\n * Dorian mode: offsets {0,2,3,5,7,9,10}.\n *\n * @category Scales\n */\nexport const DORIAN_MASK = maskFromOffsets([0, 2, 3, 5, 7, 9, 10]);\n\n/**\n * Phrygian mode: offsets {0,1,3,5,7,8,10}.\n *\n * @category Scales\n */\nexport const PHRYGIAN_MASK = maskFromOffsets([0, 1, 3, 5, 7, 8, 10]);\n\n/**\n * Lydian mode: offsets {0,2,4,6,7,9,11}.\n *\n * @category Scales\n */\nexport const LYDIAN_MASK = maskFromOffsets([0, 2, 4, 6, 7, 9, 11]);\n\n/**\n * Mixolydian mode: offsets {0,2,4,5,7,9,10}.\n *\n * @category Scales\n */\nexport const MIXOLYDIAN_MASK = maskFromOffsets([0, 2, 4, 5, 7, 9, 10]);\n\n/**\n * Locrian mode: offsets {0,1,3,5,6,8,10}.\n *\n * @category Scales\n */\nexport const LOCRIAN_MASK = maskFromOffsets([0, 1, 3, 5, 6, 8, 10]);\n\n/**\n * Major pentatonic: offsets {0,2,4,7,9}.\n *\n * @category Scales\n */\nexport const MAJOR_PENTATONIC_MASK = maskFromOffsets([0, 2, 4, 7, 9]);\n\n/**\n * Minor pentatonic: offsets {0,3,5,7,10}.\n *\n * @category Scales\n */\nexport const MINOR_PENTATONIC_MASK = maskFromOffsets([0, 3, 5, 7, 10]);\n\n/**\n * Hexatonic blues scale: minor pentatonic plus the flat-fifth — {0,3,5,6,7,10}.\n *\n * @category Scales\n */\nexport const BLUES_MASK = maskFromOffsets([0, 3, 5, 6, 7, 10]);\n\n/**\n * Whole-tone scale: offsets {0,2,4,6,8,10}.\n *\n * @category Scales\n */\nexport const WHOLE_TONE_MASK = maskFromOffsets([0, 2, 4, 6, 8, 10]);\n\n/**\n * Octatonic (half-step first): offsets {0,1,3,4,6,7,9,10}.\n *\n * @category Scales\n */\nexport const OCTATONIC_HALF_WHOLE_MASK = maskFromOffsets([0, 1, 3, 4, 6, 7, 9, 10]);\n\n/**\n * Octatonic (whole-step first): offsets {0,2,3,5,6,8,9,11}.\n *\n * @category Scales\n */\nexport const OCTATONIC_WHOLE_HALF_MASK = maskFromOffsets([0, 2, 3, 5, 6, 8, 9, 11]);\n\n/**\n * Chromatic scale: all twelve pitch classes.\n *\n * @category Scales\n */\nexport const CHROMATIC_MASK = 0b111111111111;\n\n/**\n * Named scale masks addressable by {@link scaleByName}.\n *\n * @category Scales\n */\nexport const NAMED_SCALES: Record<string, number> = {\n  major: MAJOR_MASK,\n  ionian: MAJOR_MASK,\n  naturalMinor: NATURAL_MINOR_MASK,\n  aeolian: NATURAL_MINOR_MASK,\n  harmonicMinor: HARMONIC_MINOR_MASK,\n  melodicMinor: MELODIC_MINOR_MASK,\n  dorian: DORIAN_MASK,\n  phrygian: PHRYGIAN_MASK,\n  lydian: LYDIAN_MASK,\n  mixolydian: MIXOLYDIAN_MASK,\n  locrian: LOCRIAN_MASK,\n  majorPentatonic: MAJOR_PENTATONIC_MASK,\n  minorPentatonic: MINOR_PENTATONIC_MASK,\n  blues: BLUES_MASK,\n  wholeTone: WHOLE_TONE_MASK,\n  octatonicHalfWhole: OCTATONIC_HALF_WHOLE_MASK,\n  octatonicWholeHalf: OCTATONIC_WHOLE_HALF_MASK,\n  chromatic: CHROMATIC_MASK,\n};\n","import type { KeyScale } from '../../core/types.js';\nimport { MAJOR_MASK, NAMED_SCALES, NATURAL_MINOR_MASK } from './masks.js';\n\n/**\n * Build a `KeyScale` for a major key on the given root pitch class.\n *\n * @example\n * ```ts\n * import { majorKey } from '@libraz/libcantus';\n * const cMajor = majorKey(0); // C major: { rootPc: 0, modeMask12: MAJOR_MASK }\n * ```\n *\n * @category Scales\n */\nexport function majorKey(rootPc: number): KeyScale {\n  return { rootPc: ((rootPc % 12) + 12) % 12, modeMask12: MAJOR_MASK };\n}\n\n/**\n * Build a `KeyScale` for a natural-minor key on the given root pitch class.\n *\n * @example\n * ```ts\n * import { minorKey } from '@libraz/libcantus';\n * const aMinor = minorKey(9); // A natural minor: { rootPc: 9, modeMask12: NATURAL_MINOR_MASK }\n * ```\n *\n * @category Scales\n */\nexport function minorKey(rootPc: number): KeyScale {\n  return { rootPc: ((rootPc % 12) + 12) % 12, modeMask12: NATURAL_MINOR_MASK };\n}\n\n/**\n * Build a `KeyScale` from a named scale (see {@link NAMED_SCALES}).\n *\n * @param name The scale name, e.g. `'dorian'` or `'harmonicMinor'`.\n * @param rootPc The root pitch class.\n * @returns The key/scale.\n * @throws If the name is not a known scale.\n *\n * @example\n * ```ts\n * import { scaleByName } from '@libraz/libcantus';\n * const dDorian = scaleByName('dorian', 2); // D Dorian, rootPc 2\n * ```\n *\n * @category Scales\n */\nexport function scaleByName(name: string, rootPc: number): KeyScale {\n  const mask = NAMED_SCALES[name];\n  if (mask === undefined) {\n    throw new Error(`Unknown scale: ${name}`);\n  }\n  return { rootPc: ((rootPc % 12) + 12) % 12, modeMask12: mask };\n}\n","import type { KeyScale } from '../../core/types.js';\nimport { scaleTonesInDegreeOrder } from '../scale/index.js';\n\n/**\n * Chord quality identifiers understood by the chord builder.\n *\n * @category Chords\n */\nexport type ChordQuality =\n  | 'maj'\n  | 'min'\n  | 'dim'\n  | 'aug'\n  | 'maj7'\n  | 'min7'\n  | 'dom7'\n  | 'dim7'\n  | 'm7b5'\n  | 'minMaj7'\n  | 'aug7'\n  | 'augMaj7'\n  | 'majb5'\n  | '6'\n  | 'min6'\n  | '6/9'\n  | 'sus2'\n  | 'sus4'\n  | 'add9'\n  | 'add11'\n  | 'maj9'\n  | 'min9'\n  | 'dom9'\n  | '7b9'\n  | '7#9'\n  | '7#11'\n  | '7b13'\n  | '11'\n  | '13'\n  | '5';\n\n/**\n * A bare spelled pitch used as an enharmonic hint: a diatonic letter\n * (0..6 = C..B) plus a chromatic alteration (-2 double-flat .. +2 double-sharp).\n * Mirrors the letter/alter half of the pitch module's `Note` without an octave.\n *\n * @category Chords\n */\nexport type PitchSpelling = {\n  letter: number;\n  alter: number;\n};\n\n/**\n * A chord expressed as a root pitch class plus semitone offsets.\n *\n * `rootSpelling`/`bassSpelling` are optional enharmonic hints recorded by\n * parsers (e.g. `parseChordSymbol('Bb7')`) so formatters can reproduce the\n * original spelling instead of defaulting to sharps. Consumers may ignore\n * them; a hint is only trusted when its pitch class still matches the\n * corresponding `rootPc`/`bassPc`.\n *\n * @category Chords\n */\nexport type Chord = {\n  rootPc: number;\n  quality: ChordQuality;\n  intervals: number[];\n  bassPc?: number;\n  rootSpelling?: PitchSpelling;\n  bassSpelling?: PitchSpelling;\n};\n\n/**\n * A chord positioned in time: a root pitch class and quality placed at a beat,\n * with optional harmonic-analysis hints. Serves as the neutral exchange record\n * between progression generators and timeline analysers.\n *\n * @category Composition\n */\nexport type ChordSpan = {\n  rootPc: number;\n  quality: ChordQuality;\n  startBeat: number;\n  bassPc?: number;\n  /** 0-based scale degree of the chord root, when known. */\n  degree?: number;\n  /** True when the chord is a secondary dominant tonicizing another degree. */\n  secondaryDominant?: boolean;\n};\n\n/** Semitone offsets from the root for each supported chord quality. */\nconst QUALITY_INTERVALS: Record<ChordQuality, number[]> = {\n  maj: [0, 4, 7],\n  min: [0, 3, 7],\n  dim: [0, 3, 6],\n  aug: [0, 4, 8],\n  majb5: [0, 4, 6],\n  maj7: [0, 4, 7, 11],\n  min7: [0, 3, 7, 10],\n  dom7: [0, 4, 7, 10],\n  dim7: [0, 3, 6, 9],\n  m7b5: [0, 3, 6, 10],\n  minMaj7: [0, 3, 7, 11],\n  aug7: [0, 4, 8, 10],\n  augMaj7: [0, 4, 8, 11],\n  '6': [0, 4, 7, 9],\n  min6: [0, 3, 7, 9],\n  '6/9': [0, 4, 7, 9, 14],\n  sus2: [0, 2, 7],\n  sus4: [0, 5, 7],\n  add9: [0, 4, 7, 14],\n  add11: [0, 4, 7, 17],\n  maj9: [0, 4, 7, 11, 14],\n  min9: [0, 3, 7, 10, 14],\n  dom9: [0, 4, 7, 10, 14],\n  '7b9': [0, 4, 7, 10, 13],\n  '7#9': [0, 4, 7, 10, 15],\n  '7#11': [0, 4, 7, 10, 18],\n  '7b13': [0, 4, 7, 10, 20],\n  '11': [0, 7, 10, 14, 17],\n  '13': [0, 4, 7, 10, 14, 21],\n  '5': [0, 7],\n};\n\n/** Reduce a value to a pitch class in [0, 11]. */\nfunction pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/**\n * All chord qualities the builder understands, longest templates last.\n *\n * @category Chords\n */\nexport function chordQualities(): ChordQuality[] {\n  return Object.keys(QUALITY_INTERVALS) as ChordQuality[];\n}\n\n/**\n * Build a chord rooted on a diatonic scale degree.\n *\n * The root pitch class is the degree's diatonic pitch class in `key`; the\n * quality's interval template is attached unchanged. Degrees beyond the scale\n * length wrap around.\n *\n * @param degree 0-based scale degree of the chord root.\n * @param ext Chord quality to apply.\n * @param key Key context supplying the diatonic root.\n * @returns The constructed chord.\n *\n * @category Chords\n */\nexport function chordFromDegree(degree: number, ext: ChordQuality, key: KeyScale): Chord {\n  const tones = scaleTonesInDegreeOrder(key);\n  const length = tones.length;\n  const index = length > 0 ? ((degree % length) + length) % length : 0;\n  const rootPc = tones[index] ?? pitchClass(key.rootPc);\n  return { rootPc, quality: ext, intervals: [...QUALITY_INTERVALS[ext]] };\n}\n\n/**\n * Build a chord from an explicit root pitch class and quality.\n *\n * @param rootPc Root pitch class (0..11).\n * @param quality Chord quality supplying the interval template.\n * @param bassPc Optional slash-chord bass pitch class.\n * @returns The constructed chord.\n *\n * @example\n * ```ts\n * import { makeChord } from '@libraz/libcantus';\n * const cmaj7 = makeChord(0, 'maj7');\n * // { rootPc: 0, quality: 'maj7', intervals: [0, 4, 7, 11] }\n * ```\n *\n * @category Chords\n */\nexport function makeChord(rootPc: number, quality: ChordQuality, bassPc?: number): Chord {\n  const chord: Chord = {\n    rootPc: pitchClass(rootPc),\n    quality,\n    intervals: [...QUALITY_INTERVALS[quality]],\n  };\n  if (bassPc !== undefined) {\n    chord.bassPc = pitchClass(bassPc);\n  }\n  return chord;\n}\n\n/**\n * Get the sorted, deduplicated pitch classes of a chord.\n *\n * @param chord The chord to enumerate.\n * @returns The chord's pitch classes, sorted ascending in [0, 11].\n *\n * @example\n * ```ts\n * import { makeChord, chordPitchClasses } from '@libraz/libcantus';\n * chordPitchClasses(makeChord(0, 'maj7')); // [0, 4, 7, 11]\n * ```\n *\n * @category Chords\n */\nexport function chordPitchClasses(chord: Chord): number[] {\n  const set = new Set<number>();\n  for (const interval of chord.intervals) {\n    set.add(pitchClass(chord.rootPc + interval));\n  }\n  return [...set].sort((a, b) => a - b);\n}\n\n/** The chord-tone offsets present in a chord, reduced to pitch-class space. */\nfunction chordToneOffsets(chord: Chord): Set<number> {\n  return new Set(chord.intervals.map((i) => ((i % 12) + 12) % 12));\n}\n\n/**\n * Determine a pitch's harmonic role within a chord.\n *\n * The role is derived from the pitch's interval above the chord root, reduced\n * modulo 12. A major sixth (9) reads as a `sixth` for sixth chords but as a\n * `seventh` for a diminished-seventh chord; ninths and other tensions have no\n * basic role and return null.\n *\n * @param pitch MIDI pitch or bare pitch class.\n * @param chord The chord providing the root reference.\n * @returns The chord-tone role, or null if the pitch has no basic role.\n *\n * @category Chords\n */\nexport function chordToneRole(\n  pitch: number,\n  chord: Chord,\n): 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' | null {\n  const interval = (pitchClass(pitch) - pitchClass(chord.rootPc) + 12) % 12;\n  const tones = chordToneOffsets(chord);\n  if (interval === 0) {\n    return 'root';\n  }\n  if (interval === 3 || interval === 4) {\n    return tones.has(interval) ? 'third' : null;\n  }\n  if (interval === 7) {\n    return tones.has(7) ? 'fifth' : null;\n  }\n  if (interval === 6) {\n    // A diminished fifth is the chord's fifth only when no perfect fifth is\n    // present; alongside a perfect fifth it is a #11 tension, not a fifth.\n    return tones.has(6) && !tones.has(7) ? 'fifth' : null;\n  }\n  if (interval === 8) {\n    // An augmented fifth is the chord's fifth only without a perfect fifth;\n    // alongside a perfect fifth it is a b13 tension, not a fifth.\n    return tones.has(8) && !tones.has(7) ? 'fifth' : null;\n  }\n  if (interval === 9) {\n    const hasHigherSeventh = tones.has(10) || tones.has(11);\n    const isDiminishedSeventh = tones.has(3) && tones.has(6) && !hasHigherSeventh;\n    if (isDiminishedSeventh) {\n      return 'seventh';\n    }\n    if (tones.has(9) && !hasHigherSeventh) {\n      return 'sixth';\n    }\n    return null;\n  }\n  if (interval === 10 || interval === 11) {\n    return tones.has(interval) ? 'seventh' : null;\n  }\n  return null;\n}\n\n/** Classify a stacked-thirds triad into a chord quality from its interval set. */\nfunction classifyTriad(thirdIc: number, fifthIc: number): ChordQuality {\n  if (thirdIc === 4 && fifthIc === 8) {\n    return 'aug';\n  }\n  if (thirdIc === 4 && fifthIc === 6) {\n    return 'majb5';\n  }\n  if (thirdIc === 3 && fifthIc === 6) {\n    return 'dim';\n  }\n  if (thirdIc === 3) {\n    return 'min';\n  }\n  return 'maj';\n}\n\n/** Classify a stacked-thirds seventh chord into a chord quality. */\nfunction classifySeventh(thirdIc: number, fifthIc: number, seventhIc: number): ChordQuality {\n  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 9) {\n    return 'dim7';\n  }\n  if (thirdIc === 3 && fifthIc === 6 && seventhIc === 10) {\n    return 'm7b5';\n  }\n  if (thirdIc === 3 && seventhIc === 11) {\n    return 'minMaj7';\n  }\n  if (thirdIc === 3) {\n    return 'min7';\n  }\n  if (fifthIc === 8 && seventhIc === 10) {\n    return 'aug7';\n  }\n  if (fifthIc === 8 && seventhIc === 11) {\n    return 'augMaj7';\n  }\n  if (seventhIc === 11) {\n    return 'maj7';\n  }\n  return 'dom7';\n}\n\n/** Stack scale thirds from a scale degree into a chord of `size` notes. */\nfunction stackThirds(degree: number, key: KeyScale, size: 3 | 4): Chord {\n  const tones = scaleTonesInDegreeOrder(key);\n  const length = tones.length;\n  if (length === 0) {\n    return { rootPc: pitchClass(key.rootPc), quality: 'maj', intervals: [0, 4, 7] };\n  }\n  const idx = (step: number) => (((degree + step) % length) + length) % length;\n  const rootPc = tones[idx(0)] ?? pitchClass(key.rootPc);\n  const offsets = [0, 2, 4, 6].slice(0, size).map((step) => {\n    const pc = tones[idx(step)] ?? rootPc;\n    return (((pc - rootPc) % 12) + 12) % 12;\n  });\n  const thirdIc = offsets[1] ?? 4;\n  const fifthIc = offsets[2] ?? 7;\n  const quality =\n    size === 3\n      ? classifyTriad(thirdIc, fifthIc)\n      : classifySeventh(thirdIc, fifthIc, offsets[3] ?? 11);\n  return { rootPc, quality, intervals: offsets };\n}\n\n/**\n * Build the diatonic triad rooted on a scale degree by stacking scale thirds.\n *\n * Unlike {@link chordFromDegree}, the chord quality is derived from the scale\n * rather than supplied, so degrees yield their scale-correct triads (e.g. a\n * diminished triad on the leading tone of a major key). Intended for heptatonic\n * scales; other scales stack by scale step regardless.\n *\n * @param degree 0-based scale degree of the chord root.\n * @param key Key/scale context.\n * @returns The diatonic triad.\n *\n * @example\n * ```ts\n * import { majorKey, diatonicTriad } from '@libraz/libcantus';\n * const tonic = diatonicTriad(0, majorKey(0)); // C major triad (degree 0 of C major)\n * ```\n *\n * @category Chords\n */\nexport function diatonicTriad(degree: number, key: KeyScale): Chord {\n  return stackThirds(degree, key, 3);\n}\n\n/**\n * Build the diatonic seventh chord rooted on a scale degree.\n *\n * @param degree 0-based scale degree of the chord root.\n * @param key Key/scale context.\n * @returns The diatonic seventh chord.\n *\n * @category Chords\n */\nexport function diatonicSeventh(degree: number, key: KeyScale): Chord {\n  return stackThirds(degree, key, 4);\n}\n","/**\n * Recognition: infer a chord name from a set of pitches, or a key from a set of\n * pitch classes. This is the inverse direction of the chord/scale builders,\n * which only go name -> notes.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord, ChordQuality } from '../../theory/chord/index.js';\nimport { chordPitchClasses, chordQualities, makeChord } from '../../theory/chord/index.js';\nimport {\n  HARMONIC_MINOR_MASK,\n  MAJOR_MASK,\n  MELODIC_MINOR_MASK,\n  majorKey,\n  minorKey,\n  NATURAL_MINOR_MASK,\n} from '../../theory/scale/index.js';\n\n/**\n * A candidate chord interpretation of a pitch set.\n *\n * @category Recognition\n */\nexport type ChordMatch = {\n  rootPc: number;\n  quality: ChordQuality;\n  /** Chord tones absent from the input (an incomplete voicing). */\n  missingPcs: number[];\n  /** Input pitch classes not belonging to the chord. */\n  extraPcs: number[];\n  /** True when the input pitch-class set equals the chord exactly. */\n  exact: boolean;\n  /** Inversion implied by the lowest note: 0 root position, 1 first, ... */\n  inversion: number;\n  /** Bass pitch class when inverted (the lowest note is not the root). */\n  bassPc?: number;\n};\n\n/**\n * A candidate key interpretation of a pitch-class set.\n *\n * @category Recognition\n */\nexport type KeyMatch = {\n  key: KeyScale;\n  mode: 'major' | 'minor';\n  /** Fraction of input pitch classes that are in the scale, in [0, 1]. */\n  fit: number;\n};\n\n/** Reduce any integer to a pitch class in [0, 11]. */\nfunction pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/** Unique pitch classes of the input, sorted ascending. */\nfunction uniquePitchClasses(pitches: number[]): number[] {\n  return [...new Set(pitches.map(pitchClass))].sort((a, b) => a - b);\n}\n\n/**\n * Identify chords matching a set of pitches.\n *\n * Every input pitch class is tried as a root against every known chord quality.\n * A match is reported when all of the chord's tones are present in the input, or\n * when the only absent tone is the perfect fifth (a common omission in shell\n * voicings); matches are ranked best-first by fewest extra notes, then fewest\n * missing notes, then most specific (largest) chord. An exact match (no extras,\n * no missing) is flagged and ranked first.\n *\n * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).\n * @returns Ranked chord interpretations (may be empty).\n * @example\n * ```ts\n * import { detectChord } from '@libraz/libcantus';\n * const matches = detectChord([60, 64, 67]); // C E G\n * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }\n * ```\n * @category Recognition\n */\nexport function detectChord(pitches: number[]): ChordMatch[] {\n  const input = uniquePitchClasses(pitches);\n  if (input.length === 0) {\n    return [];\n  }\n  const bassPc = pitchClass(Math.min(...pitches));\n  const inputSet = new Set(input);\n  const matches: ChordMatch[] = [];\n  const qualities = chordQualities();\n  for (const rootPc of input) {\n    for (const quality of qualities) {\n      const chord = makeChord(rootPc, quality);\n      const tones = chordPitchClasses(chord);\n      const toneSet = new Set(tones);\n      const missingPcs = tones.filter((pc) => !inputSet.has(pc));\n      // Accept an exact-tone match, or one whose only absent tone is the perfect\n      // fifth; any other missing tone (third, sus tone, seventh, ...) rejects.\n      const fifthPc = pitchClass(rootPc + 7);\n      if (missingPcs.length > 1 || (missingPcs.length === 1 && missingPcs[0] !== fifthPc)) {\n        continue;\n      }\n      const extraPcs = input.filter((pc) => !toneSet.has(pc));\n      const bassIndex = chord.intervals.findIndex((iv) => pitchClass(rootPc + iv) === bassPc);\n      const inversion = bassIndex > 0 ? bassIndex : 0;\n      const match: ChordMatch = {\n        rootPc,\n        quality,\n        missingPcs,\n        extraPcs,\n        exact: extraPcs.length === 0 && missingPcs.length === 0,\n        inversion,\n      };\n      if (inversion > 0) {\n        match.bassPc = bassPc;\n      }\n      matches.push(match);\n    }\n  }\n  matches.sort((a, b) => {\n    if (a.extraPcs.length !== b.extraPcs.length) {\n      return a.extraPcs.length - b.extraPcs.length;\n    }\n    if (a.missingPcs.length !== b.missingPcs.length) {\n      return a.missingPcs.length - b.missingPcs.length;\n    }\n    // Prefer root position (the bass is the chord root) on a tie.\n    if ((a.inversion === 0) !== (b.inversion === 0)) {\n      return a.inversion === 0 ? -1 : 1;\n    }\n    const aSize = chordPitchClasses(makeChord(a.rootPc, a.quality)).length;\n    const bSize = chordPitchClasses(makeChord(b.rootPc, b.quality)).length;\n    return bSize - aSize;\n  });\n  return matches;\n}\n\n/**\n * The single best chord interpretation of a pitch set, or null if none.\n *\n * @param pitches MIDI pitches or bare pitch classes.\n * @returns The top-ranked chord, or null when nothing matches.\n * @example\n * ```ts\n * import { detectChordBest } from '@libraz/libcantus';\n * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }\n * ```\n * @category Recognition\n */\nexport function detectChordBest(pitches: number[]): Chord | null {\n  const best = detectChord(pitches)[0];\n  if (!best) {\n    return null;\n  }\n  return makeChord(best.rootPc, best.quality, best.bassPc);\n}\n\n/**\n * Minor-scale variants scored for each minor-key candidate. Scoring against all\n * three lets the raised sixth and seventh (e.g. the leading tone G# in A minor)\n * count toward their own tonic instead of only penalizing it.\n */\nconst MINOR_MASK_VARIANTS = [NATURAL_MINOR_MASK, HARMONIC_MINOR_MASK, MELODIC_MINOR_MASK];\n\n/**\n * Rank major and minor keys by how well they contain a set of pitch classes.\n *\n * The tonic is weighted so that, among equally-fitting keys, the one whose root\n * appears in the input is preferred. Minor candidates are scored against the\n * natural, harmonic, and melodic minor variants and keep the best of the three,\n * so a minor cadence containing the leading tone still resolves to its own\n * tonic; the returned key is always the natural-minor scale. Returns all 24\n * keys ranked best-first, or an empty array for an empty input (mirroring\n * {@link detectChord}).\n *\n * @param pitches MIDI pitches or bare pitch classes.\n * @returns Ranked key interpretations (empty for an empty input).\n * @example\n * ```ts\n * import { detectKey } from '@libraz/libcantus';\n * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale\n * keys[0].mode; // 'major', with keys[0].key.rootPc === 0\n * ```\n * @category Recognition\n */\nexport function detectKey(pitches: number[]): KeyMatch[] {\n  const input = uniquePitchClasses(pitches);\n  if (input.length === 0) {\n    return [];\n  }\n  const counts = new Map<number, number>();\n  for (const pc of pitches.map(pitchClass)) {\n    counts.set(pc, (counts.get(pc) ?? 0) + 1);\n  }\n  const total = pitches.length;\n  const results: (KeyMatch & { score: number })[] = [];\n  for (let tonic = 0; tonic < 12; tonic += 1) {\n    for (const mode of ['major', 'minor'] as const) {\n      const key = mode === 'major' ? majorKey(tonic) : minorKey(tonic);\n      const masks = mode === 'major' ? [MAJOR_MASK] : MINOR_MASK_VARIANTS;\n      // Score each scale variant and keep the best; ties keep the earlier\n      // (more diatonic) variant.\n      let inScale = 0;\n      let weighted = Number.NEGATIVE_INFINITY;\n      for (const mask of masks) {\n        let variantInScale = 0;\n        let variantWeighted = 0;\n        for (const pc of input) {\n          const offset = (pc - tonic + 12) % 12;\n          if ((mask >> offset) & 1) {\n            variantInScale += 1;\n          }\n        }\n        for (const [pc, count] of counts) {\n          const offset = (pc - tonic + 12) % 12;\n          if ((mask >> offset) & 1) {\n            variantWeighted += count;\n          }\n        }\n        if (variantWeighted > weighted) {\n          weighted = variantWeighted;\n          inScale = variantInScale;\n        }\n      }\n      weighted += (counts.get(tonic) ?? 0) * 0.5;\n      results.push({\n        key,\n        mode,\n        fit: inScale / input.length,\n        score: weighted / total,\n      });\n    }\n  }\n  results.sort((a, b) => b.score - a.score);\n  return results.map(({ key, mode, fit }) => ({ key, mode, fit }));\n}\n","/**\n * Shared helpers for the functional-harmony modules.\n *\n * Roots are pitch classes measured against the key tonic, so borrowed and\n * chromatic chords are handled by their semitone offset rather than requiring a\n * spelled key signature.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord } from '../../theory/chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\n\nexport function mod12(n: number): number {\n  return ((n % 12) + 12) % 12;\n}\n\n/** Diatonic pitch class of a 1-based scale degree in a key. */\nexport function degreeRootPc(degreeNumber: number, key: KeyScale): number {\n  const tones = scaleTonesInDegreeOrder(key);\n  if (tones.length === 0) {\n    return mod12(key.rootPc);\n  }\n  return tones[(degreeNumber - 1) % tones.length] ?? mod12(key.rootPc);\n}\n\n/** Whether a chord is the Neapolitan: a major triad on the flat second degree. */\nexport function isNeapolitan(chord: Chord, key: KeyScale): boolean {\n  return mod12(chord.rootPc - key.rootPc) === 1 && chord.quality === 'maj';\n}\n","/**\n * Roman-numeral parsing and formatting.\n *\n * The {@link ROMAN_STYLE} table is the single source of truth for both\n * directions, so {@link chordToRoman} and {@link romanToChord} stay mutual\n * inverses by construction.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord, ChordQuality } from '../../theory/chord/index.js';\nimport { makeChord } from '../../theory/chord/index.js';\nimport { majorKey, scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\nimport { degreeRootPc, mod12 } from './internal.js';\n\n/** Roman numeral glyphs indexed by degree number - 1. */\nconst ROMAN = ['I', 'II', 'III', 'IV', 'V', 'VI', 'VII'] as const;\n\n/** Roman glyph -> degree number (1..7). */\nconst ROMAN_TO_DEGREE: Record<string, number> = {\n  I: 1,\n  II: 2,\n  III: 3,\n  IV: 4,\n  V: 5,\n  VI: 6,\n  VII: 7,\n};\n\n/** Major-key Roman spelling for each semitone offset above the tonic. */\nconst OFFSET_SPELLING: readonly [number, string][] = [\n  [1, ''],\n  [2, 'b'],\n  [2, ''],\n  [3, 'b'],\n  [3, ''],\n  [4, ''],\n  [4, '#'],\n  [5, ''],\n  [6, 'b'],\n  [6, ''],\n  [7, 'b'],\n  [7, ''],\n];\n\n/** Choose a seventh-chord quality from a triad label and the numeral case. */\nfunction seventhQuality(base: 'maj' | 'min' | 'dim' | 'aug', halfDim: boolean): ChordQuality {\n  if (halfDim) {\n    return 'm7b5';\n  }\n  if (base === 'dim') {\n    return 'dim7';\n  }\n  if (base === 'aug') {\n    return 'aug7';\n  }\n  return base === 'maj' ? 'dom7' : 'min7';\n}\n\n/** Figure strings that denote a recognized figured-bass inversion. */\nconst INVERSION_FIGURES = new Set(['6', '64', '65', '43', '42', '2', '7']);\n\n/**\n * Canonical Roman-numeral rendering (numeral case and quality suffix) for every\n * supported chord quality. The table is the single source of truth for both\n * directions: {@link chordToRoman} renders from it and {@link romanToChord}\n * recognizes its exact case-sensitive suffixes, so the two stay mutual\n * inverses by construction. Suffixes are chosen to never collide with\n * figured-bass inversion digits (`6`, `64`, `65`, `43`, `42`, `2`) — the added\n * sixth is `add6`, the six-nine chord is `69` — and each (case, suffix) pair is\n * unique.\n */\nconst ROMAN_STYLE: Record<ChordQuality, { lower: boolean; suffix: string }> = {\n  maj: { lower: false, suffix: '' },\n  min: { lower: true, suffix: '' },\n  dim: { lower: true, suffix: 'o' },\n  aug: { lower: false, suffix: '+' },\n  maj7: { lower: false, suffix: 'maj7' },\n  min7: { lower: true, suffix: '7' },\n  dom7: { lower: false, suffix: '7' },\n  dim7: { lower: true, suffix: 'o7' },\n  m7b5: { lower: true, suffix: 'ø7' },\n  minMaj7: { lower: true, suffix: 'maj7' },\n  aug7: { lower: false, suffix: '+7' },\n  augMaj7: { lower: false, suffix: '+maj7' },\n  majb5: { lower: false, suffix: 'b5' },\n  '6': { lower: false, suffix: 'add6' },\n  min6: { lower: true, suffix: 'add6' },\n  '6/9': { lower: false, suffix: '69' },\n  sus2: { lower: false, suffix: 'sus2' },\n  sus4: { lower: false, suffix: 'sus4' },\n  add9: { lower: false, suffix: 'add9' },\n  add11: { lower: false, suffix: 'add11' },\n  maj9: { lower: false, suffix: 'maj9' },\n  min9: { lower: true, suffix: '9' },\n  dom9: { lower: false, suffix: '9' },\n  '7b9': { lower: false, suffix: '7b9' },\n  '7#9': { lower: false, suffix: '7#9' },\n  '7#11': { lower: false, suffix: '7#11' },\n  '7b13': { lower: false, suffix: '7b13' },\n  '11': { lower: false, suffix: '11' },\n  '13': { lower: false, suffix: '13' },\n  '5': { lower: false, suffix: '5' },\n};\n\n/** Reverse lookup of {@link ROMAN_STYLE}: `(case, exact suffix) -> quality`. */\nconst SUFFIX_QUALITY: ReadonlyMap<string, ChordQuality> = new Map(\n  (Object.entries(ROMAN_STYLE) as [ChordQuality, { lower: boolean; suffix: string }][]).map(\n    ([quality, style]) => [`${style.lower ? 'l' : 'u'}:${style.suffix}`, quality],\n  ),\n);\n\n/** Read figured-bass digits into a chord inversion and whether a seventh is implied. */\nfunction parseInversion(figures: string): { inversion: number; seventh: boolean } {\n  if (figures === '65') {\n    return { inversion: 1, seventh: true };\n  }\n  if (figures === '43') {\n    return { inversion: 2, seventh: true };\n  }\n  if (figures === '42' || figures === '2') {\n    return { inversion: 3, seventh: true };\n  }\n  if (figures === '7') {\n    return { inversion: 0, seventh: true };\n  }\n  if (figures === '64') {\n    return { inversion: 2, seventh: false };\n  }\n  if (figures === '6') {\n    return { inversion: 1, seventh: false };\n  }\n  return { inversion: 0, seventh: false };\n}\n\n/** Parse a Roman numeral (no secondary '/') into a root, quality, and inversion. */\nfunction parseSimpleRoman(\n  text: string,\n  key: KeyScale,\n): { rootPc: number; quality: ChordQuality; inversion: number } {\n  const match = /^([b#]?)([iIvV]+)(.*)$/.exec(text.trim());\n  if (!match) {\n    throw new Error(`Invalid Roman numeral: ${text}`);\n  }\n  const accidental = match[1] === 'b' ? -1 : match[1] === '#' ? 1 : 0;\n  const glyph = (match[2] ?? '').toUpperCase();\n  const degreeNumber = ROMAN_TO_DEGREE[glyph];\n  if (degreeNumber === undefined) {\n    throw new Error(`Invalid Roman numeral: ${text}`);\n  }\n  const isUpper = (match[2] ?? '')[0] === (match[2] ?? '')[0]?.toUpperCase();\n  const suffix = match[3] ?? '';\n  const rootPc = mod12(degreeRootPc(degreeNumber, key) + accidental);\n\n  // Canonical quality suffixes (exact match, case-sensitive on the numeral)\n  // come first so every chordToRoman rendering re-parses to the same quality:\n  // `V9` -> dom9 but `ii9` -> min9 and `Imaj9` -> maj9, and added-tone suffixes\n  // whose digits would otherwise be misread as figured bass (`Iadd6`, `I69`,\n  // `Isus2`, `Iadd11`) resolve to their qualities in root position.\n  const canonical = SUFFIX_QUALITY.get(`${isUpper ? 'u' : 'l'}:${suffix}`);\n  if (canonical !== undefined) {\n    return { rootPc, quality: canonical, inversion: 0 };\n  }\n\n  const isDim = /o|°|dim/.test(suffix);\n  const isAug = /\\+|aug/.test(suffix);\n  const isHalfDim = /ø/.test(suffix);\n  const explicitMaj7 = /maj7|M7/.test(suffix);\n  const figures = suffix.replace(/maj7|M7/g, '').replace(/[^0-9]/g, '');\n\n  // Reject figure strings that are neither a known figured-bass inversion nor a\n  // canonical quality suffix rather than silently degrading to a root triad.\n  if (figures !== '' && !INVERSION_FIGURES.has(figures)) {\n    throw new Error(`Unsupported figured-bass or extension \"${figures}\" in Roman numeral: ${text}`);\n  }\n\n  const { inversion, seventh } = parseInversion(figures);\n  // The ø glyph is the half-diminished seventh by definition (there is no\n  // half-diminished triad), so it always implies a seventh.\n  const hasSeventh = explicitMaj7 || seventh || isHalfDim;\n\n  let base: 'maj' | 'min' | 'dim' | 'aug';\n  if (isDim || isHalfDim) {\n    base = 'dim';\n  } else if (isAug) {\n    base = 'aug';\n  } else {\n    base = isUpper ? 'maj' : 'min';\n  }\n\n  let quality: ChordQuality;\n  if (explicitMaj7) {\n    quality = base === 'min' ? 'minMaj7' : base === 'aug' ? 'augMaj7' : 'maj7';\n  } else if (hasSeventh) {\n    quality = seventhQuality(base, isHalfDim);\n  } else if (base === 'dim') {\n    quality = 'dim';\n  } else if (base === 'aug') {\n    quality = 'aug';\n  } else {\n    quality = base;\n  }\n  return { rootPc, quality, inversion };\n}\n\n/** Build a chord from a parsed Roman numeral, attaching a bass for inversions. */\nfunction chordFromParsed(parsed: {\n  rootPc: number;\n  quality: ChordQuality;\n  inversion: number;\n}): Chord {\n  const chord = makeChord(parsed.rootPc, parsed.quality);\n  if (parsed.inversion > 0 && parsed.inversion < chord.intervals.length) {\n    chord.bassPc = mod12(parsed.rootPc + (chord.intervals[parsed.inversion] ?? 0));\n  }\n  return chord;\n}\n\n/**\n * Build the chord denoted by a Roman numeral in a key.\n *\n * Supports accidentals (`bVII`, `#iv`), case-based triad quality, the `o`/`ø`/`+`\n * suffixes, sevenths (`V7`, `viio7`, `Imaj7`), figured-bass inversions\n * (`V6`, `V64`, `V65`, `V43`, `V42`), and applied/secondary chords via a slash\n * (`V7/V`, `viio/ii`). The target after the slash is read as a scale degree\n * whose root becomes a local major tonic for the applied chord. Inverted chords\n * carry a `bassPc`.\n *\n * The `ø` glyph always denotes the half-diminished seventh (`iiø` == `iiø7` ==\n * `m7b5`), since no half-diminished triad exists. Extension and added-tone\n * suffixes are the canonical case-sensitive forms emitted by\n * {@link chordToRoman} and honor the numeral case: `V9` -> `dom9`, `ii9` ->\n * `min9`, `Imaj9` -> `maj9`, `V11` -> `11`, `V13` -> `13`, `Iadd6`/`iadd6` ->\n * `6`/`min6`, `I69` -> `6/9`, `Isus2`/`Isus4`, `Iadd9`/`Iadd11`, `Ib5` ->\n * `majb5`, `I5` -> `5`, and the altered dominants `V7b9`/`V7#9`/`V7#11`/`V7b13`.\n * A figure string that is neither a recognized inversion nor a supported\n * quality suffix throws rather than silently degrading to a triad.\n *\n * @param text The Roman numeral.\n * @param key The prevailing key.\n * @returns The chord.\n * @example\n * ```ts\n * import { romanToChord, majorKey } from '@libraz/libcantus';\n * romanToChord('V7', majorKey(0)); // G7 in C major: { rootPc: 7, quality: 'dom7', ... }\n * ```\n * @category Functional Harmony\n */\nexport function romanToChord(text: string, key: KeyScale): Chord {\n  const trimmed = text.trim();\n  const slash = trimmed.indexOf('/');\n  if (slash >= 0) {\n    const applied = trimmed.slice(0, slash);\n    const target = trimmed.slice(slash + 1);\n    const targetRoot = parseSimpleRoman(target, key).rootPc;\n    const localKey = majorKey(targetRoot);\n    return chordFromParsed(parseSimpleRoman(applied, localKey));\n  }\n  return chordFromParsed(parseSimpleRoman(trimmed, key));\n}\n\n/** Case and suffix for rendering a chord quality as a Roman numeral. */\nfunction romanStyle(quality: ChordQuality): { lower: boolean; suffix: string } {\n  return ROMAN_STYLE[quality];\n}\n\n/** Choose the degree number and accidental to spell a root as a Roman numeral. */\nfunction romanSpelling(\n  rootPc: number,\n  key: KeyScale,\n): { degreeNumber: number; accidental: string } {\n  const tones = scaleTonesInDegreeOrder(key);\n  const diatonic = tones.indexOf(mod12(rootPc));\n  if (diatonic >= 0) {\n    return { degreeNumber: diatonic + 1, accidental: '' };\n  }\n  // Chromatic root: prefer a flat of the diatonic degree a semitone above it,\n  // then a sharp of the degree a semitone below. Degree 1 (the tonic) and\n  // degree 5 (the dominant) are skipped in the flat pass, so a raised leading\n  // tone spells as `#vii` rather than a flat tonic `bI`, and the tritone above\n  // the tonic spells as `#iv` rather than a flat fifth `bV` (matching the\n  // conventional `OFFSET_SPELLING` for offset 6).\n  for (let i = 0; i < tones.length; i += 1) {\n    const degreeNumber = i + 1;\n    if (degreeNumber === 1 || degreeNumber === 5) {\n      continue;\n    }\n    if (mod12((tones[i] ?? 0) - 1) === mod12(rootPc)) {\n      return { degreeNumber, accidental: 'b' };\n    }\n  }\n  for (let i = 0; i < tones.length; i += 1) {\n    if (mod12((tones[i] ?? 0) + 1) === mod12(rootPc)) {\n      return { degreeNumber: i + 1, accidental: '#' };\n    }\n  }\n  const [degreeNumber, accidental] = OFFSET_SPELLING[mod12(rootPc - key.rootPc)] ?? [1, ''];\n  return { degreeNumber, accidental };\n}\n\n/** Quality marker (without the seventh digit) used when a figure carries the 7. */\nfunction baseMarker(quality: ChordQuality): string {\n  if (quality === 'dim' || quality === 'dim7') {\n    return 'o';\n  }\n  if (quality === 'm7b5') {\n    return 'ø';\n  }\n  if (quality === 'aug' || quality === 'aug7') {\n    return '+';\n  }\n  if (quality === 'augMaj7') {\n    return '+maj7';\n  }\n  if (quality === 'maj7' || quality === 'minMaj7') {\n    return 'maj7';\n  }\n  return '';\n}\n\nconst TRIAD_FIGURES: Record<number, string> = { 1: '6', 2: '64' };\nconst SEVENTH_FIGURES: Record<number, string> = { 1: '65', 2: '43', 3: '42' };\n\n/** Qualities whose inversions render as lossless triad figures (6, 64). */\nconst TRIAD_FIGURE_QUALITIES: ReadonlySet<ChordQuality> = new Set(['maj', 'min', 'dim', 'aug']);\n\n/**\n * Qualities carrying a chordal seventh, whose inversions render as seventh\n * figures (65, 43, 42). Membership is decided by the quality itself — a 7th\n * above the root (10 or 11 semitones, or the diminished 7th of `dim7`) — never\n * by interval count, which would turn added-tone chords into false sevenths.\n */\nconst SEVENTH_FIGURE_QUALITIES: ReadonlySet<ChordQuality> = new Set([\n  'maj7',\n  'min7',\n  'dom7',\n  'dim7',\n  'm7b5',\n  'minMaj7',\n  'aug7',\n  'augMaj7',\n]);\n\n/**\n * Render a chord as a Roman numeral relative to a key.\n *\n * Diatonic roots take their scale-degree numeral directly, so numerals are\n * correct in both major and minor keys (and any custom scale). The quality\n * selects the case and suffix; chromatic roots receive a flat/sharp spelling by\n * convention. When the chord carries a `bassPc` on a chord tone, a figured-bass\n * inversion (`6`, `64`, `65`, `43`, `42`) is emitted for plain triads and true\n * seventh chords; added-tone and extended qualities have no lossless figure and\n * render in root position instead (the bass is dropped, pitch classes are\n * preserved).\n *\n * @param chord The chord to name.\n * @param key The prevailing key.\n * @returns The Roman numeral string.\n * @example\n * ```ts\n * import { chordToRoman, makeChord, majorKey } from '@libraz/libcantus';\n * chordToRoman(makeChord(7, 'dom7'), majorKey(0)); // => 'V7' (G7 in C major)\n * ```\n * @category Functional Harmony\n */\nexport function chordToRoman(chord: Chord, key: KeyScale): string {\n  const { degreeNumber, accidental } = romanSpelling(chord.rootPc, key);\n  const { lower, suffix } = romanStyle(chord.quality);\n  const numeral: string = ROMAN[degreeNumber - 1] ?? 'I';\n  const cased = lower ? numeral.toLowerCase() : numeral;\n\n  let inversion = 0;\n  if (chord.bassPc !== undefined) {\n    const idx = chord.intervals.findIndex((iv) => mod12(chord.rootPc + iv) === chord.bassPc);\n    if (idx > 0) {\n      inversion = idx;\n    }\n  }\n  if (inversion > 0) {\n    const figure = SEVENTH_FIGURE_QUALITIES.has(chord.quality)\n      ? SEVENTH_FIGURES[inversion]\n      : TRIAD_FIGURE_QUALITIES.has(chord.quality)\n        ? TRIAD_FIGURES[inversion]\n        : undefined;\n    if (figure !== undefined) {\n      return `${accidental}${cased}${baseMarker(chord.quality)}${figure}`;\n    }\n    // No lossless figured-bass symbol exists — the quality is an added-tone or\n    // extended chord, or the bass falls on a tension beyond the seventh — so\n    // fall back to root-position rendering with the quality suffix rather than\n    // emitting a figure that would re-parse as a different chord.\n  }\n  return `${accidental}${cased}${suffix}`;\n}\n","/**\n * Harmonic function (tonic / subdominant / dominant), diatonicity, parallel-key\n * mirroring, and full chord analysis.\n *\n * Roots are pitch classes measured against the key tonic, so borrowed and\n * chromatic chords are handled by their semitone offset rather than requiring a\n * spelled key signature.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord, ChordQuality } from '../../theory/chord/index.js';\nimport { chordPitchClasses, makeChord } from '../../theory/chord/index.js';\nimport { isScaleTone, MAJOR_MASK, NATURAL_MINOR_MASK } from '../../theory/scale/index.js';\nimport { type BorrowedSource, borrowedSource } from './borrowed.js';\nimport { degreeRootPc, isNeapolitan, mod12 } from './internal.js';\nimport { chordToRoman } from './roman.js';\n\n/**\n * The three broad harmonic functions of tonal music.\n *\n * @category Functional Harmony\n */\nexport type HarmonicFunction = 'tonic' | 'subdominant' | 'dominant';\n\n/** Harmonic function of each semitone offset above the tonic (major context). */\nconst FUNCTION_BY_OFFSET: readonly HarmonicFunction[] = [\n  'tonic', // 0  I\n  'subdominant', // 1  bII (Neapolitan)\n  'subdominant', // 2  ii\n  'tonic', // 3  bIII\n  'tonic', // 4  iii\n  'subdominant', // 5  IV\n  'dominant', // 6  #IV / bV\n  'dominant', // 7  V\n  'subdominant', // 8  bVI\n  'tonic', // 9  vi\n  'subdominant', // 10 bVII\n  'dominant', // 11 vii\n];\n\n/**\n * Whether a key's scale has a minor third and no major third (a minor key).\n *\n * @category Functional Harmony\n */\nexport function isMinorKey(key: KeyScale): boolean {\n  const hasMinorThird = (key.modeMask12 >> 3) & 1;\n  const hasMajorThird = (key.modeMask12 >> 4) & 1;\n  return Boolean(hasMinorThird) && !hasMajorThird;\n}\n\n/**\n * The harmonic function of a chord in a key, from its root's offset above the\n * tonic. The mapping follows common-practice major-key function and is a useful\n * approximation in minor and for borrowed chords.\n *\n * @param chord The chord.\n * @param key The prevailing key.\n * @returns The harmonic function.\n * @category Functional Harmony\n */\nexport function functionOf(chord: Chord, key: KeyScale): HarmonicFunction {\n  return FUNCTION_BY_OFFSET[mod12(chord.rootPc - key.rootPc)] ?? 'tonic';\n}\n\n/**\n * The result of {@link analyzeChord}: function, borrowing, and Roman numeral.\n *\n * @category Functional Harmony\n */\nexport type ChordAnalysis = {\n  function: HarmonicFunction;\n  borrowed: boolean;\n  source: BorrowedSource;\n  roman: string;\n};\n\n/**\n * Whether every pitch class of a chord belongs to the key's scale.\n *\n * The test is strict against the key's own mode mask: in a natural-minor key\n * the harmonic-minor dominant (major V) is *not* diatonic, since the raised\n * leading tone lies outside the mask. Borrowing predicates treat that case as\n * an in-key alteration separately (see {@link isBorrowedChord}).\n *\n * @param chord The chord to test.\n * @param key The prevailing key.\n * @returns True if all chord pitch classes are scale tones.\n * @category Functional Harmony\n */\nexport function isDiatonic(chord: Chord, key: KeyScale): boolean {\n  return chordPitchClasses(chord).every((pc) => isScaleTone(pc, key));\n}\n\n/**\n * The parallel key: same tonic, opposite mode.\n *\n * A key with a minor third (natural/harmonic/melodic minor, dorian, phrygian)\n * maps to the parallel major; any other key maps to the parallel natural minor.\n *\n * @param key The key to mirror.\n * @returns The parallel major or natural-minor key on the same tonic.\n * @category Functional Harmony\n */\nexport function parallelKey(key: KeyScale): KeyScale {\n  return {\n    rootPc: mod12(key.rootPc),\n    modeMask12: isMinorKey(key) ? MAJOR_MASK : NATURAL_MINOR_MASK,\n  };\n}\n\n/** Diminished-family qualities: diminished triad, dim7, half-diminished. */\nfunction isDiminishedQuality(quality: ChordQuality): boolean {\n  return quality === 'dim' || quality === 'dim7' || quality === 'm7b5';\n}\n\n/** Whether the chord's interval template carries a major third above the root. */\nfunction hasMajorThird(chord: Chord): boolean {\n  return chord.intervals.some((interval) => mod12(interval) === 4);\n}\n\n/**\n * Quality-aware harmonic function, refining the offset table where chord\n * quality disambiguates: diminished chords on the leading tone or the raised\n * subdominant resolve by semitone and act as dominants; the Neapolitan and the\n * major-third chords on bVI/bVII borrowed from the parallel minor act as\n * subdominant (predominant) harmony. All other chords keep {@link functionOf}.\n */\nfunction qualityAwareFunction(chord: Chord, key: KeyScale): HarmonicFunction {\n  const offset = mod12(chord.rootPc - key.rootPc);\n  if (isDiminishedQuality(chord.quality) && (offset === 11 || offset === 6)) {\n    return 'dominant';\n  }\n  if (isNeapolitan(chord, key)) {\n    return 'subdominant';\n  }\n  if (!isMinorKey(key) && hasMajorThird(chord) && (offset === 8 || offset === 10)) {\n    return 'subdominant';\n  }\n  return functionOf(chord, key);\n}\n\n/**\n * Analyze a chord in a key: harmonic function, borrowing, and Roman numeral.\n *\n * The function is quality-aware (see the predicates behind it), the source\n * follows {@link borrowedSource}, and the numeral comes from\n * {@link chordToRoman}. `borrowed` is true whenever a source is identified —\n * including the Neapolitan, which the stricter parallel-mode predicate\n * {@link isBorrowedChord} does not count.\n *\n * @param chord The chord to analyze.\n * @param key The prevailing key.\n * @returns The chord analysis.\n * @example\n * ```ts\n * import { analyzeChord, makeChord, majorKey } from '@libraz/libcantus';\n * analyzeChord(makeChord(7, 'dom7'), majorKey(0));\n * // { function: 'dominant', borrowed: false, source: null, roman: 'V7' }\n * ```\n * @category Functional Harmony\n */\nexport function analyzeChord(chord: Chord, key: KeyScale): ChordAnalysis {\n  const source = borrowedSource(chord, key);\n  return {\n    function: qualityAwareFunction(chord, key),\n    borrowed: source !== null,\n    source,\n    roman: chordToRoman(chord, key),\n  };\n}\n\n/**\n * The secondary dominant (V7) that tonicizes a scale degree.\n *\n * @param targetDegree 0-based scale degree to tonicize.\n * @param key The prevailing key.\n * @returns A dominant-seventh chord a fifth above the target's root.\n * @category Functional Harmony\n */\nexport function secondaryDominant(targetDegree: number, key: KeyScale): Chord {\n  const targetRoot = degreeRootPc(targetDegree + 1, key);\n  return makeChord(mod12(targetRoot + 7), 'dom7');\n}\n","/**\n * Borrowed chords (modal interchange) and the Neapolitan.\n *\n * Roots are pitch classes measured against the key tonic, so borrowed and\n * chromatic chords are handled by their semitone offset rather than requiring a\n * spelled key signature.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord } from '../../theory/chord/index.js';\nimport { HARMONIC_MINOR_MASK } from '../../theory/scale/index.js';\nimport { isDiatonic, isMinorKey, parallelKey } from './function.js';\nimport { isNeapolitan, mod12 } from './internal.js';\n\n/**\n * The origin of a recognized non-diatonic chord, or null when none applies.\n *\n * @category Functional Harmony\n */\nexport type BorrowedSource = 'parallel-minor' | 'parallel-major' | 'neapolitan' | null;\n\n/**\n * In a minor key, whether a non-diatonic chord is explained by the harmonic\n * minor scale on the same tonic (major V, V7, the raised-leading-tone viio).\n * Such chords are in-key chromatic alterations, not modal interchange.\n */\nfunction isHarmonicMinorAlteration(chord: Chord, key: KeyScale): boolean {\n  return (\n    isMinorKey(key) &&\n    isDiatonic(chord, { rootPc: mod12(key.rootPc), modeMask12: HARMONIC_MINOR_MASK })\n  );\n}\n\n/**\n * Whether a chord is borrowed from the parallel mode (modal interchange).\n *\n * True when the chord is not diatonic to `key` but is diatonic to its\n * {@link parallelKey} — e.g. iv, bVI, or bVII in a major key, or the Picardy\n * tonic and major IV in a minor key. Two non-diatonic families are excluded:\n * chords diatonic to neither mode (they are chromatic, not borrowed), and, in\n * a minor key, chords explained by the harmonic minor scale (the major\n * dominant and raised-leading-tone chords), which are in-key alterations\n * rather than interchange even though they happen to fit the parallel major.\n *\n * @param chord The chord to test.\n * @param key The prevailing key.\n * @returns True if the chord is borrowed from the parallel mode.\n * @category Functional Harmony\n */\nexport function isBorrowedChord(chord: Chord, key: KeyScale): boolean {\n  if (isDiatonic(chord, key)) {\n    return false;\n  }\n  if (isHarmonicMinorAlteration(chord, key)) {\n    return false;\n  }\n  return isDiatonic(chord, parallelKey(key));\n}\n\n/**\n * Identify where a non-diatonic chord comes from.\n *\n * The Neapolitan (major triad on b2) is recognized first, since it sits\n * outside both parallel modes; parallel-mode borrowing follows the\n * {@link isBorrowedChord} rules. Diatonic chords, harmonic-minor alterations,\n * and unrecognized chromatic chords all yield null.\n *\n * @param chord The chord to classify.\n * @param key The prevailing key.\n * @returns The borrowing source, or null.\n * @category Functional Harmony\n */\nexport function borrowedSource(chord: Chord, key: KeyScale): BorrowedSource {\n  if (isDiatonic(chord, key)) {\n    return null;\n  }\n  if (isNeapolitan(chord, key)) {\n    return 'neapolitan';\n  }\n  if (isBorrowedChord(chord, key)) {\n    return isMinorKey(key) ? 'parallel-major' : 'parallel-minor';\n  }\n  return null;\n}\n","/**\n * Cadence detection between two successive chords.\n *\n * Roots are pitch classes measured against the key tonic, so borrowed and\n * chromatic chords are handled by their semitone offset rather than requiring a\n * spelled key signature.\n */\n\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord } from '../../theory/chord/index.js';\nimport { isMinorKey } from './function.js';\nimport { mod12 } from './internal.js';\n\n/**\n * A recognized cadence type, or null when a chord pair forms none.\n *\n * @category Functional Harmony\n */\nexport type Cadence = 'authentic' | 'plagal' | 'half' | 'deceptive' | null;\n\n/**\n * Classify the cadence formed by moving from one chord to the next.\n *\n * - authentic: V (dominant a fifth above the tonic) to I\n * - plagal: IV (a fourth above the tonic) to I\n * - deceptive: V to the submediant (diatonic vi or borrowed bVI in major, VI in\n *   minor)\n * - half: any chord other than the dominant itself to V\n *\n * A static V-to-V repeat with no root motion is not a cadence and yields null.\n *\n * @param from The penultimate chord.\n * @param to The final chord.\n * @param key The prevailing key.\n * @returns The cadence type, or null.\n * @example\n * ```ts\n * import { detectCadence, makeChord, majorKey } from '@libraz/libcantus';\n * detectCadence(makeChord(7, 'maj'), makeChord(0, 'maj'), majorKey(0)); // => 'authentic'\n * ```\n * @category Functional Harmony\n */\nexport function detectCadence(from: Chord, to: Chord, key: KeyScale): Cadence {\n  const tonic = mod12(key.rootPc);\n  const fromOffset = mod12(from.rootPc - tonic);\n  const toOffset = mod12(to.rootPc - tonic);\n  // Deceptive targets: the diatonic submediant (vi at offset 9 in major, VI at\n  // offset 8 in minor) plus, in a major key, the borrowed flat-submediant bVI\n  // at offset 8.\n  const deceptiveTargets = isMinorKey(key) ? [8] : [8, 9];\n  if (fromOffset === 7 && toOffset === 0) {\n    return 'authentic';\n  }\n  if (fromOffset === 5 && toOffset === 0) {\n    return 'plagal';\n  }\n  if (fromOffset === 7 && deceptiveTargets.includes(toOffset)) {\n    return 'deceptive';\n  }\n  // A move to the dominant is a half cadence, but a no-root-motion V-to-V repeat\n  // is not a cadence at all.\n  if (toOffset === 7 && fromOffset !== 7) {\n    return 'half';\n  }\n  return null;\n}\n","/**\n * Reharmonization: chord substitution, modal-interchange palettes, and negative\n * harmony. These transforms take an existing chord (or a key) and propose\n * alternative harmonies that preserve a chosen relationship — a shared function,\n * a common tone, a tonicizing dominant, or a reflection across the key axis.\n *\n * Roots are pitch classes (0..11); no spelled key signature is required.\n */\n\nimport { detectChordBest } from '../../analyze/detect/index.js';\nimport {\n  type BorrowedSource,\n  borrowedSource,\n  chordToRoman,\n  functionOf,\n  type HarmonicFunction,\n  isDiatonic,\n  parallelKey,\n} from '../../analyze/functional/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport {\n  type Chord,\n  type ChordQuality,\n  chordPitchClasses,\n  diatonicTriad,\n  makeChord,\n} from '../../theory/chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\n\n/** Reduce a value to a pitch class in [0, 11]. */\nfunction mod12(n: number): number {\n  return ((n % 12) + 12) % 12;\n}\n\n/**\n * The kind of substitution relationship a candidate realizes.\n *\n * @category Reharmonization\n */\nexport type SubstitutionType =\n  | 'tritone'\n  | 'relative'\n  | 'borrowed'\n  | 'chromatic-mediant'\n  | 'secondary-dominant';\n\n/**\n * A proposed chord substitution with its relationship, numeral, and function.\n *\n * @category Reharmonization\n */\nexport type Substitution = {\n  chord: Chord;\n  type: SubstitutionType;\n  roman: string;\n  function: HarmonicFunction;\n};\n\n/**\n * Options controlling which substitutions {@link substituteChord} returns.\n *\n * @category Reharmonization\n */\nexport type SubstituteOptions = {\n  /**\n   * Melody pitch classes that must remain chord tones. When given, only\n   * substitutions whose pitch classes contain every listed pitch class are\n   * kept, so the melody stays consonant against the new harmony.\n   */\n  melodyPcs?: number[];\n};\n\n/** Whether the chord's template carries a given interval (mod 12). */\nfunction hasInterval(chord: Chord, semitone: number): boolean {\n  return chord.intervals.some((iv) => mod12(iv) === semitone);\n}\n\n/** Whether a chord is a dominant type: a major third with a minor seventh. */\nfunction isDominantType(chord: Chord): boolean {\n  return hasInterval(chord, 4) && hasInterval(chord, 10);\n}\n\n/**\n * A chord that can be tonicized: it has a perfect fifth and a third but is not\n * itself a dominant seventh (which is an unstable, tonicizing sonority rather\n * than a stable target).\n */\nfunction isStableTarget(chord: Chord): boolean {\n  const hasFifth = hasInterval(chord, 7);\n  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);\n  return hasFifth && hasThird && !isDominantType(chord);\n}\n\n/** The triad pitch classes (root, third, fifth) implied by a chord's template. */\nfunction triadPitchClasses(chord: Chord): number[] {\n  const third = hasInterval(chord, 4) ? 4 : hasInterval(chord, 3) ? 3 : 4;\n  const fifth = hasInterval(chord, 8) ? 8 : hasInterval(chord, 6) ? 6 : 7;\n  return [mod12(chord.rootPc), mod12(chord.rootPc + third), mod12(chord.rootPc + fifth)];\n}\n\n/** Count the pitch classes shared between two pitch-class sets. */\nfunction commonToneCount(a: number[], b: number[]): number {\n  const set = new Set(b);\n  return a.filter((pc) => set.has(pc)).length;\n}\n\n/** The diatonic triads of a key, one per scale degree. */\nfunction diatonicTriadsOf(key: KeyScale): Chord[] {\n  const degrees = scaleTonesInDegreeOrder(key).length;\n  const triads: Chord[] = [];\n  for (let degree = 0; degree < degrees; degree += 1) {\n    triads.push(diatonicTriad(degree, key));\n  }\n  return triads;\n}\n\n/** Whether two chords share the same root pitch class and quality. */\nfunction sameChord(a: Chord, b: Chord): boolean {\n  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;\n}\n\n/** Root offsets (semitones) that form a third above or below a root. */\nconst THIRD_OFFSETS = [3, 4, 8, 9] as const;\n\n/**\n * Propose substitutions for a chord within a key.\n *\n * Candidates are generated by several relationships and deduplicated against the\n * original chord and each other:\n *\n * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.\n * - `secondary-dominant`: for a stable target, the dominant seventh a fifth\n *   above its root (tonicizing it).\n * - `relative`: a diatonic triad a third away that shares two common tones.\n * - `borrowed`: a triad from the parallel mode with the same harmonic function.\n * - `chromatic-mediant`: a major/minor triad a third away sharing one common\n *   tone.\n *\n * Each result carries its Roman numeral and harmonic function in `key`. When\n * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all\n * of those pitch classes are returned.\n *\n * @param chord The chord to reharmonize.\n * @param key The prevailing key.\n * @param opts Optional melody-preservation constraint.\n * @returns The deduplicated substitution candidates.\n * @example\n * ```ts\n * import { substituteChord, makeChord, majorKey } from '@libraz/libcantus';\n * const subs = substituteChord(makeChord(7, 'dom7'), majorKey(0));\n * // includes the tritone sub Db7 (rootPc 1, quality 'dom7')\n * ```\n * @category Reharmonization\n */\nexport function substituteChord(\n  chord: Chord,\n  key: KeyScale,\n  opts?: SubstituteOptions,\n): Substitution[] {\n  const original = triadPitchClasses(chord);\n  const candidates: { chord: Chord; type: SubstitutionType }[] = [];\n\n  // Tritone substitution: only for dominant-type chords.\n  if (isDominantType(chord)) {\n    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), 'dom7'), type: 'tritone' });\n  }\n\n  // Secondary dominant: the V7 tonicizing a stable target.\n  if (isStableTarget(chord)) {\n    candidates.push({\n      chord: makeChord(mod12(chord.rootPc + 7), 'dom7'),\n      type: 'secondary-dominant',\n    });\n  }\n\n  // Relative: a diatonic triad a third away sharing two common tones.\n  for (const triad of diatonicTriadsOf(key)) {\n    const offset = mod12(triad.rootPc - chord.rootPc);\n    if (\n      (THIRD_OFFSETS as readonly number[]).includes(offset) &&\n      commonToneCount(original, chordPitchClasses(triad)) === 2\n    ) {\n      candidates.push({ chord: triad, type: 'relative' });\n    }\n  }\n\n  // Borrowed: a parallel-mode triad sharing the original's harmonic function.\n  const targetFunction = functionOf(chord, key);\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {\n      candidates.push({ chord: triad, type: 'borrowed' });\n    }\n  }\n\n  // Chromatic mediants: major/minor triads a third away sharing one common tone.\n  for (const offset of THIRD_OFFSETS) {\n    for (const quality of ['maj', 'min'] as const) {\n      const mediant = makeChord(mod12(chord.rootPc + offset), quality);\n      if (\n        commonToneCount(original, chordPitchClasses(mediant)) === 1 &&\n        !isDiatonic(mediant, key)\n      ) {\n        candidates.push({ chord: mediant, type: 'chromatic-mediant' });\n      }\n    }\n  }\n\n  const melodyPcs = opts?.melodyPcs?.map(mod12);\n  const seen = new Set<string>();\n  const results: Substitution[] = [];\n  for (const candidate of candidates) {\n    if (sameChord(candidate.chord, chord)) {\n      continue;\n    }\n    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      continue;\n    }\n    seen.add(dedupeKey);\n    if (melodyPcs !== undefined) {\n      const pcs = new Set(chordPitchClasses(candidate.chord));\n      if (!melodyPcs.every((pc) => pcs.has(pc))) {\n        continue;\n      }\n    }\n    results.push({\n      chord: candidate.chord,\n      type: candidate.type,\n      roman: chordToRoman(candidate.chord, key),\n      function: functionOf(candidate.chord, key),\n    });\n  }\n  return results;\n}\n\n/**\n * A borrowed chord in the modal-interchange palette of a key.\n *\n * @category Reharmonization\n */\nexport type BorrowedChord = {\n  chord: Chord;\n  roman: string;\n  source: BorrowedSource;\n};\n\n/**\n * The modal-interchange palette of a key.\n *\n * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to\n * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major\n * key), plus the Neapolitan (a major triad on the flat second degree). Each\n * carries its Roman numeral and {@link borrowedSource} relative to `key`.\n *\n * @param key The prevailing key.\n * @returns The borrowed-chord palette.\n * @category Reharmonization\n */\nexport function modalInterchangePalette(key: KeyScale): BorrowedChord[] {\n  const palette: BorrowedChord[] = [];\n  const seen = new Set<string>();\n  const add = (chord: Chord) => {\n    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      return;\n    }\n    seen.add(dedupeKey);\n    palette.push({\n      chord,\n      roman: chordToRoman(chord, key),\n      source: borrowedSource(chord, key),\n    });\n  };\n\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (!isDiatonic(triad, key)) {\n      add(triad);\n    }\n  }\n  // The Neapolitan (major triad on b2) sits outside both parallel modes, so it\n  // is added explicitly — unless b2 is already diatonic (e.g. in a Phrygian key,\n  // where it is a native chord rather than a borrowing).\n  const neapolitan = makeChord(mod12(key.rootPc + 1), 'maj');\n  if (!isDiatonic(neapolitan, key)) {\n    add(neapolitan);\n  }\n  return palette;\n}\n\n/**\n * Reflect a chord across the tonic–dominant axis of a key (negative harmony).\n *\n * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key\n * tonic — the reflection that swaps the tonic with the dominant. The mirrored\n * pitch classes (including the bass, if set) are reassembled into a chord by\n * {@link detectChordBest}; when no chord is recognized, the mirrored root and\n * the original quality are used as a fallback.\n *\n * @param chord The chord to reflect.\n * @param key The prevailing key.\n * @returns The negative-harmony counterpart of the chord.\n * @example\n * ```ts\n * import { negativeHarmonyMirror, makeChord, majorKey } from '@libraz/libcantus';\n * negativeHarmonyMirror(makeChord(7, 'maj'), majorKey(0));\n * // G major reflected across C's axis => F minor (rootPc 5, quality 'min')\n * ```\n * @category Reharmonization\n */\nexport function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord {\n  const tonic = mod12(key.rootPc);\n  const mirror = (p: number) => mod12(2 * tonic + 7 - p);\n  const pcs = chordPitchClasses(chord).map(mirror);\n  const bassPc = chord.bassPc !== undefined ? mirror(chord.bassPc) : undefined;\n  // Place the mirrored bass an octave below so it is recognized as the lowest\n  // note and preserved through detection.\n  const pitches = bassPc !== undefined ? [bassPc - 12, ...pcs] : pcs;\n  const detected = detectChordBest(pitches);\n  if (detected) {\n    // Without an input bass the mirrored tones are octave-less, so detection may\n    // read the lowest pitch class as a slash bass and report a spurious\n    // inversion. Restore the recognized chord to root position in that case.\n    if (bassPc === undefined && detected.bassPc !== undefined) {\n      return makeChord(detected.rootPc, detected.quality);\n    }\n    return detected;\n  }\n  const quality: ChordQuality = chord.quality;\n  return makeChord(mirror(chord.rootPc), quality, bassPc);\n}\n","import type { Chord } from '../chord/index.js';\nimport { chordPitchClasses } from '../chord/index.js';\nimport { NAMED_SCALES } from '../scale/index.js';\n\n/** Reduce a value to a pitch class in [0, 11]. */\nfunction pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/** Count the set bits (scale tones) in a 12-bit mode mask. */\nfunction popcount12(mask: number): number {\n  let count = 0;\n  for (let n = 0; n < 12; n += 1) {\n    count += (mask >> n) & 1;\n  }\n  return count;\n}\n\n/** Test whether a pitch class belongs to a mode mask rooted on `scaleRootPc`. */\nfunction maskHasPitchClass(mask: number, scaleRootPc: number, pc: number): boolean {\n  const offset = pitchClass(pc - scaleRootPc);\n  return ((mask >> offset) & 1) === 1;\n}\n\n/**\n * Test whether every chord pitch class is contained in a scale.\n *\n * @param chordPcs The chord's pitch classes (0..11).\n * @param scaleMask The scale's 12-bit mode mask.\n * @param scaleRootPc The pitch class the mask is rooted on.\n * @returns True if the scale is a superset of the chord.\n *\n * @category Scales\n */\nexport function scaleMatchesChord(\n  chordPcs: number[],\n  scaleMask: number,\n  scaleRootPc: number,\n): boolean {\n  for (const pc of chordPcs) {\n    if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * A named scale rooted on a pitch class that fits over a chord.\n *\n * @category Scales\n */\nexport type ChordScaleMatch = {\n  name: string;\n  rootPc: number;\n};\n\n/**\n * Scale names whose mask duplicates another {@link NAMED_SCALES} entry\n * (major/ionian, naturalMinor/aeolian). Chord-scale analysis conventionally\n * speaks in mode names, so these aliases are skipped and only the modal name\n * is reported.\n */\nconst ALIASED_SCALE_NAMES = new Set(['major', 'naturalMinor']);\n\n/** Number of tones in a heptatonic (seven-note) scale. */\nconst HEPTATONIC_SIZE = 7;\n\n/**\n * List the scales that fit over a chord, best fit first.\n *\n * Only the chord root is considered as the scale root, matching the\n * conventional chord-scale relationship. Every entry of {@link NAMED_SCALES}\n * whose pitch-class set is a superset of the chord's is returned once per\n * distinct pitch-class set (aliased masks such as major/ionian report only the\n * modal name), ranked by fewest extra scale tones beyond the chord, then by\n * scale size (heptatonic before larger scales), then by scale name. For bare\n * triads and smaller chords, heptatonic scales rank before pentatonics and\n * other sizes: a pentatonic adds no modal color over a triad, so the seven-note\n * modes are the more useful answer. The chromatic scale is only returned as a\n * fallback when no other scale contains the chord.\n *\n * @param chord The chord to fit scales over.\n * @returns The matching scales rooted on the chord root, best fit first.\n *\n * @example\n * ```ts\n * import { makeChord, chordScales } from '@libraz/libcantus';\n * const scales = chordScales(makeChord(0, 'maj7'));\n * // scales for Cmaj7, best fit first; each is { name, rootPc: 0 }\n * ```\n *\n * @category Scales\n */\nexport function chordScales(chord: Chord): ChordScaleMatch[] {\n  const chordPcs = chordPitchClasses(chord);\n  const rootPc = pitchClass(chord.rootPc);\n  const ranked: { name: string; extra: number; size: number }[] = [];\n  const seenMasks = new Set<number>();\n  for (const name of Object.keys(NAMED_SCALES)) {\n    if (name === 'chromatic' || ALIASED_SCALE_NAMES.has(name)) {\n      continue;\n    }\n    const mask = NAMED_SCALES[name];\n    if (mask === undefined || seenMasks.has(mask)) {\n      continue;\n    }\n    seenMasks.add(mask);\n    if (scaleMatchesChord(chordPcs, mask, rootPc)) {\n      const size = popcount12(mask);\n      ranked.push({ name, extra: size - chordPcs.length, size });\n    }\n  }\n  if (ranked.length === 0) {\n    // No diatonic-style scale contains the chord; fall back to the chromatic\n    // scale, which trivially contains every pitch class.\n    if (NAMED_SCALES.chromatic !== undefined) {\n      return [{ name: 'chromatic', rootPc }];\n    }\n    return [];\n  }\n  const preferHeptatonic = chordPcs.length <= 3;\n  ranked.sort((a, b) => {\n    if (preferHeptatonic && (a.size === HEPTATONIC_SIZE) !== (b.size === HEPTATONIC_SIZE)) {\n      return a.size === HEPTATONIC_SIZE ? -1 : 1;\n    }\n    if (a.extra !== b.extra) {\n      return a.extra - b.extra;\n    }\n    if (a.size !== b.size) {\n      return a.size - b.size;\n    }\n    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;\n  });\n  return ranked.map((entry) => ({ name: entry.name, rootPc }));\n}\n\n/**\n * List a scale's avoid notes over a chord.\n *\n * An avoid note is a non-chord scale tone that lies a semitone directly above a\n * chord tone; sounding it against the chord clashes. The scale is rooted on the\n * chord root. If the scale does not contain the chord, no avoid notes exist.\n *\n * @param chord The chord providing the chord tones.\n * @param scaleName A key of {@link NAMED_SCALES}.\n * @returns The avoid-note pitch classes, sorted ascending in [0, 11].\n *\n * @category Scales\n */\nexport function avoidNotes(chord: Chord, scaleName: string): number[] {\n  const mask = NAMED_SCALES[scaleName];\n  if (mask === undefined) {\n    return [];\n  }\n  const rootPc = pitchClass(chord.rootPc);\n  const chordPcs = chordPitchClasses(chord);\n  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {\n    return [];\n  }\n  const chordSet = new Set(chordPcs);\n  const avoid: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {\n      continue;\n    }\n    if (chordSet.has(pitchClass(pc - 1))) {\n      avoid.push(pc);\n    }\n  }\n  return avoid.sort((a, b) => a - b);\n}\n\n/**\n * List a scale's available tensions over a chord.\n *\n * Available tensions are scale tones that are neither chord tones nor avoid\n * notes, i.e. the usable color tones (typically the 9/11/13 region). The scale\n * is rooted on the chord root. If the scale does not contain the chord, there\n * are no available tensions.\n *\n * @param chord The chord providing the chord tones.\n * @param scaleName A key of {@link NAMED_SCALES}.\n * @returns The available-tension pitch classes, sorted ascending in [0, 11].\n *\n * @example\n * ```ts\n * import { makeChord, availableTensions } from '@libraz/libcantus';\n * availableTensions(makeChord(0, 'maj7'), 'ionian'); // [2, 9] — color tones over Cmaj7\n * ```\n *\n * @category Scales\n */\nexport function availableTensions(chord: Chord, scaleName: string): number[] {\n  const mask = NAMED_SCALES[scaleName];\n  if (mask === undefined) {\n    return [];\n  }\n  const rootPc = pitchClass(chord.rootPc);\n  const chordPcs = chordPitchClasses(chord);\n  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {\n    return [];\n  }\n  const chordSet = new Set(chordPcs);\n  const avoidSet = new Set(avoidNotes(chord, scaleName));\n  const tensions: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || avoidSet.has(pc)) {\n      continue;\n    }\n    tensions.push(pc);\n  }\n  return tensions.sort((a, b) => a - b);\n}\n\n/**\n * A scale fit over a chord together with its avoid notes and tensions.\n *\n * @category Scales\n */\nexport type ChordScaleReportEntry = {\n  name: string;\n  rootPc: number;\n  avoid: number[];\n  tensions: number[];\n};\n\n/**\n * Report the best-fitting scales for a chord with their avoid notes and tensions.\n *\n * Combines {@link chordScales}, {@link avoidNotes}, and {@link availableTensions}\n * into a single ergonomic result, ordered best fit first.\n *\n * @param chord The chord to analyze.\n * @param limit Optional maximum number of scales to report; all by default.\n * @returns One entry per reported scale, best fit first.\n *\n * @category Scales\n */\nexport function chordScaleReport(chord: Chord, limit?: number): ChordScaleReportEntry[] {\n  const matches = chordScales(chord);\n  const chosen = limit === undefined ? matches : matches.slice(0, Math.max(0, limit));\n  return chosen.map((match) => ({\n    name: match.name,\n    rootPc: match.rootPc,\n    avoid: avoidNotes(chord, match.name),\n    tensions: availableTensions(chord, match.name),\n  }));\n}\n\n/**\n * A chord paired with the scale chosen for it by {@link scalesForChanges}.\n *\n * @category Scales\n */\nexport type ScaleChoice = {\n  chord: Chord;\n  scale: ChordScaleMatch;\n};\n\n/**\n * Small per-candidate penalty added in {@link scalesForChanges} so that, among\n * choices of otherwise-equal transition cost, the tighter best-fit scale wins.\n */\nconst RANK_PENALTY = 0.01;\n\n/** Build the pitch-class set of a named scale rooted on `rootPc`. */\nfunction scalePitchClassSet(name: string, rootPc: number): Set<number> {\n  const mask = NAMED_SCALES[name];\n  const pcs = new Set<number>();\n  if (mask === undefined) {\n    return pcs;\n  }\n  for (let n = 0; n < 12; n += 1) {\n    if (((mask >> n) & 1) === 1) {\n      pcs.add(pitchClass(rootPc + n));\n    }\n  }\n  return pcs;\n}\n\n/** Count pitch classes that belong to exactly one of two sets. */\nfunction symmetricDifferenceSize(a: Set<number>, b: Set<number>): number {\n  let count = 0;\n  for (const pc of a) {\n    if (!b.has(pc)) {\n      count += 1;\n    }\n  }\n  for (const pc of b) {\n    if (!a.has(pc)) {\n      count += 1;\n    }\n  }\n  return count;\n}\n\n/**\n * Choose one scale per chord across a progression, favoring continuity.\n *\n * Each chord's {@link chordScales} candidates form a stage in a Viterbi-style\n * dynamic program. The transition cost between adjacent choices is the number\n * of pitch classes that differ between their pitch-class sets (the symmetric\n * difference), plus a small penalty for straying from a chord's best-fit scale\n * so that ties break toward the tighter fit. The minimum-total-cost path is\n * returned, one {@link ScaleChoice} per input chord in the original order.\n *\n * @param chords The chord sequence to choose scales for.\n * @returns One scale choice per chord, in input order.\n *\n * @category Scales\n */\nexport function scalesForChanges(chords: Chord[]): ScaleChoice[] {\n  if (chords.length === 0) {\n    return [];\n  }\n  const candidateLists = chords.map((chord) => chordScales(chord));\n  const pcSets = candidateLists.map((candidates) =>\n    candidates.map((match) => scalePitchClassSet(match.name, match.rootPc)),\n  );\n\n  const first = candidateLists[0] ?? [];\n  const dp: number[][] = [first.map((_, j) => j * RANK_PENALTY)];\n  const back: number[][] = [first.map(() => -1)];\n\n  for (let i = 1; i < candidateLists.length; i += 1) {\n    const candidates = candidateLists[i] ?? [];\n    const prevCosts = dp[i - 1] ?? [];\n    const prevSets = pcSets[i - 1] ?? [];\n    const curSets = pcSets[i] ?? [];\n    const stageCosts: number[] = [];\n    const stageBack: number[] = [];\n    for (let j = 0; j < candidates.length; j += 1) {\n      let bestCost = Number.POSITIVE_INFINITY;\n      let bestPrev = -1;\n      for (let k = 0; k < prevCosts.length; k += 1) {\n        const transition = symmetricDifferenceSize(\n          prevSets[k] ?? new Set(),\n          curSets[j] ?? new Set(),\n        );\n        const cost = (prevCosts[k] ?? 0) + transition;\n        if (cost < bestCost) {\n          bestCost = cost;\n          bestPrev = k;\n        }\n      }\n      stageCosts.push(bestCost + j * RANK_PENALTY);\n      stageBack.push(bestPrev);\n    }\n    dp.push(stageCosts);\n    back.push(stageBack);\n  }\n\n  const lastCosts = dp[dp.length - 1] ?? [];\n  let bestFinal = 0;\n  for (let j = 1; j < lastCosts.length; j += 1) {\n    if ((lastCosts[j] ?? Number.POSITIVE_INFINITY) < (lastCosts[bestFinal] ?? 0)) {\n      bestFinal = j;\n    }\n  }\n\n  const chosenIndices: number[] = new Array(candidateLists.length);\n  let current = bestFinal;\n  for (let i = candidateLists.length - 1; i >= 0; i -= 1) {\n    chosenIndices[i] = current;\n    current = back[i]?.[current] ?? -1;\n  }\n\n  return chords.map((chord, i) => {\n    const candidates = candidateLists[i] ?? [];\n    const scale = candidates[chosenIndices[i] ?? 0] ?? { name: 'chromatic', rootPc: chord.rootPc };\n    return { chord, scale };\n  });\n}\n","/**\n * Pitch spelling: letter-name notes, enharmonic-aware conversion, and spelled\n * intervals.\n *\n * The rest of the library works in pitch classes (0..11), which cannot tell a\n * G# from an Ab or an augmented fourth from a diminished fifth. This module adds\n * an explicit spelling layer — a note is a diatonic letter plus a chromatic\n * alteration — so interval quality (P/M/m/A/d) and enharmonic identity are\n * preserved.\n */\n\n/** Semitone offset of each natural letter above C: C D E F G A B. */\nconst LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11] as const;\n\n/** Letter glyphs indexed by letter number (0 = C .. 6 = B). */\nconst LETTER_NAMES = ['C', 'D', 'E', 'F', 'G', 'A', 'B'] as const;\n\n/**\n * A spelled note: a diatonic letter, a chromatic alteration, and an optional\n * octave.\n *\n * - `letter` is 0..6 for C..B.\n * - `alter` is the number of semitones of alteration: -2 double-flat, -1 flat,\n *   0 natural, +1 sharp, +2 double-sharp.\n * - `octave` follows scientific pitch notation (middle C = C4 = MIDI 60). When\n *   absent, the note denotes a bare pitch class.\n *\n * @category Pitch & Intervals\n */\nexport type Note = {\n  letter: number;\n  alter: number;\n  octave?: number;\n};\n\n/**\n * A spelled interval: a diatonic number, a quality label, and its semitone span.\n *\n * @category Pitch & Intervals\n */\nexport type SpelledInterval = {\n  /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */\n  number: number;\n  /** Quality label: 'P', 'M', 'm', or repeated 'A'/'d' for (multiply) aug/dim. */\n  quality: string;\n  /** Signed semitone distance from the first note to the second. */\n  semitones: number;\n};\n\n/** Reduce any integer to a pitch class in [0, 11]. */\nfunction mod12(n: number): number {\n  return ((n % 12) + 12) % 12;\n}\n\n/** Reduce any integer to [0, 7). */\nfunction mod7(n: number): number {\n  return ((n % 7) + 7) % 7;\n}\n\n/**\n * Parse scientific pitch notation into a {@link Note}.\n *\n * Accepts a letter (case-insensitive) followed by any number of same-direction\n * accidentals and an optional octave, e.g. `\"C\"`, `\"C#4\"`, `\"Bb\"`, `\"F##3\"`,\n * `\"Ebb2\"`. Both `#` and `x` (double-sharp) are accepted for sharps; `b` for\n * flats. Mixing sharps and flats (e.g. `\"C#b\"`) is rejected.\n *\n * @param text The note text.\n * @returns The parsed note.\n * @throws If the text is not a valid note.\n * @example\n * ```ts\n * import { parseNote, noteToMidi } from '@libraz/libcantus';\n * const n = parseNote('C#4');\n * noteToMidi(n); // 61\n * ```\n * @category Pitch & Intervals\n */\nexport function parseNote(text: string): Note {\n  const match = /^([A-Ga-g])([#x]*|b*)(-?\\d+)?$/.exec(text.trim());\n  if (!match) {\n    throw new Error(`Invalid note: ${text}`);\n  }\n  const letterGlyph = (match[1] ?? '').toUpperCase();\n  const letter = LETTER_NAMES.indexOf(letterGlyph as (typeof LETTER_NAMES)[number]);\n  let alter = 0;\n  for (const ch of match[2] ?? '') {\n    if (ch === '#') {\n      alter += 1;\n    } else if (ch === 'x') {\n      alter += 2;\n    } else if (ch === 'b') {\n      alter -= 1;\n    }\n  }\n  const note: Note = { letter, alter };\n  if (match[3] !== undefined) {\n    note.octave = Number.parseInt(match[3], 10);\n  }\n  return note;\n}\n\n/** Render an alteration as accidental glyphs (`##`, `b`, empty for natural). */\nfunction formatAlter(alter: number): string {\n  if (alter > 0) {\n    return '#'.repeat(alter);\n  }\n  if (alter < 0) {\n    return 'b'.repeat(-alter);\n  }\n  return '';\n}\n\n/**\n * Render a {@link Note} as scientific pitch notation.\n *\n * @param note The note to format.\n * @returns The note text, including the octave when present.\n * @example\n * ```ts\n * import { formatNote, parseNote } from '@libraz/libcantus';\n * formatNote(parseNote('C#4')); // 'C#4'\n * ```\n * @category Pitch & Intervals\n */\nexport function formatNote(note: Note): string {\n  const glyph = LETTER_NAMES[mod7(note.letter)] ?? 'C';\n  const octave = note.octave === undefined ? '' : String(note.octave);\n  return `${glyph}${formatAlter(note.alter)}${octave}`;\n}\n\n/**\n * Pitch class (0..11) of a note, ignoring octave.\n *\n * @param note The note.\n * @returns The pitch class.\n * @example\n * ```ts\n * import { noteToPitchClass, parseNote } from '@libraz/libcantus';\n * noteToPitchClass(parseNote('Db')); // 1\n * ```\n * @category Pitch & Intervals\n */\nexport function noteToPitchClass(note: Note): number {\n  const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;\n  return mod12(natural + note.alter);\n}\n\n/**\n * MIDI number of a note (middle C = C4 = 60).\n *\n * @param note The note; must carry an octave.\n * @returns The MIDI number.\n * @throws If the note has no octave.\n * @example\n * ```ts\n * import { noteToMidi, parseNote } from '@libraz/libcantus';\n * noteToMidi(parseNote('A4')); // 69\n * ```\n * @category Pitch & Intervals\n */\nexport function noteToMidi(note: Note): number {\n  if (note.octave === undefined) {\n    throw new Error('noteToMidi requires an octave');\n  }\n  const natural = LETTER_SEMITONES[mod7(note.letter)] ?? 0;\n  return (note.octave + 1) * 12 + natural + note.alter;\n}\n\n/** Preferred spelling when naming a black key from a bare MIDI number. */\nconst SHARP_SPELLING: readonly [number, number][] = [\n  [0, 0],\n  [0, 1],\n  [1, 0],\n  [1, 1],\n  [2, 0],\n  [3, 0],\n  [3, 1],\n  [4, 0],\n  [4, 1],\n  [5, 0],\n  [5, 1],\n  [6, 0],\n];\n\nconst FLAT_SPELLING: readonly [number, number][] = [\n  [0, 0],\n  [1, -1],\n  [1, 0],\n  [2, -1],\n  [2, 0],\n  [3, 0],\n  [4, -1],\n  [4, 0],\n  [5, -1],\n  [5, 0],\n  [6, -1],\n  [6, 0],\n];\n\n/**\n * Name a MIDI number as a {@link Note}, choosing sharp or flat spelling.\n *\n * The input is rounded to the nearest integer but is not clamped to the MIDI\n * range 0..127: out-of-range values extrapolate linearly (e.g. `-1` -> `B-2`,\n * `128` -> `G#9`) and remain an exact inverse of {@link noteToMidi}.\n *\n * @param midi The MIDI number.\n * @param spelling Whether to prefer sharps or flats for black keys.\n * @returns The spelled note, with octave.\n * @example\n * ```ts\n * import { midiToNote, formatNote } from '@libraz/libcantus';\n * formatNote(midiToNote(61)); // 'C#4'\n * formatNote(midiToNote(61, 'flat')); // 'Db4'\n * ```\n * @category Pitch & Intervals\n */\nexport function midiToNote(midi: number, spelling: 'sharp' | 'flat' = 'sharp'): Note {\n  const rounded = Math.round(midi);\n  const pc = mod12(rounded);\n  const octave = Math.floor(rounded / 12) - 1;\n  const table = spelling === 'sharp' ? SHARP_SPELLING : FLAT_SPELLING;\n  const entry = table[pc] ?? [0, 0];\n  return { letter: entry[0], alter: entry[1], octave };\n}\n\n/** Reference semitone span of a perfect/major simple interval by diatonic number. */\nconst SIMPLE_REFERENCE = [0, 0, 2, 4, 5, 7, 9, 11] as const;\n\n/** Whether a simple diatonic number (1..7 within an octave) is a perfect kind. */\nfunction isPerfectNumber(simpleNumber: number): boolean {\n  return simpleNumber === 1 || simpleNumber === 4 || simpleNumber === 5;\n}\n\n/** Quality label from a diatonic number and its actual semitone span. */\nfunction qualityFromSpan(numberValue: number, semitones: number): string {\n  const octaves = Math.floor((numberValue - 1) / 7);\n  const simple = numberValue - 7 * octaves;\n  const reference = (SIMPLE_REFERENCE[simple] ?? 0) + 12 * octaves;\n  const delta = semitones - reference;\n  if (isPerfectNumber(simple)) {\n    if (delta === 0) {\n      return 'P';\n    }\n    return delta > 0 ? 'A'.repeat(delta) : 'd'.repeat(-delta);\n  }\n  if (delta === 0) {\n    return 'M';\n  }\n  if (delta === -1) {\n    return 'm';\n  }\n  return delta > 0 ? 'A'.repeat(delta) : 'd'.repeat(-delta - 1);\n}\n\n/** Diatonic ladder index of a note (letter + 7 * octave when octave-bearing). */\nfunction diatonicIndex(note: Note): number {\n  return mod7(note.letter) + 7 * (note.octave ?? 0);\n}\n\n/**\n * The spelled interval from one note to another.\n *\n * When both notes carry octaves, the interval reflects their full signed\n * distance (so `C4 -> C5` is a perfect octave). When either lacks an octave the\n * interval is measured within a single ascending octave from `a` to `b`.\n *\n * @param a The lower/first note.\n * @param b The upper/second note.\n * @returns The diatonic number, quality, and semitone span.\n * @example\n * ```ts\n * import { spelledInterval, parseNote } from '@libraz/libcantus';\n * spelledInterval(parseNote('C4'), parseNote('G4'));\n * // { number: 5, quality: 'P', semitones: 7 }\n * ```\n * @category Pitch & Intervals\n */\nexport function spelledInterval(a: Note, b: Note): SpelledInterval {\n  const octaved = a.octave !== undefined && b.octave !== undefined;\n  let letterSteps: number;\n  let semitones: number;\n  if (octaved) {\n    letterSteps = diatonicIndex(b) - diatonicIndex(a);\n    // Signed pitch distance from a to b, so a note below a yields a negative span.\n    semitones = noteToMidi(b) - noteToMidi(a);\n  } else {\n    letterSteps = mod7(b.letter - a.letter);\n    let rawSemis = mod12(noteToPitchClass(b) - noteToPitchClass(a));\n    // Lift the chromatic span into the octave nearest the diatonic reference so\n    // wraparound intervals stay consistent with the diatonic number instead of\n    // collapsing modulo 12. The correction is bidirectional: an upward wrap\n    // (e.g. Ab -> G# = augmented seventh) adds an octave, while a same-letter or\n    // downward chromatic step (e.g. E -> Eb, F# -> F, C -> Cb = descending\n    // diminished/augmented unison) subtracts one so the sign follows pitch\n    // direction instead of returning a garbage stack of augmentations.\n    const reference = SIMPLE_REFERENCE[letterSteps + 1] ?? 0;\n    if (reference - rawSemis > 6) {\n      rawSemis += 12;\n    } else if (rawSemis - reference > 6) {\n      rawSemis -= 12;\n    }\n    semitones = rawSemis;\n  }\n  const absSteps = Math.abs(letterSteps);\n  const number = absSteps + 1;\n  // Quality comes from the absolute chromatic span; semitones keeps its sign.\n  const quality = qualityFromSpan(number, Math.abs(semitones));\n  return { number, quality, semitones };\n}\n","/**\n * Spelling: derive letter-name notes for scales and chords from a spelled tonic.\n *\n * The theory core works in pitch classes, which cannot choose between (say) a\n * G# and an Ab. Given a spelled tonic, this module assigns diatonic letters to\n * scale degrees and chord tones so a C major scale spells as C D E F G A B and\n * A harmonic minor spells its seventh as G#.\n */\n\nimport type { Note } from '../../core/pitch/index.js';\nimport { formatNote } from '../../core/pitch/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport type { Chord } from '../chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../scale/index.js';\n\n/** Semitone offset of each natural letter above C: C D E F G A B. */\nconst LETTER_SEMITONES = [0, 2, 4, 5, 7, 9, 11] as const;\n\n/**\n * Conventional degree assignment for each chromatic offset above the tonic.\n *\n * The letter is derived from the tonic's letter plus `degreeOffset` (so the\n * spelling follows the key's diatonic letters), and the accidental is recomputed\n * for that letter. This covers the flat-side alterations (b2, b3, b6, b7), the\n * raised fourth (#4), and the raised degrees of a minor key: the raised sixth\n * (#6) and the raised leading tone (#7). The latter two keep sharp-side minor\n * keys spelling their raised degrees with the key-correct letter (e.g. F# minor\n * spells its leading tone E#, not F).\n *\n * The `alter` field is illustrative only; `spellPitchClass` recomputes the\n * accidental from the chosen letter.\n */\nconst CHROMATIC_SPELLING: Record<number, { degreeOffset: number; alter: number }> = {\n  1: { degreeOffset: 1, alter: -1 }, // b2\n  3: { degreeOffset: 2, alter: -1 }, // b3\n  6: { degreeOffset: 3, alter: 1 }, // #4\n  8: { degreeOffset: 5, alter: -1 }, // b6\n  9: { degreeOffset: 5, alter: 1 }, // #6 (raised sixth of a minor key)\n  10: { degreeOffset: 6, alter: -1 }, // b7\n  11: { degreeOffset: 6, alter: 1 }, // #7 (raised leading tone of a minor key)\n};\n\nfunction mod12(n: number): number {\n  return ((n % 12) + 12) % 12;\n}\n\nfunction mod7(n: number): number {\n  return ((n % 7) + 7) % 7;\n}\n\n/** Natural pitch class of a letter (0 = C .. 6 = B). */\nfunction naturalPc(letter: number): number {\n  return LETTER_SEMITONES[mod7(letter)] ?? 0;\n}\n\n/** Shortest signed alteration (in [-6, 6]) taking a letter's natural pc to `pc`. */\nfunction alterFor(letter: number, pc: number): number {\n  let d = mod12(pc - naturalPc(letter));\n  if (d > 6) {\n    d -= 12;\n  }\n  return d;\n}\n\n/** Whether the key's scale is a seven-note (heptatonic) scale. */\nfunction isHeptatonic(key: KeyScale): boolean {\n  return scaleTonesInDegreeOrder(key).length === 7;\n}\n\n/**\n * Spell a single pitch class relative to a spelled tonic and key.\n *\n * Diatonic pitch classes take the scale's letter for their degree; the common\n * chromatic tones (b2, b3, #4, b6, b7) and a minor key's raised degrees (#6, #7)\n * take their conventional, key-correct accidental spelling; anything else falls\n * back to a sharp spelling of the nearest natural.\n *\n * @param pc The pitch class to spell.\n * @param tonic The spelled tonic (its letter anchors the spelling).\n * @param key The key/scale.\n * @returns The spelled note (without octave).\n * @category Pitch & Intervals\n */\nexport function spellPitchClass(pc: number, tonic: Note, key: KeyScale): Note {\n  const tonicPc = mod12(naturalPc(tonic.letter) + tonic.alter);\n  const offset = mod12(pc - tonicPc);\n  const tones = scaleTonesInDegreeOrder(key);\n\n  if (isHeptatonic(key)) {\n    const degree = tones.indexOf(mod12(pc));\n    if (degree >= 0) {\n      const letter = mod7(tonic.letter + degree);\n      return { letter, alter: alterFor(letter, pc) };\n    }\n    const chromatic = CHROMATIC_SPELLING[offset];\n    if (chromatic) {\n      const letter = mod7(tonic.letter + chromatic.degreeOffset);\n      return { letter, alter: alterFor(letter, pc) };\n    }\n  }\n\n  // Fallback: name the pitch class from the nearest natural, preferring a sharp.\n  for (let letter = 0; letter < 7; letter += 1) {\n    if (naturalPc(letter) === mod12(pc)) {\n      return { letter, alter: 0 };\n    }\n  }\n  const belowLetter = mod7([0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6][mod12(pc)] ?? 0);\n  return { letter: belowLetter, alter: alterFor(belowLetter, pc) };\n}\n\n/**\n * Spell every pitch class of a scale, in ascending scale-degree order.\n *\n * Correct for heptatonic scales (each degree gets the next letter). Non-standard\n * scales are spelled tone-by-tone with a sharp preference.\n *\n * @param tonic The spelled tonic.\n * @param key The key/scale.\n * @returns Spelled notes, one per scale degree.\n * @example\n * ```ts\n * import { spellScale, noteNames, parseNote, majorKey } from '@libraz/libcantus';\n * noteNames(spellScale(parseNote('C'), majorKey(0)));\n * // ['C', 'D', 'E', 'F', 'G', 'A', 'B']\n * ```\n * @category Pitch & Intervals\n */\nexport function spellScale(tonic: Note, key: KeyScale): Note[] {\n  return scaleTonesInDegreeOrder(key).map((pc) => spellPitchClass(pc, tonic, key));\n}\n\n/**\n * Spell an arbitrary list of pitch classes relative to a key.\n *\n * @param pcs The pitch classes.\n * @param tonic The spelled tonic.\n * @param key The key/scale.\n * @returns Spelled notes, in input order.\n * @category Pitch & Intervals\n */\nexport function spellPitchClasses(pcs: number[], tonic: Note, key: KeyScale): Note[] {\n  return pcs.map((pc) => spellPitchClass(pc, tonic, key));\n}\n\n/**\n * Spell a chord's tones, in the chord's own (tertian) order, relative to a key.\n *\n * Diatonic chords spell exactly (e.g. G7 in C major -> G B D F). Chromatic chord\n * tones take their conventional spelling; enharmonically ambiguous altered\n * tensions may be spelled by the general convention rather than by chord\n * function.\n *\n * @param chord The chord.\n * @param tonic The spelled tonic of the key.\n * @param key The key/scale.\n * @returns Spelled chord tones, root first.\n * @example\n * ```ts\n * import { spellChord, noteNames, parseNote, majorKey, makeChord } from '@libraz/libcantus';\n * // G7 in C major\n * noteNames(spellChord(makeChord(7, 'dom7'), parseNote('C'), majorKey(0)));\n * // ['G', 'B', 'D', 'F']\n * ```\n * @category Pitch & Intervals\n */\nexport function spellChord(chord: Chord, tonic: Note, key: KeyScale): Note[] {\n  return chord.intervals.map((interval) =>\n    spellPitchClass(mod12(chord.rootPc + interval), tonic, key),\n  );\n}\n\n/**\n * Convenience: render spelled notes as letter-name strings.\n *\n * @param notes The notes.\n * @returns Their formatted names.\n * @category Pitch & Intervals\n */\nexport function noteNames(notes: Note[]): string[] {\n  return notes.map(formatNote);\n}\n","/**\n * Lead-sheet chord symbol parsing and formatting.\n *\n * Bridges the informal `<root><quality>[/<bass>]` notation musicians write\n * (`Cmaj7`, `F#m7b5`, `Bb7`, `C/G`) and the library's structured {@link Chord}\n * type, so callers can accept/emit plain text at the edges of the API.\n */\n\nimport {\n  formatNote,\n  midiToNote,\n  type Note,\n  noteToPitchClass,\n  parseNote,\n} from '../../core/pitch/index.js';\nimport { type Chord, type ChordQuality, makeChord, type PitchSpelling } from '../chord/index.js';\n\n/**\n * Matches a chord root: a letter A-G (case-insensitive, like {@link parseNote})\n * with an optional single-direction accidental.\n */\nconst ROOT_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?/;\n\n/** Matches a bare note usable as a slash-chord bass (no octave). */\nconst BASS_RE = /^[A-Ga-g](?:#{1,2}|b{1,2})?$/;\n\n/** Recognized quality suffixes, keyed by their exact lead-sheet spelling. */\nconst QUALITY_MAP: Record<string, ChordQuality> = {\n  '': 'maj',\n  m: 'min',\n  min: 'min',\n  '-': 'min',\n  dim: 'dim',\n  '°': 'dim',\n  aug: 'aug',\n  '+': 'aug',\n  maj7: 'maj7',\n  M7: 'maj7',\n  Δ: 'maj7',\n  Δ7: 'maj7',\n  m7: 'min7',\n  min7: 'min7',\n  '-7': 'min7',\n  '7': 'dom7',\n  dim7: 'dim7',\n  '°7': 'dim7',\n  m7b5: 'm7b5',\n  ø: 'm7b5',\n  ø7: 'm7b5',\n  min7b5: 'm7b5',\n  mMaj7: 'minMaj7',\n  mM7: 'minMaj7',\n  minMaj7: 'minMaj7',\n  aug7: 'aug7',\n  '+7': 'aug7',\n  '7#5': 'aug7',\n  augMaj7: 'augMaj7',\n  augM7: 'augMaj7',\n  '+maj7': 'augMaj7',\n  '+M7': 'augMaj7',\n  majb5: 'majb5',\n  'maj(b5)': 'majb5',\n  '(b5)': 'majb5',\n  '6': '6',\n  m6: 'min6',\n  min6: 'min6',\n  '6/9': '6/9',\n  '69': '6/9',\n  sus2: 'sus2',\n  sus: 'sus4',\n  sus4: 'sus4',\n  add9: 'add9',\n  add11: 'add11',\n  maj9: 'maj9',\n  M9: 'maj9',\n  m9: 'min9',\n  min9: 'min9',\n  '9': 'dom9',\n  '7b9': '7b9',\n  '7#9': '7#9',\n  '7#11': '7#11',\n  '7b13': '7b13',\n  '11': '11',\n  '13': '13',\n  '5': '5',\n};\n\n/** Canonical lead-sheet suffix emitted for each chord quality when formatting. */\nconst CANONICAL_SUFFIX: Record<ChordQuality, string> = {\n  maj: '',\n  min: 'm',\n  dim: 'dim',\n  aug: 'aug',\n  maj7: 'maj7',\n  min7: 'm7',\n  dom7: '7',\n  dim7: 'dim7',\n  m7b5: 'm7b5',\n  minMaj7: 'mMaj7',\n  aug7: 'aug7',\n  augMaj7: 'augMaj7',\n  majb5: 'maj(b5)',\n  '6': '6',\n  min6: 'm6',\n  '6/9': '6/9',\n  sus2: 'sus2',\n  sus4: 'sus4',\n  add9: 'add9',\n  add11: 'add11',\n  maj9: 'maj9',\n  min9: 'm9',\n  dom9: '9',\n  '7b9': '7b9',\n  '7#9': '7#9',\n  '7#11': '7#11',\n  '7b13': '7b13',\n  '11': '11',\n  '13': '13',\n  '5': '5',\n};\n\n/** Reduce a value to a pitch class in [0, 11]. */\nfunction pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/** Build a chord and record the parsed spellings as enharmonic hints. */\nfunction makeSpelledChord(root: Note, quality: ChordQuality, bass?: Note): Chord {\n  const chord = makeChord(\n    noteToPitchClass(root),\n    quality,\n    bass === undefined ? undefined : noteToPitchClass(bass),\n  );\n  chord.rootSpelling = { letter: root.letter, alter: root.alter };\n  if (bass !== undefined) {\n    chord.bassSpelling = { letter: bass.letter, alter: bass.alter };\n  }\n  return chord;\n}\n\n/**\n * Parse a lead-sheet chord symbol into a {@link Chord}.\n *\n * Accepts `<root><quality>[/<bass>]`, e.g. `Cmaj7`, `F#m7b5`, `Bb7`, `C/G`,\n * `C6/9`, `C6/9/E`. Root and bass letters are case-insensitive, matching\n * {@link parseNote}. A `/` is ambiguous between a slash bass and the `6/9`\n * quality; the text splits at the last `/` whose right-hand side is a valid\n * bare note preceded by a recognized quality, so `6/9` (with or without a\n * further slash bass) parses as a quality.\n *\n * The parsed chord carries the root/bass spellings as enharmonic hints\n * (`rootSpelling`/`bassSpelling`) so {@link formatChordSymbol} can reproduce\n * flat spellings such as `Bbmaj7` instead of respelling them with sharps.\n *\n * @param text The chord symbol text.\n * @returns The parsed chord.\n * @throws If the root or quality is not recognized.\n * @example\n * ```ts\n * import { parseChordSymbol, formatChordSymbol } from '@libraz/libcantus';\n * const c = parseChordSymbol('Bbmaj7');\n * formatChordSymbol(c); // 'Bbmaj7' — flat spelling is preserved on round-trip\n * ```\n * @category Chords\n */\nexport function parseChordSymbol(text: string): Chord {\n  const trimmed = text.trim();\n  const rootMatch = ROOT_RE.exec(trimmed);\n  if (!rootMatch) {\n    throw new Error(`Invalid chord symbol: ${text}`);\n  }\n  const rootToken = rootMatch[0];\n  const rootNote = parseNote(rootToken);\n  const rest = trimmed.slice(rootToken.length);\n\n  // Split at the last '/' so the '6/9' quality's own slash never masks a\n  // trailing slash bass (e.g. 'C6/9/E').\n  const slashIndex = rest.lastIndexOf('/');\n  if (slashIndex !== -1) {\n    const before = rest.slice(0, slashIndex);\n    const after = rest.slice(slashIndex + 1);\n    const beforeQuality = QUALITY_MAP[before];\n    if (beforeQuality !== undefined && BASS_RE.test(after)) {\n      return makeSpelledChord(rootNote, beforeQuality, parseNote(after));\n    }\n  }\n\n  const quality = QUALITY_MAP[rest];\n  if (quality === undefined) {\n    throw new Error(`Unrecognized chord quality: ${text}`);\n  }\n  return makeSpelledChord(rootNote, quality);\n}\n\n/**\n * Name a pitch class, preferring a spelling hint when it is still valid.\n *\n * A hint is used only when no explicit sharp/flat preference was given and the\n * hint still resolves to `pc` (a stale hint left over after transposition is\n * ignored). Otherwise the pitch class is respelled from the requested table.\n */\nfunction pitchClassName(pc: number, hint: PitchSpelling | undefined, flats?: boolean): string {\n  if (flats === undefined && hint !== undefined && noteToPitchClass(hint) === pc) {\n    return formatNote(hint);\n  }\n  const note = midiToNote(60 + pc, flats ? 'flat' : 'sharp');\n  return formatNote({ letter: note.letter, alter: note.alter });\n}\n\n/**\n * Format a {@link Chord} as a lead-sheet chord symbol.\n *\n * The inverse of {@link parseChordSymbol}: each quality maps to one canonical\n * suffix spelling, and a slash bass is appended only when it differs from the\n * root. When the chord carries `rootSpelling`/`bassSpelling` hints (as chords\n * from {@link parseChordSymbol} do) and no explicit `flats` preference is\n * given, the hints are reused so flat symbols round-trip unchanged.\n *\n * @param chord The chord to format.\n * @param opts Formatting options.\n * @param opts.flats Prefer flat spellings over sharps for altered roots/basses;\n *   passing either `true` or `false` overrides any spelling hints.\n * @returns The chord symbol text.\n * @example\n * ```ts\n * import { makeChord, formatChordSymbol } from '@libraz/libcantus';\n * formatChordSymbol(makeChord(0, 'min7')); // 'Cm7'\n * ```\n * @category Chords\n */\nexport function formatChordSymbol(chord: Chord, opts?: { flats?: boolean }): string {\n  const rootPc = pitchClass(chord.rootPc);\n  const rootName = pitchClassName(rootPc, chord.rootSpelling, opts?.flats);\n  const suffix = CANONICAL_SUFFIX[chord.quality];\n  let symbol = `${rootName}${suffix}`;\n  if (chord.bassPc !== undefined && pitchClass(chord.bassPc) !== rootPc) {\n    symbol += `/${pitchClassName(pitchClass(chord.bassPc), chord.bassSpelling, opts?.flats)}`;\n  }\n  return symbol;\n}\n\n/**\n * Transpose a chord symbol by a number of semitones.\n *\n * @param text The chord symbol text.\n * @param semitones Signed semitone offset to apply to the root and bass.\n * @param opts Formatting options for the result; see {@link formatChordSymbol}.\n * @returns The transposed chord symbol text.\n * @throws If `text` does not parse as a chord symbol.\n * @example\n * ```ts\n * import { transposeChordSymbol } from '@libraz/libcantus';\n * transposeChordSymbol('C/G', 2); // 'D/A'\n * ```\n * @category Chords\n */\nexport function transposeChordSymbol(\n  text: string,\n  semitones: number,\n  opts?: { flats?: boolean },\n): string {\n  const chord = parseChordSymbol(text);\n  const transposed: Chord = { ...chord, rootPc: pitchClass(chord.rootPc + semitones) };\n  if (chord.bassPc !== undefined) {\n    transposed.bassPc = pitchClass(chord.bassPc + semitones);\n  }\n  return formatChordSymbol(transposed, opts);\n}\n","import { isConsonantInterval } from '../../core/interval/index.js';\nimport type { KeyScale } from '../../core/types.js';\n\n/** Reduce a MIDI pitch (or pitch class) to a pitch class in [0, 11]. */\nfunction pitchClass(pitch: number): number {\n  return ((Math.trunc(pitch) % 12) + 12) % 12;\n}\n\n/**\n * Whether an upper voice has crossed below a lower voice.\n *\n * @param upperPitch Pitch of the nominally higher voice.\n * @param lowerPitch Pitch of the nominally lower voice.\n * @returns True when the upper voice sits below the lower voice.\n * @category Voicing & Counterpoint\n */\nexport function createsVoiceCrossing(upperPitch: number, lowerPitch: number): boolean {\n  return upperPitch < lowerPitch;\n}\n\n/**\n * Whether two simultaneous pitches form a dissonance.\n *\n * @param a First pitch.\n * @param b Second pitch.\n * @param twoVoice When true, the perfect fourth counts as dissonant.\n * @returns True when the vertical interval is dissonant.\n * @category Voicing & Counterpoint\n */\nexport function createsVerticalDissonance(a: number, b: number, twoVoice: boolean): boolean {\n  return !isConsonantInterval(a - b, twoVoice);\n}\n\n/**\n * Whether a melodic move is a forbidden leap: a tritone, either seventh (minor\n * or major), or any leap wider than an octave.\n *\n * Operates on the raw absolute distance, so compound leaps are not reduced to\n * their simple class before the octave check.\n *\n * @param prev Starting pitch.\n * @param cur Ending pitch.\n * @returns True when the leap is forbidden in strict counterpoint.\n * @category Voicing & Counterpoint\n */\nexport function isForbiddenMelodicLeap(prev: number, cur: number): boolean {\n  const semis = Math.abs(cur - prev);\n  return semis === 6 || semis === 10 || semis === 11 || semis > 12;\n}\n\n/** Reduce an interval to its simple class in [0, 11]. */\nfunction simpleClass(semitones: number): number {\n  return Math.abs(semitones) % 12;\n}\n\n/** Whether a simple interval class is a perfect kind (unison/octave or fifth). */\nfunction isPerfectClass(cls: number): boolean {\n  return cls === 0 || cls === 7;\n}\n\n/** Whether two voices move in the same direction (similar or parallel motion). */\nfunction similarMotion(aMove: number, bMove: number): boolean {\n  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;\n}\n\n/** Whether both voices actually move (neither is stationary — excludes oblique motion). */\nfunction bothVoicesMove(aMove: number, bMove: number): boolean {\n  return aMove !== 0 && bMove !== 0;\n}\n\n/**\n * Whether two voices move into consecutive perfect intervals of the same kind\n * (fifth-to-fifth, octave-to-octave, unison-to-unison).\n *\n * Both true parallels (similar motion) and anti-parallels — the same perfect\n * class reached by contrary motion, e.g. octave to octave with the voices moving\n * in opposite directions — are flagged, as both are forbidden in strict two-voice\n * counterpoint. The rule requires that both voices actually move: oblique motion\n * (either voice stationary) and the no-change case (identical pitches) are excluded.\n *\n * A fifth expanding to a twelfth counts (same perfect class); a fifth moving to\n * an octave does not (different perfect kinds — the direct/hidden case owned by\n * {@link createsHiddenParallelPerfect}).\n *\n * @category Voicing & Counterpoint\n */\nexport function createsParallelPerfect(\n  aPrev: number,\n  aCur: number,\n  bPrev: number,\n  bCur: number,\n): boolean {\n  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {\n    return false;\n  }\n  const nowClass = simpleClass(aCur - bCur);\n  const prevClass = simpleClass(aPrev - bPrev);\n  return isPerfectClass(nowClass) && nowClass === prevClass;\n}\n\n/**\n * Whether two voices move in consecutive parallel octaves (or unisons) by\n * similar motion.\n *\n * This is a strict subset of {@link createsParallelPerfect}: a similar-motion\n * octave-to-octave is the perfect-class-zero case that predicate already flags\n * (and it additionally catches the contrary-motion anti-parallel). Callers that\n * tally parallel violations should therefore use {@link createsParallelPerfect}\n * alone to avoid double counting; this predicate remains for callers wanting a\n * dedicated similar-motion octave test.\n *\n * @category Voicing & Counterpoint\n */\nexport function createsParallelOctave(\n  aPrev: number,\n  aCur: number,\n  bPrev: number,\n  bCur: number,\n): boolean {\n  if (!similarMotion(aCur - aPrev, bCur - bPrev)) {\n    return false;\n  }\n  return simpleClass(aCur - bCur) === 0 && simpleClass(aPrev - bPrev) === 0;\n}\n\n/**\n * Whether two voices move in consecutive parallel unisons — both landing on the\n * same pitch, having shared a pitch on the previous move.\n *\n * @category Voicing & Counterpoint\n */\nexport function createsParallelUnison(\n  aPrev: number,\n  aCur: number,\n  bPrev: number,\n  bCur: number,\n): boolean {\n  if (aCur === aPrev || bCur === bPrev) {\n    return false;\n  }\n  return aCur === bCur && aPrev === bPrev;\n}\n\n/**\n * Whether two voices reach a perfect interval by similar motion from an\n * imperfect one (a hidden/direct fifth or octave).\n *\n * The traditional step exception is applied: the approach is allowed when the\n * upper of the two voices moves by step, so only leaps into the perfect\n * interval are flagged.\n *\n * @category Voicing & Counterpoint\n */\nexport function createsHiddenParallelPerfect(\n  aPrev: number,\n  aCur: number,\n  bPrev: number,\n  bCur: number,\n): boolean {\n  const aMove = aCur - aPrev;\n  const bMove = bCur - bPrev;\n  if (!similarMotion(aMove, bMove)) {\n    return false;\n  }\n  const nowClass = simpleClass(aCur - bCur);\n  const prevClass = simpleClass(aPrev - bPrev);\n  // Approaching the same perfect class (e.g. fifth to fifth) is a true parallel\n  // owned by createsParallelPerfect; approaching a different perfect interval\n  // (fifth to octave, or vice versa) is the hidden/direct case flagged here.\n  if (!isPerfectClass(nowClass) || prevClass === nowClass) {\n    return false;\n  }\n  const upperMove = aCur >= bCur ? aMove : bMove;\n  if (Math.abs(upperMove) <= 2) {\n    return false; // upper voice moves by step — direct interval is acceptable\n  }\n  return true;\n}\n\n/**\n * Whether two voices overlap: the upper voice descends below where the lower\n * voice just was, or the lower voice rises above where the upper voice just was.\n * Distinct from a simultaneous voice crossing.\n *\n * @param upperPrev Previous pitch of the upper voice.\n * @param upperCur Current pitch of the upper voice.\n * @param lowerPrev Previous pitch of the lower voice.\n * @param lowerCur Current pitch of the lower voice.\n * @category Voicing & Counterpoint\n */\nexport function createsVoiceOverlap(\n  upperPrev: number,\n  upperCur: number,\n  lowerPrev: number,\n  lowerCur: number,\n): boolean {\n  return upperCur < lowerPrev || lowerCur > upperPrev;\n}\n\n/**\n * Whether two adjacent upper voices are spaced more than a maximum apart\n * (commonly an octave). Bass-to-tenor spacing is conventionally exempt, so this\n * is meant for the upper voice pairs.\n *\n * @param upperPitch Pitch of the higher voice.\n * @param lowerPitch Pitch of the lower voice.\n * @param maxSemitones Maximum allowed spacing in semitones (default an octave).\n * @category Voicing & Counterpoint\n */\nexport function exceedsSpacing(upperPitch: number, lowerPitch: number, maxSemitones = 12): boolean {\n  return Math.abs(upperPitch - lowerPitch) > maxSemitones;\n}\n\n/**\n * Whether a leading tone resolves correctly upward to the tonic.\n *\n * @param prev The leading-tone pitch.\n * @param cur The following pitch.\n * @param key Key context supplying the tonic.\n * @returns True when `prev` is the leading tone and `cur` is the tonic a step above.\n * @category Voicing & Counterpoint\n */\nexport function isLeadingToneResolution(prev: number, cur: number, key: KeyScale): boolean {\n  const tonic = pitchClass(key.rootPc);\n  const leading = (tonic + 11) % 12;\n  if (pitchClass(prev) !== leading || pitchClass(cur) !== tonic) {\n    return false;\n  }\n  return cur > prev && cur - prev <= 2;\n}\n","import type { Chord } from '../chord/index.js';\nimport { chordPitchClasses } from '../chord/index.js';\nimport {\n  createsParallelPerfect,\n  createsVoiceCrossing,\n  createsVoiceOverlap,\n  exceedsSpacing,\n} from '../counterpoint/index.js';\nimport type { VoiceRange } from './satb.js';\n\n/** Default maximum spacing between adjacent upper voices (one octave). */\nexport const DEFAULT_MAX_SPACING = 12;\n\n/** Score penalty per counterpoint violation between consecutive voicings. */\nexport const VIOLATION_PENALTY = 1000;\n/** Score penalty per chord tone absent from a voicing. */\nconst MISSING_TONE_PENALTY = 500;\n/** Score penalty per doubled tone that is neither the root nor the fifth. */\nconst POOR_DOUBLING_PENALTY = 4;\n/** Hard cap on candidate voicings evaluated per chord, keeping the search bounded. */\nconst MAX_CANDIDATES = 4000;\n\n/** Reduce a value to a pitch class in [0, 11]. */\nexport function pitchClass(value: number): number {\n  return ((Math.trunc(value) % 12) + 12) % 12;\n}\n\n/**\n * All MIDI pitches of a pitch class inside an inclusive range, ordered from the\n * centre of the range outward (ties break toward the lower pitch). Enumerating\n * centre-outward keeps the candidate set balanced around the register when it\n * is truncated at {@link MAX_CANDIDATES}, instead of skewing to the low octaves\n * that a plain ascending scan would visit first.\n */\nfunction pitchesForPc(pc: number, range: VoiceRange): number[] {\n  const result: number[] = [];\n  for (let midi = Math.ceil(range.min); midi <= range.max; midi += 1) {\n    if (pitchClass(midi) === pc) {\n      result.push(midi);\n    }\n  }\n  const center = (range.min + range.max) / 2;\n  return result.sort((a, b) => {\n    const da = Math.abs(a - center);\n    const db = Math.abs(b - center);\n    return da === db ? a - b : da - db;\n  });\n}\n\n/**\n * Enumerate candidate voicings for a chord: the bass takes the chord's bass\n * (or root) pitch class at each available octave, and each upper voice takes\n * any chord pitch class within its range. Candidates are built in ascending\n * voice order and pruned to exclude voice crossings and over-wide adjacent\n * spacing (the bass–tenor pair is allowed an extra octave, per convention).\n * Enumeration is deterministic and capped at {@link MAX_CANDIDATES}.\n */\nexport function enumerateVoicings(\n  chord: Chord,\n  ranges: VoiceRange[],\n  maxSpacing: number,\n): number[][] {\n  const chordPcs = chordPitchClasses(chord);\n  const bassPc = pitchClass(chord.bassPc ?? chord.rootPc);\n  const results: number[][] = [];\n  const current: number[] = [];\n  const build = (voice: number): void => {\n    if (results.length >= MAX_CANDIDATES) {\n      return;\n    }\n    if (voice === ranges.length) {\n      results.push([...current]);\n      return;\n    }\n    const range = ranges[voice];\n    if (range === undefined) {\n      return;\n    }\n    const pcs = voice === 0 ? [bassPc] : chordPcs;\n    const prev = current[voice - 1];\n    for (const pc of pcs) {\n      for (const pitch of pitchesForPc(pc, range)) {\n        if (prev !== undefined) {\n          if (pitch < prev) {\n            continue; // would cross below the next lower voice\n          }\n          const spacingLimit = voice === 1 ? maxSpacing + 12 : maxSpacing;\n          if (pitch - prev > spacingLimit) {\n            continue;\n          }\n        }\n        current.push(pitch);\n        build(voice + 1);\n        current.pop();\n      }\n    }\n  };\n  build(0);\n  return results;\n}\n\n/**\n * Structural quality penalty of a single voicing: heavily penalize missing\n * chord tones, mildly penalize doubling anything other than the root or fifth.\n */\nexport function structuralPenalty(pitches: number[], chord: Chord): number {\n  const counts = new Map<number, number>();\n  for (const pitch of pitches) {\n    const pc = pitchClass(pitch);\n    counts.set(pc, (counts.get(pc) ?? 0) + 1);\n  }\n  let penalty = 0;\n  for (const pc of chordPitchClasses(chord)) {\n    if (!counts.has(pc)) {\n      penalty += MISSING_TONE_PENALTY;\n    }\n  }\n  const rootPc = pitchClass(chord.rootPc);\n  const fifthPc = pitchClass(chord.rootPc + 7);\n  for (const [pc, count] of counts) {\n    if (count > 1 && pc !== rootPc && pc !== fifthPc) {\n      penalty += (count - 1) * POOR_DOUBLING_PENALTY;\n    }\n  }\n  return penalty;\n}\n\n/**\n * Count counterpoint violations between two consecutive voicings of equal\n * length: parallel perfects (fifths and octaves alike, since octaves are the\n * perfect-class-zero case of {@link createsParallelPerfect}) on every voice\n * pair, voice crossings in the new voicing, and — on adjacent pairs — voice\n * overlaps and over-wide spacing between upper voices.\n */\nexport function violationCount(prev: number[], cur: number[], maxSpacing: number): number {\n  let count = 0;\n  for (let lower = 0; lower < cur.length; lower += 1) {\n    for (let upper = lower + 1; upper < cur.length; upper += 1) {\n      const prevLower = prev[lower];\n      const prevUpper = prev[upper];\n      const curLower = cur[lower];\n      const curUpper = cur[upper];\n      if (\n        prevLower === undefined ||\n        prevUpper === undefined ||\n        curLower === undefined ||\n        curUpper === undefined\n      ) {\n        continue;\n      }\n      if (createsParallelPerfect(prevUpper, curUpper, prevLower, curLower)) {\n        count += 1;\n      }\n      if (createsVoiceCrossing(curUpper, curLower)) {\n        count += 1;\n      }\n      if (upper === lower + 1) {\n        if (createsVoiceOverlap(prevUpper, curUpper, prevLower, curLower)) {\n          count += 1;\n        }\n        if (lower > 0 && exceedsSpacing(curUpper, curLower, maxSpacing)) {\n          count += 1;\n        }\n      }\n    }\n  }\n  return count;\n}\n","import type { Chord } from '../chord/index.js';\nimport {\n  DEFAULT_MAX_SPACING,\n  enumerateVoicings,\n  structuralPenalty,\n  VIOLATION_PENALTY,\n  violationCount,\n} from './internal.js';\nimport { voiceLeadingCost } from './leading.js';\n\n/**\n * An inclusive MIDI pitch range for a single voice.\n *\n * @category Voicing & Counterpoint\n */\nexport type VoiceRange = {\n  min: number;\n  max: number;\n};\n\n/**\n * Default four-voice SATB ranges, ascending (index 0 = lowest):\n * bass E2–C4 (40–60), tenor C3–G4 (48–67), alto G3–D5 (55–74),\n * soprano C4–G5 (60–79).\n *\n * @category Voicing & Counterpoint\n */\nexport const SATB_RANGES: readonly VoiceRange[] = [\n  { min: 40, max: 60 },\n  { min: 48, max: 67 },\n  { min: 55, max: 74 },\n  { min: 60, max: 79 },\n];\n\n/**\n * Options controlling {@link voiceChord} and {@link voiceProgression}.\n *\n * @category Voicing & Counterpoint\n */\nexport type VoicingOptions = {\n  /**\n   * Number of voices to realize. Ignored when `ranges` is given.\n   *\n   * @defaultValue 4\n   */\n  voices?: number;\n  /** Explicit per-voice ranges, ascending (index 0 = lowest). Takes precedence over `voices`. */\n  ranges?: VoiceRange[];\n  /**\n   * Maximum spacing in semitones between adjacent upper voices.\n   *\n   * @defaultValue 12\n   */\n  maxSpacing?: number;\n};\n\n/** Overall pitch floor/ceiling used when deriving ranges for arbitrary voice counts. */\nconst DERIVED_LOW = 40;\nconst DERIVED_HIGH = 79;\n/** Span of each derived per-voice range in semitones. */\nconst DERIVED_SPAN = 19;\n\n/**\n * Resolve the per-voice ranges implied by the options: explicit `ranges` win,\n * four voices use {@link SATB_RANGES}, and other counts get evenly spaced\n * ranges spanning roughly the bass-to-soprano compass.\n */\nexport function resolveRanges(opts?: VoicingOptions): VoiceRange[] {\n  if (opts?.ranges !== undefined) {\n    if (opts.ranges.length === 0) {\n      throw new Error('ranges must contain at least one voice range');\n    }\n    return opts.ranges.map((range) => ({ ...range }));\n  }\n  const voices = opts?.voices ?? 4;\n  if (voices < 1) {\n    throw new Error('voices must be at least 1');\n  }\n  if (voices === 4) {\n    return SATB_RANGES.map((range) => ({ ...range }));\n  }\n  if (voices === 1) {\n    return [{ min: DERIVED_LOW, max: DERIVED_HIGH }];\n  }\n  const ranges: VoiceRange[] = [];\n  for (let i = 0; i < voices; i += 1) {\n    const min = Math.round(\n      DERIVED_LOW + (i * (DERIVED_HIGH - DERIVED_SPAN - DERIVED_LOW)) / (voices - 1),\n    );\n    ranges.push({ min, max: min + DERIVED_SPAN });\n  }\n  return ranges;\n}\n\n/**\n * Realize a single chord as one MIDI pitch per voice, ascending (index 0 =\n * lowest). The bass voice takes the chord's `bassPc` when set, otherwise the\n * root; upper voices take chord pitch classes, doubling the root or fifth as\n * needed to fill all voices. The result stays inside each voice's range, keeps\n * adjacent upper voices within `maxSpacing`, avoids voice crossing, and is\n * deterministic: a compact close-position voicing centered in the ranges.\n *\n * @param chord The chord to voice.\n * @param opts Voicing options; defaults to four voices in {@link SATB_RANGES}.\n * @returns MIDI pitches, ascending, one per voice.\n * @throws If no voicing fits the given ranges.\n * @example\n * ```ts\n * import { parseChordSymbol, voiceChord } from '@libraz/libcantus';\n * const chord = parseChordSymbol('Cmaj7');\n * voiceChord(chord); // four ascending MIDI pitches within the SATB ranges\n * ```\n * @category Voicing & Counterpoint\n */\nexport function voiceChord(chord: Chord, opts?: VoicingOptions): number[] {\n  const ranges = resolveRanges(opts);\n  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;\n  const candidates = enumerateVoicings(chord, ranges, maxSpacing);\n  let best: number[] | undefined;\n  let bestScore = Number.POSITIVE_INFINITY;\n  for (const candidate of candidates) {\n    let score = structuralPenalty(candidate, chord);\n    for (let i = 0; i < candidate.length; i += 1) {\n      const pitch = candidate[i];\n      const range = ranges[i];\n      if (pitch === undefined || range === undefined) {\n        continue;\n      }\n      // Prefer pitches near the middle of each voice's range for a centered,\n      // compact default voicing.\n      score += Math.abs(pitch - (range.min + range.max) / 2);\n    }\n    if (score < bestScore) {\n      bestScore = score;\n      best = candidate;\n    }\n  }\n  if (best === undefined) {\n    throw new Error('no voicing satisfies the given ranges');\n  }\n  return best;\n}\n\n/**\n * Voice a chord progression with smooth voice leading. The first chord is\n * voiced with {@link voiceChord}; each subsequent chord picks, from a bounded\n * deterministic candidate set, the voicing minimizing the voice-leading cost\n * from the previous voicing plus a large penalty per counterpoint violation\n * (parallel perfects/octaves, voice crossing, voice overlap, and over-wide\n * upper-voice spacing).\n *\n * @param chords The chords to voice in order.\n * @param opts Voicing options; defaults to four voices in {@link SATB_RANGES}.\n * @returns One voicing per chord, each ascending with one MIDI pitch per voice.\n * @throws If any chord admits no voicing within the given ranges.\n * @example\n * ```ts\n * import { parseChordSymbol, voiceProgression } from '@libraz/libcantus';\n * const chords = ['C', 'Am', 'F', 'G'].map((s) => parseChordSymbol(s));\n * voiceProgression(chords); // one four-voice voicing per chord, smoothly led\n * ```\n * @category Voicing & Counterpoint\n */\nexport function voiceProgression(chords: Chord[], opts?: VoicingOptions): number[][] {\n  const ranges = resolveRanges(opts);\n  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;\n  const result: number[][] = [];\n  let prev: number[] | undefined;\n  for (const chord of chords) {\n    if (prev === undefined) {\n      prev = voiceChord(chord, opts);\n      result.push(prev);\n      continue;\n    }\n    const candidates = enumerateVoicings(chord, ranges, maxSpacing);\n    let best: number[] | undefined;\n    let bestScore = Number.POSITIVE_INFINITY;\n    for (const candidate of candidates) {\n      const score =\n        structuralPenalty(candidate, chord) +\n        voiceLeadingCost(prev, candidate) +\n        VIOLATION_PENALTY * violationCount(prev, candidate, maxSpacing);\n      if (score < bestScore) {\n        bestScore = score;\n        best = candidate;\n      }\n    }\n    if (best === undefined) {\n      throw new Error('no voicing satisfies the given ranges');\n    }\n    result.push(best);\n    prev = best;\n  }\n  return result;\n}\n","import type { Chord } from '../chord/index.js';\nimport { createsHiddenParallelPerfect } from '../counterpoint/index.js';\nimport {\n  DEFAULT_MAX_SPACING,\n  enumerateVoicings,\n  structuralPenalty,\n  VIOLATION_PENALTY,\n  violationCount,\n} from './internal.js';\nimport type { VoicingOptions } from './satb.js';\nimport { resolveRanges } from './satb.js';\n\n/**\n * Moderate penalty for a hidden/direct perfect fifth or octave reached on the\n * outer-voice (bass–soprano) pair. Unlike a true parallel perfect it is\n * discouraged rather than forbidden, so the weight sits alongside voice-leading\n * motion rather than the hard {@link VIOLATION_PENALTY}.\n */\nconst HIDDEN_PERFECT_PENALTY = 6;\n\n/**\n * Total voice-leading cost between two voicings: the sum of absolute semitone\n * motion across voices, plus a moderate {@link HIDDEN_PERFECT_PENALTY} when the\n * outer-voice (bass–soprano) pair reaches a hidden/direct perfect fifth or\n * octave by similar motion. The arrays must be the same length; when they\n * differ the voicings are not comparable and the cost is `Infinity`.\n *\n * @param from The previous voicing, one MIDI pitch per voice.\n * @param to The next voicing, one MIDI pitch per voice.\n * @returns The summed absolute motion (plus any hidden-perfect penalty), or\n *   `Infinity` when lengths differ.\n * @category Voicing & Counterpoint\n */\nexport function voiceLeadingCost(from: number[], to: number[]): number {\n  if (from.length !== to.length) {\n    return Number.POSITIVE_INFINITY;\n  }\n  let total = 0;\n  for (let i = 0; i < from.length; i += 1) {\n    const a = from[i];\n    const b = to[i];\n    if (a === undefined || b === undefined) {\n      continue;\n    }\n    total += Math.abs(b - a);\n  }\n  // Discourage hidden/direct perfects between the outermost voices, where they\n  // are most audible. True parallels are handled (and forbidden) elsewhere.\n  if (from.length >= 2) {\n    const bassPrev = from[0];\n    const bassCur = to[0];\n    const sopPrev = from[from.length - 1];\n    const sopCur = to[to.length - 1];\n    if (\n      bassPrev !== undefined &&\n      bassCur !== undefined &&\n      sopPrev !== undefined &&\n      sopCur !== undefined &&\n      createsHiddenParallelPerfect(bassPrev, bassCur, sopPrev, sopCur)\n    ) {\n      total += HIDDEN_PERFECT_PENALTY;\n    }\n  }\n  return total;\n}\n\n/**\n * Voice a single chord to follow smoothly from an arbitrary current voicing.\n *\n * Candidate voicings of `chord` are enumerated within ranges taken from `opts`,\n * or — when neither `voices` nor `ranges` is given — from a one-octave window\n * around each pitch of `current` (so the result matches `current`'s voice\n * count). Each candidate is scored by structural quality, voice-leading motion\n * from `current`, and a large penalty per counterpoint violation; the lowest\n * scoring candidate is returned, ascending.\n *\n * @param current The current voicing to lead from, ascending (index 0 = lowest).\n * @param chord The next chord to voice.\n * @param opts Voicing options; when omitted, ranges follow `current`'s span.\n * @returns The chosen voicing, ascending with one MIDI pitch per voice.\n * @throws If no voicing fits the derived ranges.\n * @category Voicing & Counterpoint\n */\nexport function nextVoicing(current: number[], chord: Chord, opts?: VoicingOptions): number[] {\n  const ranges =\n    opts?.ranges !== undefined || opts?.voices !== undefined\n      ? resolveRanges(opts)\n      : current.map((pitch) => {\n          // Window one octave around each current pitch, clamped so extreme-low\n          // or extreme-high input can never yield MIDI outside [0, 127].\n          const centre = Math.min(127, Math.max(0, pitch));\n          return { min: Math.max(0, centre - 12), max: Math.min(127, centre + 12) };\n        });\n  const maxSpacing = opts?.maxSpacing ?? DEFAULT_MAX_SPACING;\n  const candidates = enumerateVoicings(chord, ranges, maxSpacing);\n  let best: number[] | undefined;\n  let bestScore = Number.POSITIVE_INFINITY;\n  for (const candidate of candidates) {\n    const score =\n      structuralPenalty(candidate, chord) +\n      voiceLeadingCost(current, candidate) +\n      VIOLATION_PENALTY * violationCount(current, candidate, maxSpacing);\n    if (score < bestScore) {\n      bestScore = score;\n      best = candidate;\n    }\n  }\n  if (best === undefined) {\n    throw new Error('no voicing satisfies the given ranges');\n  }\n  return best;\n}\n","import type { Chord } from '../chord/index.js';\nimport { chordToneRole } from '../chord/index.js';\nimport { pitchClass } from './internal.js';\n\n/**\n * A tertian voicing style for {@link voiceChordStyled}.\n *\n * - `close`: the plain close-position tertian stack.\n * - `drop2`: the second voice from the top dropped an octave (drop-2 voicing).\n * - `drop3`: the third voice from the top dropped an octave (drop-3 voicing).\n * - `shell`: root plus guide tones (third and seventh) for seventh chords, or\n *   root/third/fifth for triads; the fifth and tensions are omitted.\n * - `rootless`: the root omitted, keeping third/fifth/seventh and tensions\n *   (a typical left-hand jazz voicing).\n *\n * @category Voicing & Counterpoint\n */\nexport type VoicingStyle = 'close' | 'drop2' | 'drop3' | 'shell' | 'rootless';\n\n/**\n * Options controlling {@link voiceChordStyled}.\n *\n * @category Voicing & Counterpoint\n */\nexport type StyledVoicingOptions = {\n  /**\n   * Voicing style to build.\n   *\n   * @defaultValue 'close'\n   */\n  style?: VoicingStyle;\n  /** Constrain the highest voice to this pitch class (0..11) when given. */\n  topNote?: number;\n  /**\n   * Base octave for the close stack; the stack begins near `12 * octave`.\n   *\n   * @defaultValue 4\n   */\n  octave?: number;\n  /**\n   * Omit the root regardless of style (relevant for jazz voicings).\n   *\n   * @defaultValue false\n   */\n  rootless?: boolean;\n};\n\n/** Default base octave for a styled close-position stack. */\nconst DEFAULT_STYLE_OCTAVE = 4;\n\n/** Return the pitch classes of a list in order, without duplicates. */\nfunction dedupePcs(pcs: number[]): number[] {\n  const seen = new Set<number>();\n  const result: number[] = [];\n  for (const pc of pcs) {\n    if (!seen.has(pc)) {\n      seen.add(pc);\n      result.push(pc);\n    }\n  }\n  return result;\n}\n\n/** The lowest MIDI pitch of a pitch class at or above a floor. */\nfunction lowestPitchAtOrAbove(pc: number, floor: number): number {\n  return floor + ((((pc - pitchClass(floor)) % 12) + 12) % 12);\n}\n\n/** The pitch class in `pcs` whose circular distance to `target` is smallest. */\nfunction nearestPc(target: number, pcs: number[]): number {\n  let best = pcs[0] ?? target;\n  let bestDist = 12;\n  for (const pc of pcs) {\n    const dist = Math.min((((pc - target) % 12) + 12) % 12, (((target - pc) % 12) + 12) % 12);\n    if (dist < bestDist) {\n      bestDist = dist;\n      best = pc;\n    }\n  }\n  return best;\n}\n\n/**\n * Realize a single chord as an explicit tertian voicing in a chosen style,\n * independent of the SATB range search used by {@link voiceChord}.\n *\n * The chord tones are stacked in close position from the bass (`bassPc`, else\n * `rootPc`) in the given scientific-pitch `octave` upward (octave 4 starts the\n * bass near C4 = MIDI 60, matching {@link midiToNote} and the bass module).\n * When `topNote` is given the stack is rotated so the highest voice's pitch\n * class equals that note (or the nearest chord tone). The chosen\n * {@link VoicingStyle} then transforms the stack, and the result is returned as\n * ascending MIDI pitches (index 0 = lowest).\n *\n * @param chord The chord to voice.\n * @param opts Styled voicing options; defaults to a close voicing at octave 4.\n * @returns MIDI pitches, ascending, one per retained voice.\n * @example\n * ```ts\n * import { parseChordSymbol, voiceChordStyled } from '@libraz/libcantus';\n * const chord = parseChordSymbol('Dm7');\n * voiceChordStyled(chord, { style: 'drop2' }); // ascending MIDI pitches, drop-2 voicing\n * ```\n * @category Voicing & Counterpoint\n */\nexport function voiceChordStyled(chord: Chord, opts?: StyledVoicingOptions): number[] {\n  const style = opts?.style ?? 'close';\n  const base = 12 * ((opts?.octave ?? DEFAULT_STYLE_OCTAVE) + 1);\n  const rootPc = pitchClass(chord.rootPc);\n  const bassPc = pitchClass(chord.bassPc ?? chord.rootPc);\n  const omitRoot = style === 'rootless' || opts?.rootless === true;\n\n  // Tertian chord tones in order, with the bass tone rotated to the bottom.\n  let order = dedupePcs(chord.intervals.map((interval) => pitchClass(chord.rootPc + interval)));\n  const bassIndex = order.indexOf(bassPc);\n  if (bassIndex > 0) {\n    order = [...order.slice(bassIndex), ...order.slice(0, bassIndex)];\n  } else if (bassIndex < 0) {\n    order = [bassPc, ...order];\n  }\n\n  if (style === 'shell') {\n    const roles = order.map((pc) => chordToneRole(pc, chord));\n    // The guide tone is the seventh when present; on a sixth chord the sixth\n    // stands in for it, and otherwise the voicing falls back to the fifth.\n    const guide = roles.includes('seventh')\n      ? 'seventh'\n      : roles.includes('sixth')\n        ? 'sixth'\n        : 'fifth';\n    order = order.filter((_pc, i) => {\n      const role = roles[i];\n      return role === 'root' || role === 'third' || role === guide;\n    });\n  }\n\n  if (omitRoot) {\n    order = order.filter((pc) => pc !== rootPc);\n  }\n\n  if (order.length === 0) {\n    return [];\n  }\n\n  if (opts?.topNote !== undefined) {\n    const target = order.includes(pitchClass(opts.topNote))\n      ? pitchClass(opts.topNote)\n      : nearestPc(pitchClass(opts.topNote), order);\n    const targetIndex = order.indexOf(target);\n    order = [...order.slice(targetIndex + 1), ...order.slice(0, targetIndex + 1)];\n  }\n\n  // Stack the ordered pitch classes upward in close position.\n  const stack: number[] = [];\n  let prev: number | undefined;\n  for (const pc of order) {\n    if (prev === undefined) {\n      prev = lowestPitchAtOrAbove(pc, base);\n    } else {\n      let delta = (((pc - pitchClass(prev)) % 12) + 12) % 12;\n      if (delta === 0) {\n        delta = 12;\n      }\n      prev += delta;\n    }\n    stack.push(prev);\n  }\n\n  if (style === 'drop2' && stack.length >= 2) {\n    stack[stack.length - 2] = (stack[stack.length - 2] ?? 0) - 12;\n  } else if (style === 'drop3' && stack.length >= 3) {\n    stack[stack.length - 3] = (stack[stack.length - 3] ?? 0) - 12;\n  }\n\n  return stack.sort((a, b) => a - b);\n}\n","import { midiToNote, type Note as NoteData } from '../core/pitch/index.js';\n\n/** Reduce any integer to a pitch class in [0, 11]. */\nexport function mod12(n: number): number {\n  return ((n % 12) + 12) % 12;\n}\n\n/** Spell a bare pitch class as an octave-less note with a sharp/flat preference. */\nexport function spellPitchClassBare(pc: number, spelling: 'sharp' | 'flat'): NoteData {\n  const spelled = midiToNote(60 + mod12(pc), spelling);\n  return { letter: spelled.letter, alter: spelled.alter };\n}\n","import {\n  formatNote,\n  midiToNote,\n  type Note as NoteData,\n  noteToMidi,\n  noteToPitchClass,\n  parseNote,\n  type SpelledInterval,\n  spelledInterval,\n} from '../core/pitch/index.js';\nimport { spellPitchClassBare } from './shared.js';\n\n/** Defensive copy of a plain note. */\nfunction copyNote(data: NoteData): NoteData {\n  const copy: NoteData = { letter: data.letter, alter: data.alter };\n  if (data.octave !== undefined) {\n    copy.octave = data.octave;\n  }\n  return copy;\n}\n\n/**\n * An immutable spelled note: a diatonic letter plus a chromatic alteration and\n * an optional octave. Wraps the plain note object and delegates to the pitch\n * module; every transformation returns a new instance.\n *\n * @category Class API\n * @example\n * ```ts\n * import { Note } from '@libraz/libcantus';\n * Note.of('C4').transpose(7).name; // 'G4'\n * ```\n */\nexport class Note {\n  readonly #data: NoteData;\n\n  /**\n   * Wrap a plain note object.\n   *\n   * @param data The spelled note; it is copied, never retained or mutated.\n   */\n  constructor(data: NoteData) {\n    this.#data = copyNote(data);\n  }\n\n  /**\n   * Parse scientific pitch notation (e.g. `'C#4'`, `'Bb'`, `'F##3'`).\n   *\n   * @param name The note text.\n   * @returns The parsed note.\n   * @throws If the text is not a valid note.\n   */\n  static of(name: string): Note {\n    return new Note(parseNote(name));\n  }\n\n  /**\n   * Name a MIDI number (middle C = C4 = 60) as a note.\n   *\n   * @param midi The MIDI number.\n   * @param spelling Whether to prefer sharps or flats for black keys.\n   * @returns The spelled note, with octave.\n   */\n  static fromMidi(midi: number, spelling: 'sharp' | 'flat' = 'sharp'): Note {\n    return new Note(midiToNote(midi, spelling));\n  }\n\n  /**\n   * Wrap an existing plain note object.\n   *\n   * @param data The plain note.\n   * @returns The wrapped note.\n   */\n  static fromData(data: NoteData): Note {\n    return new Note(data);\n  }\n\n  /** The note rendered as scientific pitch notation, e.g. `'G4'` or `'Bb'`. */\n  get name(): string {\n    return formatNote(this.#data);\n  }\n\n  /** The pitch class (0..11), ignoring octave. */\n  get pitchClass(): number {\n    return noteToPitchClass(this.#data);\n  }\n\n  /**\n   * The MIDI number (middle C = C4 = 60).\n   *\n   * @throws If the note has no octave and therefore no fixed pitch.\n   */\n  get midi(): number {\n    if (this.#data.octave === undefined) {\n      throw new Error(`note ${this.name} has no octave, so it has no MIDI number`);\n    }\n    return noteToMidi(this.#data);\n  }\n\n  /** The diatonic letter number: 0..6 for C..B. */\n  get letter(): number {\n    return this.#data.letter;\n  }\n\n  /** The chromatic alteration in semitones: -1 flat, 0 natural, +1 sharp, ... */\n  get alter(): number {\n    return this.#data.alter;\n  }\n\n  /** The octave (scientific pitch notation), or undefined for a bare pitch class. */\n  get octave(): number | undefined {\n    return this.#data.octave;\n  }\n\n  /** A copy of the underlying plain note object. */\n  get data(): NoteData {\n    return copyNote(this.#data);\n  }\n\n  /**\n   * Transpose by a signed number of semitones.\n   *\n   * When the note carries an octave the transposition happens in MIDI space and\n   * the result is spelled with a sharp preference. An octave-less note stays\n   * octave-less: only its pitch class is moved. Transposing by zero is the\n   * identity: the original spelling is preserved (no enharmonic respelling).\n   *\n   * @param semitones The signed semitone offset.\n   * @returns The transposed note.\n   */\n  transpose(semitones: number): Note {\n    if (semitones === 0) {\n      return new Note(this.#data);\n    }\n    if (this.#data.octave !== undefined) {\n      return Note.fromMidi(this.midi + semitones);\n    }\n    return new Note(spellPitchClassBare(this.pitchClass + semitones, 'sharp'));\n  }\n\n  /**\n   * The spelled interval from this note to another.\n   *\n   * @param other The second note.\n   * @returns The diatonic number, quality, and semitone span.\n   */\n  intervalTo(other: Note): SpelledInterval {\n    return spelledInterval(this.#data, other.#data);\n  }\n\n  /**\n   * Whether another note has the same letter, alteration, and octave.\n   *\n   * @param other The note to compare.\n   * @returns True if the spellings are identical.\n   */\n  equals(other: Note): boolean {\n    return (\n      this.#data.letter === other.#data.letter &&\n      this.#data.alter === other.#data.alter &&\n      this.#data.octave === other.#data.octave\n    );\n  }\n\n  /**\n   * The plain note data, for JSON serialization.\n   *\n   * Private class fields do not serialize, so an explicit `toJSON` keeps\n   * `JSON.stringify(note)` from collapsing to `{}`.\n   *\n   * @returns A copy of the underlying plain note object.\n   */\n  toJSON(): NoteData {\n    return this.data;\n  }\n}\n","import {\n  type Cadence,\n  type ChordAnalysis,\n  detectCadence,\n  type HarmonicFunction,\n} from '../analyze/functional/index.js';\nimport type { Note as NoteData } from '../core/pitch/index.js';\nimport type { KeyScale } from '../core/types.js';\nimport type { Chord as ChordData } from '../theory/chord/index.js';\nimport { type VoicingOptions, voiceProgression } from '../theory/voicing/index.js';\nimport type { Chord } from './chord.js';\nimport type { Key } from './key.js';\n\n/**\n * An immutable ordered sequence of chords, optionally carrying a {@link Key}\n * context shared by its analysis methods.\n *\n * @category Class API\n * @example\n * ```ts\n * import { Key } from '@libraz/libcantus';\n * const key = Key.major('C');\n * key.chord(1).progressionTo(key.chord(4), key.chord(0)).roman();\n * // ['ii', 'V', 'I']\n * ```\n */\nexport class Progression {\n  readonly #chords: readonly Chord[];\n  readonly #key: Key | undefined;\n\n  /**\n   * Wrap a chord sequence.\n   *\n   * @param chords The chords in order; the array is copied.\n   * @param key Optional key context for analysis methods.\n   */\n  constructor(chords: readonly Chord[], key?: Key) {\n    this.#chords = [...chords];\n    this.#key = key;\n  }\n\n  /** A copy of the chord sequence. */\n  get chords(): readonly Chord[] {\n    return [...this.#chords];\n  }\n\n  /** The carried key context, if any. */\n  get key(): Key | undefined {\n    return this.#key;\n  }\n\n  /** The number of chords. */\n  get length(): number {\n    return this.#chords.length;\n  }\n\n  /**\n   * A copy of this progression with a chord appended.\n   *\n   * @param chord The chord to append.\n   * @returns The new progression.\n   */\n  add(chord: Chord): Progression {\n    return new Progression([...this.#chords, chord], this.#key);\n  }\n\n  /**\n   * A copy of this progression carrying the given key context.\n   *\n   * @param key The key context to attach.\n   * @returns The new progression.\n   */\n  withKey(key: Key): Progression {\n    return new Progression(this.#chords, key);\n  }\n\n  /**\n   * Voice the progression with smooth voice leading.\n   *\n   * @param opts Voicing options; defaults to four SATB voices.\n   * @returns One ascending voicing (MIDI pitches) per chord.\n   * @throws If any chord admits no voicing within the given ranges.\n   */\n  voice(opts?: VoicingOptions): number[][] {\n    return voiceProgression(\n      this.#chords.map((chord) => chord.data),\n      opts,\n    );\n  }\n\n  /**\n   * The Roman numeral of each chord in a key.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns One numeral per chord.\n   * @throws If no key is given and none is carried.\n   */\n  roman(key?: Key): string[] {\n    const resolved = this.#resolveKey(key);\n    return this.#chords.map((chord) => chord.roman(resolved));\n  }\n\n  /**\n   * The harmonic function of each chord in a key.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns One function per chord.\n   * @throws If no key is given and none is carried.\n   */\n  functions(key?: Key): HarmonicFunction[] {\n    const resolved = this.#resolveKey(key);\n    return this.#chords.map((chord) => chord.function(resolved));\n  }\n\n  /**\n   * Analyze every chord and classify the closing cadence.\n   *\n   * The cadence is detected on the final chord pair and is null when the\n   * progression has fewer than two chords.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns Per-chord analyses and the closing cadence.\n   * @throws If no key is given and none is carried.\n   */\n  analyze(key?: Key): { chords: ChordAnalysis[]; cadence: Cadence } {\n    const resolved = this.#resolveKey(key);\n    const chords = this.#chords.map((chord) => chord.analyze(resolved));\n    const from = this.#chords[this.#chords.length - 2];\n    const to = this.#chords[this.#chords.length - 1];\n    const cadence =\n      from !== undefined && to !== undefined\n        ? detectCadence(from.data, to.data, resolved.scale)\n        : null;\n    return { chords, cadence };\n  }\n\n  /**\n   * The plain progression data, for JSON serialization.\n   *\n   * Private class fields do not serialize, so an explicit `toJSON` keeps\n   * `JSON.stringify(progression)` from collapsing to `{}`. The chords are\n   * emitted as plain data and the carried key, when present, as its own data.\n   *\n   * @returns The chord data sequence and the carried key, if any.\n   */\n  toJSON(): { chords: ChordData[]; key: { scale: KeyScale; tonic: NoteData } | undefined } {\n    return {\n      chords: this.#chords.map((chord) => chord.data),\n      key: this.#key?.toJSON(),\n    };\n  }\n\n  /** Resolve the key for an analysis method: explicit first, then carried. */\n  #resolveKey(key?: Key): Key {\n    const resolved = key ?? this.#key;\n    if (resolved === undefined) {\n      throw new Error('progression has no key context; pass a Key or attach one with withKey()');\n    }\n    return resolved;\n  }\n}\n","import { detectChord, detectChordBest } from '../analyze/detect/index.js';\nimport {\n  analyzeChord,\n  type BorrowedSource,\n  borrowedSource,\n  type ChordAnalysis,\n  chordToRoman,\n  functionOf,\n  type HarmonicFunction,\n  isBorrowedChord,\n} from '../analyze/functional/index.js';\nimport { negativeHarmonyMirror } from '../generate/reharmony/index.js';\nimport {\n  type Chord as ChordData,\n  type ChordQuality,\n  chordPitchClasses,\n  makeChord,\n} from '../theory/chord/index.js';\nimport {\n  availableTensions,\n  avoidNotes,\n  type ChordScaleMatch,\n  chordScales,\n} from '../theory/chordscale/index.js';\nimport { spellChord } from '../theory/spelling/index.js';\nimport { formatChordSymbol, parseChordSymbol } from '../theory/symbol/index.js';\nimport {\n  type StyledVoicingOptions,\n  type VoicingOptions,\n  voiceChord,\n  voiceChordStyled,\n} from '../theory/voicing/index.js';\nimport type { Key } from './key.js';\nimport { Note } from './note.js';\nimport { Progression } from './progression.js';\nimport { mod12 } from './shared.js';\n\n/**\n * Defensive copy of a plain chord.\n *\n * Any enharmonic spelling hints (`rootSpelling`/`bassSpelling`, populated by\n * `parseChordSymbol`) are carried through so a flat-named chord round-trips\n * through the class API; a hint that no longer matches its pitch class is\n * simply ignored by the formatter.\n */\nfunction copyChord(data: ChordData): ChordData {\n  const copy: ChordData = {\n    rootPc: data.rootPc,\n    quality: data.quality,\n    intervals: [...data.intervals],\n  };\n  if (data.bassPc !== undefined) {\n    copy.bassPc = data.bassPc;\n  }\n  if (data.rootSpelling !== undefined) {\n    copy.rootSpelling = { letter: data.rootSpelling.letter, alter: data.rootSpelling.alter };\n  }\n  if (data.bassSpelling !== undefined) {\n    copy.bassSpelling = { letter: data.bassSpelling.letter, alter: data.bassSpelling.alter };\n  }\n  return copy;\n}\n\n/**\n * An immutable chord: a root pitch class, quality, interval template, and\n * optional slash bass, optionally carrying a {@link Key} context. Analysis\n * methods (`roman`, `function`, `analyze`, ...) use an explicitly passed key\n * first and fall back to the carried context.\n *\n * @category Class API\n * @example\n * ```ts\n * import { Chord } from '@libraz/libcantus';\n * Chord.parse('Cmaj7').invert(1).symbol(); // 'Cmaj7/E' (third in the bass)\n * ```\n */\nexport class Chord {\n  readonly #data: ChordData;\n  readonly #key: Key | undefined;\n\n  /**\n   * Wrap a plain chord object.\n   *\n   * @param data The chord; it is copied, never retained or mutated.\n   * @param key Optional key context for analysis methods.\n   */\n  constructor(data: ChordData, key?: Key) {\n    this.#data = copyChord(data);\n    this.#key = key;\n  }\n\n  /**\n   * Build a chord from a root and quality.\n   *\n   * @param root Root as a note name (e.g. `'Eb'`) or a pitch class.\n   * @param quality The chord quality.\n   * @param bass Optional slash-chord bass pitch class.\n   * @returns The chord (without key context).\n   */\n  static of(root: string | number, quality: ChordQuality, bass?: number): Chord {\n    const rootPc = typeof root === 'string' ? Note.of(root).pitchClass : root;\n    return new Chord(makeChord(rootPc, quality, bass));\n  }\n\n  /**\n   * Wrap an existing plain chord object.\n   *\n   * @param data The plain chord.\n   * @returns The wrapped chord (without key context).\n   */\n  static from(data: ChordData): Chord {\n    return new Chord(data);\n  }\n\n  /**\n   * Parse a lead-sheet chord symbol (e.g. `'Cmaj7'`, `'F#m7b5'`, `'C/G'`).\n   *\n   * @param symbol The chord symbol.\n   * @returns The chord (without key context).\n   * @throws If the root or quality is not recognized.\n   */\n  static parse(symbol: string): Chord {\n    return new Chord(parseChordSymbol(symbol));\n  }\n\n  /**\n   * Identify the chords matching a set of pitches, best interpretation first.\n   *\n   * @param pitches MIDI pitches or bare pitch classes.\n   * @returns Ranked chord interpretations (may be empty).\n   */\n  static detect(pitches: number[]): Chord[] {\n    return detectChord(pitches).map(\n      (match) => new Chord(makeChord(match.rootPc, match.quality, match.bassPc)),\n    );\n  }\n\n  /**\n   * The single best chord interpretation of a pitch set.\n   *\n   * @param pitches MIDI pitches or bare pitch classes.\n   * @returns The top-ranked chord, or null when nothing matches.\n   */\n  static detectBest(pitches: number[]): Chord | null {\n    const best = detectChordBest(pitches);\n    return best === null ? null : new Chord(best);\n  }\n\n  /** The root pitch class (0..11). */\n  get rootPc(): number {\n    return this.#data.rootPc;\n  }\n\n  /** The chord quality. */\n  get quality(): ChordQuality {\n    return this.#data.quality;\n  }\n\n  /** A copy of the semitone offsets above the root. */\n  get intervals(): number[] {\n    return [...this.#data.intervals];\n  }\n\n  /** The slash-chord bass pitch class, or undefined in root position. */\n  get bassPc(): number | undefined {\n    return this.#data.bassPc;\n  }\n\n  /** A copy of the underlying plain chord object. */\n  get data(): ChordData {\n    return copyChord(this.#data);\n  }\n\n  /** The carried key context, if any. */\n  get key(): Key | undefined {\n    return this.#key;\n  }\n\n  /**\n   * A copy of this chord carrying the given key context.\n   *\n   * @param key The key context to attach.\n   * @returns The new chord.\n   */\n  withKey(key: Key): Chord {\n    return new Chord(this.#data, key);\n  }\n\n  /**\n   * The chord's sorted, deduplicated pitch classes.\n   *\n   * @returns Pitch classes ascending in [0, 11].\n   */\n  pitchClasses(): number[] {\n    return chordPitchClasses(this.#data);\n  }\n\n  /**\n   * The chord's Roman numeral in a key.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns The Roman numeral string.\n   * @throws If no key is given and none is carried.\n   */\n  roman(key?: Key): string {\n    return chordToRoman(this.#data, this.#resolveKey(key).scale);\n  }\n\n  /**\n   * The chord's harmonic function (tonic / subdominant / dominant) in a key.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns The harmonic function.\n   * @throws If no key is given and none is carried.\n   */\n  function(key?: Key): HarmonicFunction {\n    return functionOf(this.#data, this.#resolveKey(key).scale);\n  }\n\n  /**\n   * Full functional analysis: function, borrowing, and Roman numeral.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns The chord analysis.\n   * @throws If no key is given and none is carried.\n   */\n  analyze(key?: Key): ChordAnalysis {\n    return analyzeChord(this.#data, this.#resolveKey(key).scale);\n  }\n\n  /**\n   * Whether the chord is borrowed from the parallel mode (modal interchange).\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns True if the chord is borrowed.\n   * @throws If no key is given and none is carried.\n   */\n  isBorrowed(key?: Key): boolean {\n    return isBorrowedChord(this.#data, this.#resolveKey(key).scale);\n  }\n\n  /**\n   * The origin of a non-diatonic chord (parallel mode or Neapolitan), or null.\n   *\n   * @param key Key to analyze in; falls back to the carried context.\n   * @returns The borrowing source, or null.\n   * @throws If no key is given and none is carried.\n   */\n  borrowedSource(key?: Key): BorrowedSource {\n    return borrowedSource(this.#data, this.#resolveKey(key).scale);\n  }\n\n  /**\n   * The chord rendered as a lead-sheet symbol (e.g. `'Cmaj7'`, `'F#m7'`, `'C/G'`).\n   *\n   * @param opts Set `flats: true` to spell the root/bass with flats.\n   * @returns The chord symbol.\n   */\n  symbol(opts?: { flats?: boolean }): string {\n    return formatChordSymbol(this.#data, opts);\n  }\n\n  /**\n   * Realize the chord as one MIDI pitch per voice, ascending.\n   *\n   * @param opts Voicing options; defaults to four SATB voices.\n   * @returns MIDI pitches, ascending, one per voice.\n   * @throws If no voicing fits the given ranges.\n   */\n  voice(opts?: VoicingOptions): number[] {\n    return voiceChord(this.#data, opts);\n  }\n\n  /**\n   * Realize the chord as a single styled voicing (`close`, `drop2`, `drop3`,\n   * `shell`, or `rootless`), optionally constraining the top voice.\n   *\n   * @param opts Styled-voicing options; defaults to a close-position voicing.\n   * @returns MIDI pitches, ascending.\n   */\n  styledVoicing(opts?: StyledVoicingOptions): number[] {\n    return voiceChordStyled(this.#data, opts);\n  }\n\n  /**\n   * The negative-harmony mirror of the chord about the key's tonic–dominant\n   * axis (major becomes minor and vice versa).\n   *\n   * @param key Key providing the reflection axis; falls back to the carried\n   *   context.\n   * @returns The mirrored chord, keeping any key context.\n   * @throws If no key is given and none is carried.\n   */\n  negativeHarmony(key?: Key): Chord {\n    const resolved = this.#resolveKey(key);\n    // Retain the key that anchored the reflection (explicit first, then carried)\n    // so a later no-arg analysis method still has a key context.\n    return new Chord(negativeHarmonyMirror(this.#data, resolved.scale), key ?? this.#key);\n  }\n\n  /**\n   * The n-th inversion: a copy whose bass is the chord tone `n` steps above the\n   * root in the interval template (`invert(1)` puts the third in the bass).\n   * `n` wraps around the template length; negative values count backwards.\n   *\n   * `invert(0)` (and any `n` that wraps to it) is root position, so it carries\n   * no slash bass and equals the original chord.\n   *\n   * @param n The inversion number.\n   * @returns The inverted chord, keeping any key context.\n   * @throws If the chord has no intervals.\n   */\n  invert(n: number): Chord {\n    const intervals = this.#data.intervals;\n    const length = intervals.length;\n    if (length === 0) {\n      throw new Error('cannot invert a chord with no intervals');\n    }\n    const index = ((n % length) + length) % length;\n    const data = copyChord(this.#data);\n    if (index === 0) {\n      delete data.bassPc;\n    } else {\n      data.bassPc = mod12(this.#data.rootPc + (intervals[index] ?? 0));\n    }\n    return new Chord(data, this.#key);\n  }\n\n  /**\n   * The named scales that fit over this chord, best fit first, rooted on the\n   * chord root.\n   *\n   * @returns The matching scales.\n   */\n  scales(): ChordScaleMatch[] {\n    return chordScales(this.#data);\n  }\n\n  /**\n   * The available tensions (usable non-chord, non-avoid scale tones) of a\n   * scale over this chord.\n   *\n   * @param scaleName A named scale, rooted on the chord root.\n   * @returns Tension pitch classes, ascending in [0, 11].\n   */\n  tensions(scaleName: string): number[] {\n    return availableTensions(this.#data, scaleName);\n  }\n\n  /**\n   * The avoid notes (scale tones a semitone above a chord tone) of a scale\n   * over this chord.\n   *\n   * @param scaleName A named scale, rooted on the chord root.\n   * @returns Avoid-note pitch classes, ascending in [0, 11].\n   */\n  avoidNotes(scaleName: string): number[] {\n    return avoidNotes(this.#data, scaleName);\n  }\n\n  /**\n   * Spell the chord tones with letter names, root first, in the key's spelling.\n   *\n   * @param key Key providing the spelled tonic; falls back to the carried\n   *   context.\n   * @returns Spelled octave-less notes in the chord's own (tertian) order.\n   * @throws If no key is given and none is carried.\n   */\n  spell(key?: Key): Note[] {\n    const resolved = this.#resolveKey(key);\n    return spellChord(this.#data, resolved.tonic.data, resolved.scale).map(\n      (note) => new Note(note),\n    );\n  }\n\n  /**\n   * Start a progression with this chord followed by others, carrying this\n   * chord's key context (if any).\n   *\n   * @param others The chords following this one.\n   * @returns The progression.\n   */\n  progressionTo(...others: Chord[]): Progression {\n    return new Progression([this, ...others], this.#key);\n  }\n\n  /**\n   * Whether another chord has the same root, quality, intervals, and bass.\n   * Key context is not compared.\n   *\n   * @param other The chord to compare.\n   * @returns True if the chord data is identical.\n   */\n  equals(other: Chord): boolean {\n    const a = this.#data;\n    const b = other.#data;\n    return (\n      a.rootPc === b.rootPc &&\n      a.quality === b.quality &&\n      a.bassPc === b.bassPc &&\n      a.intervals.length === b.intervals.length &&\n      a.intervals.every((interval, i) => interval === b.intervals[i])\n    );\n  }\n\n  /**\n   * The plain chord data, for JSON serialization.\n   *\n   * @returns A copy of the underlying plain chord object.\n   */\n  toJSON(): ChordData {\n    return this.data;\n  }\n\n  /** Resolve the key for an analysis method: explicit first, then carried. */\n  #resolveKey(key?: Key): Key {\n    const resolved = key ?? this.#key;\n    if (resolved === undefined) {\n      throw new Error('chord has no key context; pass a Key or attach one with withKey()');\n    }\n    return resolved;\n  }\n}\n","import type { SpelledInterval } from '../core/pitch/index.js';\nimport type { Note } from './note.js';\n\n/**\n * An immutable spelled interval value: a diatonic number, a quality label, and\n * a signed semitone span. A thin convenience wrapper over the pitch module's\n * plain interval result.\n *\n * @category Class API\n * @example\n * ```ts\n * import { Interval, Note } from '@libraz/libcantus';\n * Interval.between(Note.of('C4'), Note.of('G4')).name; // 'P5'\n * ```\n */\nexport class Interval {\n  readonly #number: number;\n  readonly #quality: string;\n  readonly #semitones: number;\n\n  private constructor(numberValue: number, quality: string, semitones: number) {\n    this.#number = numberValue;\n    this.#quality = quality;\n    this.#semitones = semitones;\n  }\n\n  /**\n   * The spelled interval between two notes.\n   *\n   * @param a The first note.\n   * @param b The second note.\n   * @returns The interval from `a` to `b`.\n   */\n  static between(a: Note, b: Note): Interval {\n    const spelled = a.intervalTo(b);\n    return new Interval(spelled.number, spelled.quality, spelled.semitones);\n  }\n\n  /**\n   * Build an interval from explicit components.\n   *\n   * @param numberValue Diatonic size: 1 = unison, 2 = second, ... 8 = octave.\n   * @param quality Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`.\n   * @param semitones Signed semitone span.\n   * @returns The interval.\n   */\n  static of(numberValue: number, quality: string, semitones: number): Interval {\n    return new Interval(numberValue, quality, semitones);\n  }\n\n  /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */\n  get number(): number {\n    return this.#number;\n  }\n\n  /** Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`. */\n  get quality(): string {\n    return this.#quality;\n  }\n\n  /** Signed semitone span. */\n  get semitones(): number {\n    return this.#semitones;\n  }\n\n  /** A readable label composed of quality and number, e.g. `'P5'` or `'M3'`. */\n  get name(): string {\n    return `${this.#quality}${this.#number}`;\n  }\n\n  /**\n   * The plain interval data, for JSON serialization.\n   *\n   * Private class fields do not serialize, so an explicit `toJSON` keeps\n   * `JSON.stringify(interval)` from collapsing to `{}`.\n   *\n   * @returns The diatonic number, quality, and semitone span.\n   */\n  toJSON(): SpelledInterval {\n    return { number: this.#number, quality: this.#quality, semitones: this.#semitones };\n  }\n}\n","import { isMinorKey, romanToChord } from '../analyze/functional/index.js';\nimport type { Note as NoteData } from '../core/pitch/index.js';\nimport type { KeyScale } from '../core/types.js';\nimport {\n  type ChordQuality,\n  chordFromDegree,\n  diatonicSeventh,\n  diatonicTriad,\n} from '../theory/chord/index.js';\nimport {\n  isScaleTone,\n  majorKey,\n  minorKey,\n  scaleByName,\n  scaleTonesInDegreeOrder,\n} from '../theory/scale/index.js';\nimport { spellScale } from '../theory/spelling/index.js';\nimport { Chord } from './chord.js';\nimport { Note } from './note.js';\nimport { mod12, spellPitchClassBare } from './shared.js';\n\n/** Resolve a string or numeric key root into a spelled tonic note. */\nfunction resolveTonic(root: string | number, spelling: 'sharp' | 'flat'): Note {\n  return typeof root === 'string' ? Note.of(root) : new Note(spellPitchClassBare(root, spelling));\n}\n\n/** Total accidentals a spelled tonic produces across a key's whole scale. */\nfunction accidentalLoad(tonic: NoteData, scale: KeyScale): number {\n  return spellScale(tonic, scale).reduce((sum, note) => sum + Math.abs(note.alter), 0);\n}\n\n/**\n * Choose the tonic spelling (sharp- or flat-side) that spells `scale` with the\n * fewest accidentals, so a numeric root never yields a double-flat/double-sharp\n * scale (e.g. pitch class 6 minor spells as F# minor, not Gb minor with Bbb).\n */\nfunction bestTonicForScale(rootPc: number, scale: KeyScale): Note {\n  const sharp = spellPitchClassBare(rootPc, 'sharp');\n  const flat = spellPitchClassBare(rootPc, 'flat');\n  if (sharp.letter === flat.letter && sharp.alter === flat.alter) {\n    return new Note(sharp);\n  }\n  return accidentalLoad(flat, scale) <= accidentalLoad(sharp, scale)\n    ? new Note(flat)\n    : new Note(sharp);\n}\n\n/**\n * An immutable key/scale: a `KeyScale` (root pitch class plus mode mask) paired\n * with a spelled tonic that anchors letter-name spelling. Acts as the factory\n * for key-aware chords.\n *\n * @category Class API\n * @example\n * ```ts\n * import { Key } from '@libraz/libcantus';\n * Key.major('C').chord(4).symbol(); // 'G' (the diatonic triad on scale degree 4)\n * ```\n */\nexport class Key {\n  readonly #scale: KeyScale;\n  readonly #tonic: Note;\n\n  /**\n   * Wrap a key/scale and its spelled tonic.\n   *\n   * @param scale The key/scale; its root is normalized to a pitch class.\n   * @param tonic The spelled tonic anchoring letter-name spelling.\n   */\n  constructor(scale: KeyScale, tonic: Note) {\n    this.#scale = { rootPc: mod12(scale.rootPc), modeMask12: scale.modeMask12 };\n    this.#tonic = tonic;\n  }\n\n  /**\n   * A major key.\n   *\n   * @param root Tonic as a note name (e.g. `'Eb'`) or a pitch class; a numeric\n   *   root is spelled with whichever accidental side yields the fewest\n   *   accidentals across the scale.\n   * @returns The major key.\n   */\n  static major(root: string | number): Key {\n    if (typeof root === 'string') {\n      const tonic = Note.of(root);\n      return new Key(majorKey(tonic.pitchClass), tonic);\n    }\n    const scale = majorKey(root);\n    return new Key(scale, bestTonicForScale(root, scale));\n  }\n\n  /**\n   * A natural-minor key.\n   *\n   * @param root Tonic as a note name or a pitch class; a numeric root is\n   *   spelled with whichever accidental side yields the fewest accidentals\n   *   across the scale.\n   * @returns The minor key.\n   */\n  static minor(root: string | number): Key {\n    if (typeof root === 'string') {\n      const tonic = Note.of(root);\n      return new Key(minorKey(tonic.pitchClass), tonic);\n    }\n    const scale = minorKey(root);\n    return new Key(scale, bestTonicForScale(root, scale));\n  }\n\n  /**\n   * A key on a named scale (e.g. `'dorian'`, `'harmonicMinor'`).\n   *\n   * @param name The scale name, a key of the scale module's named-scale table.\n   * @param root Tonic as a note name or a pitch class.\n   * @returns The key.\n   * @throws If the name is not a known scale.\n   */\n  static named(name: string, root: string | number): Key {\n    const tonic = resolveTonic(root, 'sharp');\n    return new Key(scaleByName(name, tonic.pitchClass), tonic);\n  }\n\n  /**\n   * Wrap an existing `KeyScale`, synthesizing a spelled tonic when none is\n   * given (flat-preferred for minor-third scales, sharp-preferred otherwise).\n   *\n   * @param scale The key/scale to wrap.\n   * @param tonic Optional spelled tonic.\n   * @returns The key.\n   */\n  static of(scale: KeyScale, tonic?: Note): Key {\n    const spelled =\n      tonic ?? new Note(spellPitchClassBare(scale.rootPc, isMinorKey(scale) ? 'flat' : 'sharp'));\n    return new Key(scale, spelled);\n  }\n\n  /** A copy of the underlying plain `KeyScale`. */\n  get scale(): KeyScale {\n    return { rootPc: this.#scale.rootPc, modeMask12: this.#scale.modeMask12 };\n  }\n\n  /** The spelled tonic. */\n  get tonic(): Note {\n    return this.#tonic;\n  }\n\n  /** The tonic pitch class (0..11). */\n  get rootPc(): number {\n    return this.#scale.rootPc;\n  }\n\n  /** Whether the scale has a minor third and no major third. */\n  get isMinor(): boolean {\n    return isMinorKey(this.#scale);\n  }\n\n  /**\n   * The scale's pitch classes in ascending scale-degree order (degree 0 first).\n   *\n   * @returns One pitch class per scale degree.\n   */\n  pitchClasses(): number[] {\n    return scaleTonesInDegreeOrder(this.#scale);\n  }\n\n  /**\n   * The spelled scale, one note per degree (e.g. C D E F G A B for C major).\n   *\n   * @returns Spelled octave-less notes in scale-degree order.\n   */\n  notes(): Note[] {\n    return spellScale(this.#tonic.data, this.#scale).map((note) => new Note(note));\n  }\n\n  /**\n   * Alias of {@link Key.notes}.\n   *\n   * @returns Spelled octave-less notes in scale-degree order.\n   */\n  spell(): Note[] {\n    return this.notes();\n  }\n\n  /**\n   * The spelled scale as letter-name strings.\n   *\n   * @returns One name per scale degree.\n   */\n  noteNames(): string[] {\n    return this.notes().map((note) => note.name);\n  }\n\n  /**\n   * Build a chord on a scale degree, carrying this key as context.\n   *\n   * With an explicit quality the quality's interval template is attached to the\n   * degree's diatonic root; without one the scale-correct diatonic triad is\n   * stacked (e.g. a diminished triad on the leading tone of a major key).\n   *\n   * @param degree 0-based scale degree of the chord root.\n   * @param quality Optional chord quality.\n   * @returns The chord, with this key attached.\n   */\n  chord(degree: number, quality?: ChordQuality): Chord {\n    const data =\n      quality === undefined\n        ? diatonicTriad(degree, this.#scale)\n        : chordFromDegree(degree, quality, this.#scale);\n    return new Chord(data, this);\n  }\n\n  /**\n   * The diatonic triad on a scale degree, carrying this key as context.\n   *\n   * @param degree 0-based scale degree of the chord root.\n   * @returns The triad, with this key attached.\n   */\n  diatonicTriad(degree: number): Chord {\n    return new Chord(diatonicTriad(degree, this.#scale), this);\n  }\n\n  /**\n   * The diatonic seventh chord on a scale degree, carrying this key as context.\n   *\n   * @param degree 0-based scale degree of the chord root.\n   * @returns The seventh chord, with this key attached.\n   */\n  diatonicSeventh(degree: number): Chord {\n    return new Chord(diatonicSeventh(degree, this.#scale), this);\n  }\n\n  /**\n   * Build the chord denoted by a Roman numeral in this key (including applied\n   * chords such as `'V7/V'`), carrying this key as context.\n   *\n   * @param text The Roman numeral.\n   * @returns The chord, with this key attached.\n   * @throws If the numeral is not valid.\n   */\n  roman(text: string): Chord {\n    return new Chord(romanToChord(text, this.#scale), this);\n  }\n\n  /**\n   * Whether a pitch belongs to the scale.\n   *\n   * @param x A MIDI pitch, bare pitch class, or note.\n   * @returns True if the pitch class is a scale tone.\n   */\n  contains(x: number | Note): boolean {\n    return isScaleTone(typeof x === 'number' ? x : x.pitchClass, this.#scale);\n  }\n\n  /**\n   * The plain key data, for JSON serialization.\n   *\n   * Private class fields do not serialize, so an explicit `toJSON` keeps\n   * `JSON.stringify(key)` from collapsing to `{}`. The result pairs the\n   * `KeyScale` with the spelled tonic, enough to reconstruct the key via\n   * {@link Key.of}.\n   *\n   * @returns The key/scale and its spelled tonic.\n   */\n  toJSON(): { scale: KeyScale; tonic: NoteData } {\n    return { scale: this.scale, tonic: this.#tonic.data };\n  }\n}\n"],"mappings":"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","names":["pitchClass","pitchClass","degreeNumber","hasMajorThird","mod12","mod12","pitchClass","mod12","LETTER_SEMITONES","mod12","mod7","mod12","pitchClass","pitchClass","pitchClass","mod12","mod12","mod12"]}
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/model/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACF,wNAAC","file":"/home/runner/work/libcantus/libcantus/dist/model/index.cjs"}