@libraz/libcantus 0.9.2 → 0.9.4

package/dist/{chunk-COKTX2G5.js → chunk-EHVEBWM5.js}

@@ -1,6 +1,6 @@
 import {
   negativeHarmonyMirror
-} from "./chunk-GQKN5KDT.js";
+} from "./chunk-GQSGS2N4.js";
 import {
   analyzeChord,
   borrowedSource,
@@ -8,11 +8,13 @@ import {
   detectCadence,
   detectChord,
   detectChordBest,
+  detectKey,
+  detectKeyBest,
   functionOf,
   isBorrowedChord,
   isMinorKey,
   romanToChord
-} from "./chunk-LN7ZZMD2.js";
+} from "./chunk-KMHOICIY.js";
 import {
   availableTensions,
   avoidNotes,
@@ -20,19 +22,13 @@ import {
   formatChordSymbol,
   parseChordSymbol,
   spellChord,
+  spellChordFromRoot,
+  spellPitchClass,
   spellScale,
   voiceChord,
   voiceChordStyled,
   voiceProgression
-} from "./chunk-XTC3X6MS.js";
-import {
-  formatNote,
-  midiToNote,
-  noteToMidi,
-  noteToPitchClass,
-  parseNote,
-  spelledInterval
-} from "./chunk-DYWFNC4A.js";
+} from "./chunk-RK35RIN7.js";
 import {
   chordFromDegree,
   chordPitchClasses,
@@ -43,20 +39,189 @@ import {
   makeChord,
   minorKey,
   scaleByName,
-  scaleTonesInDegreeOrder
-} from "./chunk-7Y7WF64D.js";
+  scaleTonesInDegreeOrder,
+  transposeChord
+} from "./chunk-D2FAJBYL.js";
+import {
+  InvalidInputError,
+  assertFiniteNumber,
+  formatNote,
+  intervalSemitones,
+  isConsonantInterval,
+  midiToNote,
+  noteToMidi,
+  noteToPitchClass,
+  parseInterval,
+  parseNote,
+  pitchClassOf,
+  spelledInterval,
+  transposeByInterval,
+  transposeNote
+} from "./chunk-XEBG3G53.js";
 
-// src/model/shared.ts
-function mod12(n) {
-  return (n % 12 + 12) % 12;
-}
-function spellPitchClassBare(pc, spelling) {
-  const spelled = midiToNote(60 + mod12(pc), spelling);
-  return { letter: spelled.letter, alter: spelled.alter };
+// src/model/interval.ts
+var INVERSION_SUM = 9;
+function invertQuality(quality) {
+  if (quality === "P") {
+    return "P";
+  }
+  if (quality === "M") {
+    return "m";
+  }
+  if (quality === "m") {
+    return "M";
+  }
+  return quality.startsWith("A") ? `d${"d".repeat(quality.length - 1)}` : `A${"A".repeat(quality.length - 1)}`;
 }
+var Interval = class _Interval {
+  #number;
+  #quality;
+  #semitones;
+  constructor(numberValue, quality, semitones) {
+    this.#number = numberValue;
+    this.#quality = quality;
+    this.#semitones = semitones;
+  }
+  /**
+   * The spelled interval between two notes.
+   *
+   * @param a The first note.
+   * @param b The second note.
+   * @returns The interval from `a` to `b`.
+   */
+  static between(a, b) {
+    return a.intervalTo(b);
+  }
+  /**
+   * Build an interval from explicit components.
+   *
+   * @param numberValue Diatonic size: 1 = unison, 2 = second, ... 8 = octave.
+   * @param quality Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`.
+   * @param semitones Signed semitone span; its magnitude must be the span the
+   *   number and quality describe.
+   * @returns The interval.
+   * @throws If the three components do not describe the same interval — a
+   *   `P5` spanning 8 semitones is not a value any other method can produce.
+   */
+  static of(numberValue, quality, semitones) {
+    const expected = intervalSemitones(numberValue, quality);
+    if (Math.abs(semitones) !== expected) {
+      throw new InvalidInputError(
+        `${quality}${numberValue} spans ${expected} semitones; received ${semitones}`
+      );
+    }
+    return new _Interval(numberValue, quality, semitones);
+  }
+  /**
+   * Wrap a plain spelled interval, as returned by the pitch module.
+   *
+   * @param data The plain interval.
+   * @returns The wrapped interval.
+   */
+  static fromData(data) {
+    return new _Interval(data.number, data.quality, data.semitones);
+  }
+  /**
+   * Rebuild an interval from its {@link Interval.toJSON} output.
+   *
+   * @param data The serialized interval.
+   * @returns The wrapped interval.
+   */
+  static fromJSON(data) {
+    return _Interval.fromData(data);
+  }
+  /**
+   * Parse an interval name such as `'P5'`, `'m3'`, or `'AA4'`.
+   *
+   * @param name The interval name.
+   * @returns The ascending interval of that name.
+   * @throws If the name is not a quality label followed by a diatonic number.
+   */
+  static parse(name) {
+    return _Interval.fromData(parseInterval(name));
+  }
+  /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */
+  get number() {
+    return this.#number;
+  }
+  /** Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`. */
+  get quality() {
+    return this.#quality;
+  }
+  /** Signed semitone span. */
+  get semitones() {
+    return this.#semitones;
+  }
+  /** A readable label composed of quality and number, e.g. `'P5'` or `'M3'`. */
+  get name() {
+    return `${this.#quality}${this.#number}`;
+  }
+  /**
+   * The interval's inversion: the complement that completes the octave.
+   *
+   * A compound interval is reduced to its simple form first, and the result is
+   * always ascending — an inversion answers "what is left of the octave",
+   * which has no direction of its own.
+   *
+   * @returns The inverted interval, e.g. `M3` becomes `m6`.
+   */
+  invert() {
+    const simple = (this.#number - 1) % 7 + 1;
+    const numberValue = INVERSION_SUM - simple;
+    const quality = invertQuality(this.#quality);
+    return _Interval.of(numberValue, quality, intervalSemitones(numberValue, quality));
+  }
+  /**
+   * Whether the interval is consonant.
+   *
+   * @param twoVoice When true, the perfect fourth counts as a dissonance,
+   *   matching two-voice counterpoint.
+   * @returns True if the interval is consonant in that context.
+   */
+  isConsonant(twoVoice = true) {
+    return isConsonantInterval(this.#semitones, twoVoice);
+  }
+  /**
+   * Whether another interval is spelled identically.
+   *
+   * Enharmonic equivalents are not equal: an augmented second and a minor
+   * third span the same distance but are different intervals.
+   *
+   * @param other The interval to compare with.
+   * @returns True when number, quality, and span all match.
+   */
+  equals(other) {
+    return this.#number === other.number && this.#quality === other.quality && this.#semitones === other.semitones;
+  }
+  /**
+   * The plain interval data, for JSON serialization.
+   *
+   * Private class fields do not serialize, so an explicit `toJSON` keeps
+   * `JSON.stringify(interval)` from collapsing to `{}`.
+   *
+   * @returns The diatonic number, quality, and semitone span.
+   */
+  toJSON() {
+    return { number: this.#number, quality: this.#quality, semitones: this.#semitones };
+  }
+  /**
+   * The interval's name, so a template literal or a log line reads as the
+   * interval.
+   *
+   * @returns The name, e.g. `'M3'`.
+   */
+  toString() {
+    return this.name;
+  }
+};
 
 // src/model/note.ts
 function copyNote(data) {
+  if (!Number.isInteger(data.letter) || data.letter < 0 || data.letter > 6) {
+    throw new InvalidInputError(
+      `note letter must be an integer in [0, 6]; received ${data.letter}`
+    );
+  }
   const copy = { letter: data.letter, alter: data.alter };
   if (data.octave !== void 0) {
     copy.octave = data.octave;
@@ -69,6 +234,7 @@ var Note = class _Note {
    * Wrap a plain note object.
    *
    * @param data The spelled note; it is copied, never retained or mutated.
+   * @throws If `letter` is not an integer in 0..6.
    */
   constructor(data) {
     this.#data = copyNote(data);
@@ -98,6 +264,7 @@ var Note = class _Note {
    *
    * @param data The plain note.
    * @returns The wrapped note.
+   * @throws If `letter` is not an integer in 0..6.
    */
   static fromData(data) {
     return new _Note(data);
@@ -117,7 +284,7 @@ var Note = class _Note {
    */
   get midi() {
     if (this.#data.octave === void 0) {
-      throw new Error(`note ${this.name} has no octave, so it has no MIDI number`);
+      throw new InvalidInputError(`note ${this.name} has no octave, so it has no MIDI number`);
     }
     return noteToMidi(this.#data);
   }
@@ -138,33 +305,67 @@ var Note = class _Note {
     return copyNote(this.#data);
   }
   /**
-   * Transpose by a signed number of semitones.
+   * Transpose by a signed number of semitones, keeping the spelling.
    *
-   * When the note carries an octave the transposition happens in MIDI space and
-   * the result is spelled with a sharp preference. An octave-less note stays
+   * The letter moves by the diatonic distance of the conventional interval for
+   * that many semitones, so `Ab4` up a major second is `Bb4` rather than `A#4`
+   * and a flat key stays on the flat side. An octave-less note stays
    * octave-less: only its pitch class is moved. Transposing by zero is the
    * identity: the original spelling is preserved (no enharmonic respelling).
    *
    * @param semitones The signed semitone offset.
+   * @param opts `spelling` forces the result onto the sharp or flat side
+   *   instead of following this note's letter.
    * @returns The transposed note.
+   * @example
+   * ```ts
+   * import { Note } from '@libraz/libcantus';
+   * Note.of('Ab4').transpose(2).name; // 'Bb4'
+   * Note.of('Ab4').transpose(2, { spelling: 'sharp' }).name; // 'A#4'
+   * ```
    */
-  transpose(semitones) {
-    if (semitones === 0) {
+  transpose(semitones, opts) {
+    if (semitones === 0 && opts?.spelling === void 0) {
       return new _Note(this.#data);
     }
-    if (this.#data.octave !== void 0) {
-      return _Note.fromMidi(this.midi + semitones);
-    }
-    return new _Note(spellPitchClassBare(this.pitchClass + semitones, "sharp"));
+    return new _Note(transposeNote(this.#data, semitones, opts));
   }
   /**
    * The spelled interval from this note to another.
    *
    * @param other The second note.
-   * @returns The diatonic number, quality, and semitone span.
+   * @returns The interval, which {@link Interval.toJSON} unwraps to plain data.
    */
   intervalTo(other) {
-    return spelledInterval(this.#data, other.#data);
+    return Interval.fromData(spelledInterval(this.#data, other.data));
+  }
+  /**
+   * Transpose by a spelled interval, keeping the spelling the interval names.
+   *
+   * Unlike {@link Note.transpose}, which picks a letter from the semitone
+   * count, the interval's diatonic number decides the letter: C up an
+   * augmented second is D#, not Eb.
+   *
+   * @param interval The interval to apply; a descending interval moves down.
+   * @returns The transposed note.
+   * @example
+   * ```ts
+   * import { Interval, Note } from '@libraz/libcantus';
+   * Note.of('C4').transposeBy(Interval.parse('A2')).name; // 'D#4'
+   * ```
+   */
+  transposeBy(interval) {
+    return new _Note(transposeByInterval(this.#data, interval.toJSON()));
+  }
+  /**
+   * Rebuild a note from its {@link Note.toJSON} output.
+   *
+   * @param data The serialized note.
+   * @returns The wrapped note.
+   * @throws If `letter` is not an integer in 0..6.
+   */
+  static fromJSON(data) {
+    return new _Note(data);
   }
   /**
    * Whether another note has the same letter, alteration, and octave.
@@ -173,7 +374,8 @@ var Note = class _Note {
    * @returns True if the spellings are identical.
    */
   equals(other) {
-    return this.#data.letter === other.#data.letter && this.#data.alter === other.#data.alter && this.#data.octave === other.#data.octave;
+    const b = other.data;
+    return this.#data.letter === b.letter && this.#data.alter === b.alter && this.#data.octave === b.octave;
   }
   /**
    * The plain note data, for JSON serialization.
@@ -186,722 +388,1062 @@ var Note = class _Note {
   toJSON() {
     return this.data;
   }
-};
-
-// src/model/progression.ts
-var Progression = class _Progression {
-  #chords;
-  #key;
   /**
-   * Wrap a chord sequence.
+   * The note's name, so a template literal or a log line reads as the note.
    *
-   * @param chords The chords in order; the array is copied.
-   * @param key Optional key context for analysis methods.
+   * @returns The spelled name, e.g. `'Bb3'`.
    */
-  constructor(chords, key) {
-    this.#chords = [...chords];
-    this.#key = key;
-  }
-  /** A copy of the chord sequence. */
-  get chords() {
-    return [...this.#chords];
+  toString() {
+    return this.name;
   }
-  /** The carried key context, if any. */
-  get key() {
-    return this.#key;
+};
+
+// src/model/shared.ts
+function spellPitchClassBare(pc, spelling) {
+  const spelled = midiToNote(60 + pitchClassOf(pc), spelling);
+  return { letter: spelled.letter, alter: spelled.alter };
+}
+
+// src/model/key.ts
+function accidentalLoad(tonic, scale) {
+  return spellScale(tonic, scale).reduce((sum, note) => sum + Math.abs(note.alter), 0);
+}
+function bestTonicForScale(rootPc, scale) {
+  const sharp = spellPitchClassBare(rootPc, "sharp");
+  const flat = spellPitchClassBare(rootPc, "flat");
+  if (sharp.letter === flat.letter && sharp.alter === flat.alter) {
+    return new Note(sharp);
   }
-  /** The number of chords. */
-  get length() {
-    return this.#chords.length;
+  return accidentalLoad(flat, scale) <= accidentalLoad(sharp, scale) ? new Note(flat) : new Note(sharp);
+}
+var Key = class _Key {
+  #scale;
+  #tonic;
+  /**
+   * Wrap a key/scale and its spelled tonic.
+   *
+   * @param scale The key/scale; its root is normalized to a pitch class.
+   * @param tonic The spelled tonic anchoring letter-name spelling.
+   */
+  constructor(scale, tonic) {
+    const rootPc = pitchClassOf(scale.rootPc);
+    if (tonic.pitchClass !== rootPc) {
+      throw new InvalidInputError(
+        `tonic ${tonic.name} does not match the scale root pitch class ${rootPc}; pass a tonic that spells the scale root, or omit it to have one chosen`
+      );
+    }
+    this.#scale = { rootPc, modeMask12: scale.modeMask12 };
+    this.#tonic = tonic;
   }
   /**
-   * A copy of this progression with a chord appended.
+   * A major key.
    *
-   * @param chord The chord to append.
-   * @returns The new progression.
+   * @param root Tonic as a note name (e.g. `'Eb'`) or a pitch class; a numeric
+   *   root is spelled with whichever accidental side yields the fewest
+   *   accidentals across the scale.
+   * @returns The major key.
    */
-  add(chord) {
-    return new _Progression([...this.#chords, chord], this.#key);
+  static major(root) {
+    if (typeof root === "string") {
+      const tonic = Note.of(root);
+      return new _Key(majorKey(tonic.pitchClass), tonic);
+    }
+    const scale = majorKey(root);
+    return new _Key(scale, bestTonicForScale(root, scale));
   }
   /**
-   * A copy of this progression carrying the given key context.
+   * A natural-minor key.
    *
-   * @param key The key context to attach.
-   * @returns The new progression.
+   * @param root Tonic as a note name or a pitch class; a numeric root is
+   *   spelled with whichever accidental side yields the fewest accidentals
+   *   across the scale.
+   * @returns The minor key.
    */
-  withKey(key) {
-    return new _Progression(this.#chords, key);
+  static minor(root) {
+    if (typeof root === "string") {
+      const tonic = Note.of(root);
+      return new _Key(minorKey(tonic.pitchClass), tonic);
+    }
+    const scale = minorKey(root);
+    return new _Key(scale, bestTonicForScale(root, scale));
   }
   /**
-   * Voice the progression with smooth voice leading.
+   * A key on a named scale (e.g. `'dorian'`, `'harmonicMinor'`).
    *
-   * @param opts Voicing options; defaults to four SATB voices.
-   * @returns One ascending voicing (MIDI pitches) per chord.
-   * @throws If any chord admits no voicing within the given ranges.
+   * @param name The scale name, a key of the scale module's named-scale table.
+   * @param root Tonic as a note name or a pitch class; a numeric root is
+   *   spelled with whichever accidental side yields the fewest accidentals
+   *   across the scale, exactly as {@link Key.major} does.
+   * @returns The key.
+   * @throws If the name is not a known scale.
    */
-  voice(opts) {
-    return voiceProgression(
-      this.#chords.map((chord) => chord.data),
-      opts
-    );
+  static named(name, root) {
+    if (typeof root === "string") {
+      const tonic = Note.of(root);
+      return new _Key(scaleByName(name, tonic.pitchClass), tonic);
+    }
+    const scale = scaleByName(name, pitchClassOf(root));
+    return new _Key(scale, bestTonicForScale(pitchClassOf(root), scale));
   }
   /**
-   * The Roman numeral of each chord in a key.
+   * Wrap an existing `KeyScale`, synthesizing a spelled tonic when none is
+   * given.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns One numeral per chord.
-   * @throws If no key is given and none is carried.
+   * The synthesized tonic is chosen the same way as for a numeric root
+   * elsewhere: whichever accidental side spells the scale with the fewest
+   * accidentals. This is what keeps `Key.of(detectKey(...).scale)` from handing
+   * every downstream chord a double-sharp spelling.
+   *
+   * @param scale The key/scale to wrap.
+   * @param tonic Optional spelled tonic; must spell the scale's root pitch class.
+   * @returns The key.
+   * @throws If the given tonic is not the scale's root pitch class.
    */
-  roman(key) {
-    const resolved = this.#resolveKey(key);
-    return this.#chords.map((chord) => chord.roman(resolved));
+  static of(scale, tonic) {
+    return new _Key(scale, tonic ?? bestTonicForScale(pitchClassOf(scale.rootPc), scale));
   }
   /**
-   * The harmonic function of each chord in a key.
+   * Rebuild a key from its {@link Key.toJSON} output.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns One function per chord.
-   * @throws If no key is given and none is carried.
+   * @param data The serialized key and tonic.
+   * @returns The key.
    */
-  functions(key) {
-    const resolved = this.#resolveKey(key);
-    return this.#chords.map((chord) => chord.function(resolved));
+  static fromJSON(data) {
+    return new _Key(data.scale, new Note(data.tonic));
   }
   /**
-   * Analyze every chord and classify the closing cadence.
+   * Identify the keys a set of pitches fits, best interpretation first.
    *
-   * The cadence is detected on the final chord pair and is null when the
-   * progression has fewer than two chords.
+   * The counterpart of {@link Chord.detect}.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns Per-chord analyses and the closing cadence.
-   * @throws If no key is given and none is carried.
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to weigh the input; see {@link DetectKeyOptions}.
+   * @returns Ranked keys (may be empty).
    */
-  analyze(key) {
-    const resolved = this.#resolveKey(key);
-    const chords = this.#chords.map((chord) => chord.analyze(resolved));
-    const from = this.#chords[this.#chords.length - 2];
-    const to = this.#chords[this.#chords.length - 1];
-    const cadence = from !== void 0 && to !== void 0 ? detectCadence(from.data, to.data, resolved.scale) : null;
-    return { chords, cadence };
+  static detect(pitches, opts) {
+    return detectKey(pitches, opts).map((match) => _Key.of(match.key));
   }
   /**
-   * The plain progression data, for JSON serialization.
+   * The single best key interpretation of a pitch set.
    *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(progression)` from collapsing to `{}`. The chords are
-   * emitted as plain data and the carried key, when present, as its own data.
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to weigh the input; see {@link DetectKeyOptions}.
+   * @returns The top-ranked key, or null when nothing matches.
+   * @example
+   * ```ts
+   * import { Key } from '@libraz/libcantus';
+   * Key.detectBest([0, 2, 4, 5, 7, 9, 11])?.toString(); // 'C major'
+   * ```
+   */
+  static detectBest(pitches, opts) {
+    const best = detectKeyBest(pitches, opts);
+    return best === null ? null : _Key.of(best.key);
+  }
+  /**
+   * Whether another key has the same tonic pitch class and mode.
    *
-   * @returns The chord data sequence and the carried key, if any.
+   * The spelled tonic is not compared: C# major and Db major are the same key
+   * written two ways.
+   *
+   * @param other The key to compare.
+   * @returns True when tonic and mode mask both match.
    */
-  toJSON() {
-    return {
-      chords: this.#chords.map((chord) => chord.data),
-      key: this.#key?.toJSON()
-    };
+  equals(other) {
+    const scale = other.scale;
+    return this.#scale.rootPc === scale.rootPc && this.#scale.modeMask12 === scale.modeMask12;
   }
-  /** Resolve the key for an analysis method: explicit first, then carried. */
-  #resolveKey(key) {
-    const resolved = key ?? this.#key;
-    if (resolved === void 0) {
-      throw new Error("progression has no key context; pass a Key or attach one with withKey()");
-    }
-    return resolved;
+  /** A copy of the underlying plain `KeyScale`. */
+  get scale() {
+    return { rootPc: this.#scale.rootPc, modeMask12: this.#scale.modeMask12 };
   }
-};
-
-// src/model/chord.ts
-function copyChord(data) {
-  const copy = {
-    rootPc: data.rootPc,
-    quality: data.quality,
-    intervals: [...data.intervals]
-  };
-  if (data.bassPc !== void 0) {
-    copy.bassPc = data.bassPc;
+  /** The spelled tonic. */
+  get tonic() {
+    return this.#tonic;
   }
-  if (data.rootSpelling !== void 0) {
-    copy.rootSpelling = { letter: data.rootSpelling.letter, alter: data.rootSpelling.alter };
+  /** The tonic pitch class (0..11). */
+  get rootPc() {
+    return this.#scale.rootPc;
   }
-  if (data.bassSpelling !== void 0) {
-    copy.bassSpelling = { letter: data.bassSpelling.letter, alter: data.bassSpelling.alter };
+  /** Whether the scale has a minor third and no major third. */
+  get isMinor() {
+    return isMinorKey(this.#scale);
   }
-  return copy;
-}
-var Chord = class _Chord {
-  #data;
-  #key;
   /**
-   * Wrap a plain chord object.
+   * The scale's pitch classes in ascending scale-degree order (degree 0 first).
    *
-   * @param data The chord; it is copied, never retained or mutated.
-   * @param key Optional key context for analysis methods.
+   * @returns One pitch class per scale degree.
    */
-  constructor(data, key) {
-    this.#data = copyChord(data);
-    this.#key = key;
+  pitchClasses() {
+    return scaleTonesInDegreeOrder(this.#scale);
   }
   /**
-   * Build a chord from a root and quality.
+   * Transpose the key by a number of semitones.
    *
-   * @param root Root as a note name (e.g. `'Eb'`) or a pitch class.
-   * @param quality The chord quality.
-   * @param bass Optional slash-chord bass pitch class.
-   * @returns The chord (without key context).
+   * The mode mask is unchanged, so the scale keeps its shape; only the tonic
+   * moves. The new tonic is spelled the way that key is conventionally written
+   * — D major, not C## major.
+   *
+   * @param semitones The signed semitone offset.
+   * @returns The transposed key.
+   * @example
+   * ```ts
+   * import { Key } from '@libraz/libcantus';
+   * Key.major('C').transpose(2).toString(); // 'D major'
+   * ```
    */
-  static of(root, quality, bass) {
-    const rootPc = typeof root === "string" ? Note.of(root).pitchClass : root;
-    return new _Chord(makeChord(rootPc, quality, bass));
+  transpose(semitones) {
+    assertFiniteNumber(semitones, "semitones");
+    const rootPc = pitchClassOf(this.#scale.rootPc + Math.round(semitones));
+    return _Key.of({ rootPc, modeMask12: this.#scale.modeMask12 });
   }
   /**
-   * Wrap an existing plain chord object.
+   * The spelled scale, one note per degree (e.g. C D E F G A B for C major).
    *
-   * @param data The plain chord.
-   * @returns The wrapped chord (without key context).
+   * @returns Spelled octave-less notes in scale-degree order.
    */
-  static from(data) {
-    return new _Chord(data);
+  notes() {
+    return spellScale(this.#tonic.data, this.#scale).map((note) => new Note(note));
   }
   /**
-   * Parse a lead-sheet chord symbol (e.g. `'Cmaj7'`, `'F#m7b5'`, `'C/G'`).
+   * Alias of {@link Key.notes}.
    *
-   * @param symbol The chord symbol.
-   * @returns The chord (without key context).
-   * @throws If the root or quality is not recognized.
+   * @returns Spelled octave-less notes in scale-degree order.
    */
-  static parse(symbol) {
-    return new _Chord(parseChordSymbol(symbol));
+  spell() {
+    return this.notes();
   }
   /**
-   * Identify the chords matching a set of pitches, best interpretation first.
+   * The spelled scale as letter-name strings.
    *
-   * @param pitches MIDI pitches or bare pitch classes.
-   * @returns Ranked chord interpretations (may be empty).
+   * @returns One name per scale degree.
    */
-  static detect(pitches) {
-    return detectChord(pitches).map(
-      (match) => new _Chord(makeChord(match.rootPc, match.quality, match.bassPc))
-    );
+  noteNames() {
+    return this.notes().map((note) => note.name);
   }
   /**
-   * The single best chord interpretation of a pitch set.
+   * Build a chord on a scale degree, carrying this key as context.
    *
-   * @param pitches MIDI pitches or bare pitch classes.
-   * @returns The top-ranked chord, or null when nothing matches.
+   * With an explicit quality the quality's interval template is attached to the
+   * degree's diatonic root; without one the scale-correct diatonic triad is
+   * stacked (e.g. a diminished triad on the leading tone of a major key).
+   *
+   * @param degree 0-based scale degree of the chord root.
+   * @param quality Optional chord quality.
+   * @returns The chord, with this key attached.
+   * @throws Without a `quality`, if this key's scale is not heptatonic —
+   *   stacking thirds needs seven degrees, so the pentatonic, blues,
+   *   whole-tone, octatonic and chromatic scales have no diatonic triad. Pass
+   *   an explicit `quality` for those.
    */
-  static detectBest(pitches) {
-    const best = detectChordBest(pitches);
-    return best === null ? null : new _Chord(best);
-  }
-  /** The root pitch class (0..11). */
-  get rootPc() {
-    return this.#data.rootPc;
-  }
-  /** The chord quality. */
-  get quality() {
-    return this.#data.quality;
-  }
-  /** A copy of the semitone offsets above the root. */
-  get intervals() {
-    return [...this.#data.intervals];
-  }
-  /** The slash-chord bass pitch class, or undefined in root position. */
-  get bassPc() {
-    return this.#data.bassPc;
-  }
-  /** A copy of the underlying plain chord object. */
-  get data() {
-    return copyChord(this.#data);
-  }
-  /** The carried key context, if any. */
-  get key() {
-    return this.#key;
+  chord(degree, quality) {
+    const data = quality === void 0 ? diatonicTriad(degree, this.#scale) : chordFromDegree(degree, quality, this.#scale);
+    return new Chord(data, this);
   }
   /**
-   * A copy of this chord carrying the given key context.
+   * The diatonic triad on a scale degree, carrying this key as context.
    *
-   * @param key The key context to attach.
-   * @returns The new chord.
+   * @param degree 0-based scale degree of the chord root.
+   * @returns The triad, with this key attached.
+   * @throws If this key's scale is not heptatonic; stacking thirds needs seven
+   *   degrees. Use {@link Key.chord} with an explicit quality instead.
    */
-  withKey(key) {
-    return new _Chord(this.#data, key);
+  diatonicTriad(degree) {
+    return new Chord(diatonicTriad(degree, this.#scale), this);
   }
   /**
-   * The chord's sorted, deduplicated pitch classes.
+   * The diatonic seventh chord on a scale degree, carrying this key as context.
    *
-   * @returns Pitch classes ascending in [0, 11].
+   * @param degree 0-based scale degree of the chord root.
+   * @returns The seventh chord, with this key attached.
+   * @throws If this key's scale is not heptatonic; stacking thirds needs seven
+   *   degrees. Use {@link Key.chord} with an explicit quality instead.
    */
-  pitchClasses() {
-    return chordPitchClasses(this.#data);
+  diatonicSeventh(degree) {
+    return new Chord(diatonicSeventh(degree, this.#scale), this);
   }
   /**
-   * The chord's Roman numeral in a key.
+   * Build the chord denoted by a Roman numeral in this key (including applied
+   * chords such as `'V7/V'`), carrying this key as context.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The Roman numeral string.
-   * @throws If no key is given and none is carried.
+   * @param text The Roman numeral.
+   * @returns The chord, with this key attached.
+   * @throws If the numeral is not valid.
    */
-  roman(key) {
-    return chordToRoman(this.#data, this.#resolveKey(key).scale);
+  roman(text) {
+    return new Chord(romanToChord(text, this.#scale), this);
   }
   /**
-   * The chord's harmonic function (tonic / subdominant / dominant) in a key.
+   * Whether a pitch belongs to the scale.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The harmonic function.
-   * @throws If no key is given and none is carried.
+   * @param x A MIDI pitch, bare pitch class, or note.
+   * @returns True if the pitch class is a scale tone.
    */
-  function(key) {
-    return functionOf(this.#data, this.#resolveKey(key).scale);
+  contains(x) {
+    return isScaleTone(typeof x === "number" ? x : x.pitchClass, this.#scale);
   }
   /**
-   * Full functional analysis: function, borrowing, and Roman numeral.
+   * The plain key data, for JSON serialization.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The chord analysis.
-   * @throws If no key is given and none is carried.
+   * Private class fields do not serialize, so an explicit `toJSON` keeps
+   * `JSON.stringify(key)` from collapsing to `{}`. The result pairs the
+   * `KeyScale` with the spelled tonic, enough to reconstruct the key via
+   * {@link Key.of}.
+   *
+   * @returns The key/scale and its spelled tonic.
    */
-  analyze(key) {
-    return analyzeChord(this.#data, this.#resolveKey(key).scale);
+  toJSON() {
+    return { scale: this.scale, tonic: this.#tonic.data };
   }
   /**
-   * Whether the chord is borrowed from the parallel mode (modal interchange).
+   * The key's tonic and mode, so a template literal or a log line reads as the
+   * key. Only the major/minor distinction is named, since a mask does not carry
+   * a scale name.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns True if the chord is borrowed.
-   * @throws If no key is given and none is carried.
+   * @returns The name, e.g. `'C major'` or `'A minor'`.
    */
-  isBorrowed(key) {
-    return isBorrowedChord(this.#data, this.#resolveKey(key).scale);
+  toString() {
+    return `${this.#tonic.name} ${this.isMinor ? "minor" : "major"}`;
   }
+};
+
+// src/model/progression.ts
+var Progression = class _Progression {
+  #chords;
+  #key;
   /**
-   * The origin of a non-diatonic chord (parallel mode or Neapolitan), or null.
+   * Wrap a chord sequence.
    *
-   * @param key Key to analyze in; falls back to the carried context.
-   * @returns The borrowing source, or null.
-   * @throws If no key is given and none is carried.
+   * @param chords The chords in order; the array is copied.
+   * @param key Optional key context for analysis methods.
    */
-  borrowedSource(key) {
-    return borrowedSource(this.#data, this.#resolveKey(key).scale);
+  constructor(chords, key) {
+    this.#chords = Object.freeze([...chords]);
+    this.#key = key;
   }
   /**
-   * The chord rendered as a lead-sheet symbol (e.g. `'Cmaj7'`, `'F#m7'`, `'C/G'`).
+   * Build a progression from the {@link ChordSpan} records the generators
+   * return, keeping their order.
    *
-   * @param opts Set `flats: true` to spell the root/bass with flats.
-   * @returns The chord symbol.
+   * The spans' `startBeat`, `degree`, and `secondaryDominant` are analysis
+   * annotations that a chord sequence does not carry; only the harmony crosses
+   * over. Keep the spans themselves if the timing matters.
+   *
+   * @param spans The chord spans, in order.
+   * @param key Optional key context for the analysis methods.
+   * @returns The progression.
+   * @example
+   * ```ts
+   * import { generateProgression, Key, Progression } from '@libraz/libcantus';
+   * const key = Key.major('C');
+   * const spans = generateProgression({ key: key.scale, style: 'dance', bars: 4 });
+   * Progression.fromSpans(spans, key).roman();
+   * ```
    */
-  symbol(opts) {
-    return formatChordSymbol(this.#data, opts);
+  static fromSpans(spans, key) {
+    const chords = spans.map((span) => {
+      const chord = Chord.from(makeChord(span.rootPc, span.quality, span.bassPc));
+      return key === void 0 ? chord : chord.withKey(key);
+    });
+    return key === void 0 ? new _Progression(chords) : new _Progression(chords, key);
   }
   /**
-   * Realize the chord as one MIDI pitch per voice, ascending.
+   * Rebuild a progression from its {@link Progression.toJSON} output.
    *
-   * @param opts Voicing options; defaults to four SATB voices.
-   * @returns MIDI pitches, ascending, one per voice.
-   * @throws If no voicing fits the given ranges.
+   * @param data The serialized chords and key.
+   * @returns The progression.
    */
-  voice(opts) {
-    return voiceChord(this.#data, opts);
+  static fromJSON(data) {
+    const key = data.key === void 0 ? void 0 : Key.fromJSON(data.key);
+    const chords = data.chords.map((chord) => Chord.fromJSON(chord));
+    return key === void 0 ? new _Progression(chords) : new _Progression(chords, key);
   }
   /**
-   * Realize the chord as a single styled voicing (`close`, `drop2`, `drop3`,
-   * `shell`, or `rootless`), optionally constraining the top voice.
+   * The chord sequence.
    *
-   * @param opts Styled-voicing options; defaults to a close-position voicing.
-   * @returns MIDI pitches, ascending.
+   * The array is the progression's own and is frozen rather than copied, so
+   * reading it in a loop stays linear.
    */
-  styledVoicing(opts) {
-    return voiceChordStyled(this.#data, opts);
+  get chords() {
+    return this.#chords;
+  }
+  /** The carried key context, if any. */
+  get key() {
+    return this.#key;
+  }
+  /** The number of chords. */
+  get length() {
+    return this.#chords.length;
   }
   /**
-   * The negative-harmony mirror of the chord about the key's tonic–dominant
-   * axis (major becomes minor and vice versa).
+   * The chord at an index.
    *
-   * @param key Key providing the reflection axis; falls back to the carried
-   *   context.
-   * @returns The mirrored chord, keeping any key context.
-   * @throws If no key is given and none is carried.
+   * @param index 0-based position; a negative index counts from the end.
+   * @returns The chord, or undefined when the index is out of range.
    */
-  negativeHarmony(key) {
-    const resolved = this.#resolveKey(key);
-    return new _Chord(negativeHarmonyMirror(this.#data, resolved.scale), key ?? this.#key);
+  at(index) {
+    return this.#chords.at(index);
+  }
+  /** Iterate the chords in order, so a progression works with `for...of`. */
+  [Symbol.iterator]() {
+    return this.#chords[Symbol.iterator]();
   }
   /**
-   * The n-th inversion: a copy whose bass is the chord tone `n` steps above the
-   * root in the interval template (`invert(1)` puts the third in the bass).
-   * `n` wraps around the template length; negative values count backwards.
+   * Whether another progression holds the same chords in the same order.
    *
-   * `invert(0)` (and any `n` that wraps to it) is root position, so it carries
-   * no slash bass and equals the original chord.
+   * The key context is not compared: it is an analysis lens, not part of the
+   * harmony. Chord equality follows {@link Chord.equals}.
    *
-   * @param n The inversion number.
-   * @returns The inverted chord, keeping any key context.
-   * @throws If the chord has no intervals.
+   * @param other The progression to compare.
+   * @returns True when the chord sequences match.
    */
-  invert(n) {
-    const intervals = this.#data.intervals;
-    const length = intervals.length;
-    if (length === 0) {
-      throw new Error("cannot invert a chord with no intervals");
-    }
-    const index = (n % length + length) % length;
-    const data = copyChord(this.#data);
-    if (index === 0) {
-      delete data.bassPc;
-    } else {
-      data.bassPc = mod12(this.#data.rootPc + (intervals[index] ?? 0));
+  equals(other) {
+    if (this.#chords.length !== other.length) {
+      return false;
     }
-    return new _Chord(data, this.#key);
+    return this.#chords.every((chord, index) => {
+      const theirs = other.at(index);
+      return theirs !== void 0 && chord.equals(theirs);
+    });
   }
   /**
-   * The named scales that fit over this chord, best fit first, rooted on the
-   * chord root.
+   * A copy of this progression with a chord appended.
    *
-   * @returns The matching scales.
+   * @param chord The chord to append.
+   * @returns The new progression.
    */
-  scales() {
-    return chordScales(this.#data);
+  add(chord) {
+    return new _Progression([...this.#chords, chord], this.#key);
   }
   /**
-   * The available tensions (usable non-chord, non-avoid scale tones) of a
-   * scale over this chord.
+   * A copy of this progression carrying the given key context.
    *
-   * @param scaleName A named scale, rooted on the chord root.
-   * @returns Tension pitch classes, ascending in [0, 11].
+   * @param key The key context to attach.
+   * @returns The new progression.
    */
-  tensions(scaleName) {
-    return availableTensions(this.#data, scaleName);
+  withKey(key) {
+    return new _Progression(this.#chords, key);
   }
   /**
-   * The avoid notes (scale tones a semitone above a chord tone) of a scale
-   * over this chord.
+   * Voice the progression with smooth voice leading.
    *
-   * @param scaleName A named scale, rooted on the chord root.
-   * @returns Avoid-note pitch classes, ascending in [0, 11].
+   * @param opts Voicing options; defaults to four SATB voices.
+   * @returns One ascending voicing (MIDI pitches) per chord.
+   * @throws If any chord admits no voicing within the given ranges.
    */
-  avoidNotes(scaleName) {
-    return avoidNotes(this.#data, scaleName);
+  voice(opts) {
+    return voiceProgression(
+      this.#chords.map((chord) => chord.data),
+      opts
+    );
   }
   /**
-   * Spell the chord tones with letter names, root first, in the key's spelling.
+   * The Roman numeral of each chord in a key.
    *
-   * @param key Key providing the spelled tonic; falls back to the carried
-   *   context.
-   * @returns Spelled octave-less notes in the chord's own (tertian) order.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns One numeral per chord.
    * @throws If no key is given and none is carried.
    */
-  spell(key) {
+  roman(key) {
     const resolved = this.#resolveKey(key);
-    return spellChord(this.#data, resolved.tonic.data, resolved.scale).map(
-      (note) => new Note(note)
-    );
+    return this.#chords.map((chord) => chord.roman(resolved));
   }
   /**
-   * Start a progression with this chord followed by others, carrying this
-   * chord's key context (if any).
+   * The harmonic function of each chord in a key.
    *
-   * @param others The chords following this one.
-   * @returns The progression.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns One function per chord.
+   * @throws If no key is given and none is carried.
    */
-  progressionTo(...others) {
-    return new Progression([this, ...others], this.#key);
+  functions(key) {
+    const resolved = this.#resolveKey(key);
+    return this.#chords.map((chord) => chord.function(resolved));
   }
   /**
-   * Whether another chord has the same root, quality, intervals, and bass.
-   * Key context is not compared.
+   * Analyze every chord and classify the closing cadence.
    *
-   * @param other The chord to compare.
-   * @returns True if the chord data is identical.
+   * The cadence is detected on the final chord pair and is null when the
+   * progression has fewer than two chords.
+   *
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns Per-chord analyses and the closing cadence.
+   * @throws If no key is given and none is carried.
    */
-  equals(other) {
-    const a = this.#data;
-    const b = other.#data;
-    return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc && a.intervals.length === b.intervals.length && a.intervals.every((interval, i) => interval === b.intervals[i]);
+  analyze(key) {
+    const resolved = this.#resolveKey(key);
+    const chords = this.#chords.map((chord) => chord.analyze(resolved));
+    const from = this.#chords[this.#chords.length - 2];
+    const to = this.#chords[this.#chords.length - 1];
+    const cadence = from !== void 0 && to !== void 0 ? detectCadence(from.data, to.data, resolved.scale) : null;
+    return { chords, cadence };
   }
   /**
-   * The plain chord data, for JSON serialization.
+   * The plain progression data, for JSON serialization.
    *
-   * @returns A copy of the underlying plain chord object.
+   * Private class fields do not serialize, so an explicit `toJSON` keeps
+   * `JSON.stringify(progression)` from collapsing to `{}`. The chords are
+   * emitted as plain data and the carried key, when present, as its own data.
+   *
+   * @returns The chord data sequence and the carried key, if any.
+   */
+  /**
+   * Transpose every chord by a number of semitones.
+   *
+   * A carried key moves with the chords, so the progression keeps its degrees
+   * and functions in the new key.
+   *
+   * @param semitones The signed semitone offset.
+   * @returns The transposed progression.
+   * @example
+   * ```ts
+   * import { Chord, Progression } from '@libraz/libcantus';
+   * new Progression([Chord.parse('C'), Chord.parse('G')]).transpose(2).toString(); // 'D A'
+   * ```
+   */
+  transpose(semitones) {
+    const key = this.#key?.transpose(semitones);
+    const chords = this.#chords.map((chord) => {
+      const moved = chord.transpose(semitones);
+      return key !== void 0 && moved.key === void 0 ? moved.withKey(key) : moved;
+    });
+    return key === void 0 ? new _Progression(chords) : new _Progression(chords, key);
+  }
+  /**
+   * The chord symbols separated by spaces, so a template literal or a log line
+   * reads as the progression.
+   *
+   * @returns The symbols in order, e.g. `'C Am F G'`.
    */
+  toString() {
+    return this.#chords.map((chord) => chord.symbol()).join(" ");
+  }
   toJSON() {
-    return this.data;
+    return {
+      chords: this.#chords.map((chord) => chord.data),
+      key: this.#key?.toJSON()
+    };
   }
   /** Resolve the key for an analysis method: explicit first, then carried. */
   #resolveKey(key) {
     const resolved = key ?? this.#key;
     if (resolved === void 0) {
-      throw new Error("chord has no key context; pass a Key or attach one with withKey()");
+      throw new InvalidInputError(
+        "progression has no key context; pass a Key or attach one with withKey()"
+      );
     }
     return resolved;
   }
 };
 
-// src/model/interval.ts
-var Interval = class _Interval {
-  #number;
-  #quality;
-  #semitones;
-  constructor(numberValue, quality, semitones) {
-    this.#number = numberValue;
-    this.#quality = quality;
-    this.#semitones = semitones;
+// src/model/chord.ts
+function hintMatches(hint, pc) {
+  return hint !== void 0 && pc !== void 0 && pitchClassOf(noteToPitchClass(hint)) === pitchClassOf(pc);
+}
+function copyChord(data) {
+  const copy = {
+    rootPc: data.rootPc,
+    quality: data.quality,
+    intervals: [...data.intervals]
+  };
+  if (data.bassPc !== void 0) {
+    copy.bassPc = data.bassPc;
+  }
+  if (hintMatches(data.rootSpelling, data.rootPc) && data.rootSpelling !== void 0) {
+    copy.rootSpelling = { letter: data.rootSpelling.letter, alter: data.rootSpelling.alter };
+  }
+  if (hintMatches(data.bassSpelling, data.bassPc) && data.bassSpelling !== void 0) {
+    copy.bassSpelling = { letter: data.bassSpelling.letter, alter: data.bassSpelling.alter };
+  }
+  return copy;
+}
+function deriveBassSpelling(chord, key) {
+  const bassPc = chord.bassPc;
+  if (bassPc === void 0) {
+    return void 0;
+  }
+  const root = chord.rootSpelling;
+  if (root !== void 0) {
+    const index = chord.intervals.findIndex((i) => pitchClassOf(chord.rootPc + i) === bassPc);
+    const tone = index >= 0 ? spellChordFromRoot(chord, root)[index] : void 0;
+    if (tone !== void 0) {
+      return { letter: tone.letter, alter: tone.alter };
+    }
+  }
+  if (key === void 0) {
+    return void 0;
   }
+  const spelled = spellPitchClass(bassPc, key.tonic.data, key.scale);
+  return { letter: spelled.letter, alter: spelled.alter };
+}
+var Chord = class _Chord {
+  /** Exactly what the caller supplied: any spelling here is the caller's own. */
+  #given;
+  #key;
   /**
-   * The spelled interval between two notes.
+   * Wrap a plain chord object.
    *
-   * @param a The first note.
-   * @param b The second note.
-   * @returns The interval from `a` to `b`.
+   * @param data The chord; it is copied, never retained or mutated.
+   * @param key Optional key context for analysis methods.
    */
-  static between(a, b) {
-    const spelled = a.intervalTo(b);
-    return new _Interval(spelled.number, spelled.quality, spelled.semitones);
+  constructor(data, key) {
+    this.#given = copyChord(data);
+    this.#key = key;
   }
   /**
-   * Build an interval from explicit components.
+   * The chord data with any missing spelling hint filled in from the key.
    *
-   * @param numberValue Diatonic size: 1 = unison, 2 = second, ... 8 = octave.
-   * @param quality Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`.
-   * @param semitones Signed semitone span.
-   * @returns The interval.
+   * Derived spellings are computed on read rather than baked in at construction,
+   * so re-attaching a different key re-spells the chord instead of carrying the
+   * first key's letters forever. A spelling the caller supplied always wins.
    */
-  static of(numberValue, quality, semitones) {
-    return new _Interval(numberValue, quality, semitones);
-  }
-  /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */
-  get number() {
-    return this.#number;
-  }
-  /** Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`. */
-  get quality() {
-    return this.#quality;
-  }
-  /** Signed semitone span. */
-  get semitones() {
-    return this.#semitones;
-  }
-  /** A readable label composed of quality and number, e.g. `'P5'` or `'M3'`. */
-  get name() {
-    return `${this.#quality}${this.#number}`;
+  get #data() {
+    const out = copyChord(this.#given);
+    const key = this.#key;
+    if (out.rootSpelling === void 0 && key !== void 0) {
+      out.rootSpelling = spellPitchClass(out.rootPc, key.tonic.data, key.scale);
+    }
+    if (out.bassSpelling === void 0) {
+      const bass = deriveBassSpelling(out, key);
+      if (bass !== void 0) {
+        out.bassSpelling = bass;
+      }
+    }
+    return out;
   }
   /**
-   * The plain interval data, for JSON serialization.
-   *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(interval)` from collapsing to `{}`.
+   * Build a chord from a root and quality.
    *
-   * @returns The diatonic number, quality, and semitone span.
+   * @param root Root as a note name (e.g. `'Eb'`) or a pitch class.
+   * @param quality The chord quality.
+   * @param bass Optional slash-chord bass, as a note name (e.g. `'Bb'`) or a
+   *   pitch class. A named bass keeps its own spelling.
+   * @returns The chord (without key context).
    */
-  toJSON() {
-    return { number: this.#number, quality: this.#quality, semitones: this.#semitones };
-  }
-};
-
-// src/model/key.ts
-function resolveTonic(root, spelling) {
-  return typeof root === "string" ? Note.of(root) : new Note(spellPitchClassBare(root, spelling));
-}
-function accidentalLoad(tonic, scale) {
-  return spellScale(tonic, scale).reduce((sum, note) => sum + Math.abs(note.alter), 0);
-}
-function bestTonicForScale(rootPc, scale) {
-  const sharp = spellPitchClassBare(rootPc, "sharp");
-  const flat = spellPitchClassBare(rootPc, "flat");
-  if (sharp.letter === flat.letter && sharp.alter === flat.alter) {
-    return new Note(sharp);
+  static of(root, quality, bass) {
+    const bassNote = typeof bass === "string" ? Note.of(bass) : void 0;
+    const bassPc = bassNote !== void 0 ? bassNote.pitchClass : bass;
+    const rootNote = typeof root === "string" ? Note.of(root) : void 0;
+    const data = makeChord(
+      rootNote !== void 0 ? rootNote.pitchClass : root,
+      quality,
+      bassPc
+    );
+    if (rootNote !== void 0) {
+      data.rootSpelling = { letter: rootNote.letter, alter: rootNote.alter };
+    }
+    if (bassNote !== void 0) {
+      data.bassSpelling = { letter: bassNote.letter, alter: bassNote.alter };
+    }
+    return new _Chord(data);
   }
-  return accidentalLoad(flat, scale) <= accidentalLoad(sharp, scale) ? new Note(flat) : new Note(sharp);
-}
-var Key = class _Key {
-  #scale;
-  #tonic;
   /**
-   * Wrap a key/scale and its spelled tonic.
+   * Wrap an existing plain chord object.
    *
-   * @param scale The key/scale; its root is normalized to a pitch class.
-   * @param tonic The spelled tonic anchoring letter-name spelling.
+   * @param data The plain chord.
+   * @returns The wrapped chord (without key context).
    */
-  constructor(scale, tonic) {
-    this.#scale = { rootPc: mod12(scale.rootPc), modeMask12: scale.modeMask12 };
-    this.#tonic = tonic;
+  static from(data) {
+    return new _Chord(data);
   }
   /**
-   * A major key.
+   * Alias of {@link Chord.from}, matching the `fromData` factory on the other
+   * classes.
    *
-   * @param root Tonic as a note name (e.g. `'Eb'`) or a pitch class; a numeric
-   *   root is spelled with whichever accidental side yields the fewest
-   *   accidentals across the scale.
-   * @returns The major key.
+   * @param data The plain chord.
+   * @returns The wrapped chord (without key context).
    */
-  static major(root) {
-    if (typeof root === "string") {
-      const tonic = Note.of(root);
-      return new _Key(majorKey(tonic.pitchClass), tonic);
-    }
-    const scale = majorKey(root);
-    return new _Key(scale, bestTonicForScale(root, scale));
+  static fromData(data) {
+    return new _Chord(data);
   }
   /**
-   * A natural-minor key.
+   * Rebuild a chord from its {@link Chord.toJSON} output.
    *
-   * @param root Tonic as a note name or a pitch class; a numeric root is
-   *   spelled with whichever accidental side yields the fewest accidentals
-   *   across the scale.
-   * @returns The minor key.
+   * The key context is not serialized, so the result carries none; re-attach
+   * one with {@link Chord.withKey}.
+   *
+   * @param data The serialized chord.
+   * @returns The wrapped chord.
    */
-  static minor(root) {
-    if (typeof root === "string") {
-      const tonic = Note.of(root);
-      return new _Key(minorKey(tonic.pitchClass), tonic);
-    }
-    const scale = minorKey(root);
-    return new _Key(scale, bestTonicForScale(root, scale));
+  static fromJSON(data) {
+    return new _Chord(data);
   }
   /**
-   * A key on a named scale (e.g. `'dorian'`, `'harmonicMinor'`).
+   * Parse a lead-sheet chord symbol (e.g. `'Cmaj7'`, `'F#m7b5'`, `'C/G'`).
    *
-   * @param name The scale name, a key of the scale module's named-scale table.
-   * @param root Tonic as a note name or a pitch class.
-   * @returns The key.
-   * @throws If the name is not a known scale.
+   * @param symbol The chord symbol.
+   * @returns The chord (without key context).
+   * @throws If the root or quality is not recognized.
    */
-  static named(name, root) {
-    const tonic = resolveTonic(root, "sharp");
-    return new _Key(scaleByName(name, tonic.pitchClass), tonic);
+  static parse(symbol) {
+    return new _Chord(parseChordSymbol(symbol));
   }
   /**
-   * Wrap an existing `KeyScale`, synthesizing a spelled tonic when none is
-   * given (flat-preferred for minor-third scales, sharp-preferred otherwise).
+   * Identify the chords matching a set of pitches, best interpretation first.
    *
-   * @param scale The key/scale to wrap.
-   * @param tonic Optional spelled tonic.
-   * @returns The key.
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to interpret the input; see {@link DetectChordOptions}.
+   * @returns Ranked chord interpretations (may be empty).
    */
-  static of(scale, tonic) {
-    const spelled = tonic ?? new Note(spellPitchClassBare(scale.rootPc, isMinorKey(scale) ? "flat" : "sharp"));
-    return new _Key(scale, spelled);
+  static detect(pitches, opts) {
+    return detectChord(pitches, opts).map(
+      (match) => new _Chord(makeChord(match.rootPc, match.quality, match.bassPc))
+    );
   }
-  /** A copy of the underlying plain `KeyScale`. */
-  get scale() {
-    return { rootPc: this.#scale.rootPc, modeMask12: this.#scale.modeMask12 };
+  /**
+   * Identify the chords matching a set of pitches, keeping each match's
+   * recognition metadata beside the chord.
+   *
+   * {@link Chord.detect} discards the confidence signals a recognition UI needs
+   * — whether the set matched exactly, which chord tones were missing, which
+   * input notes were foreign, and which inversion the bass implies.
+   *
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to interpret the input; see {@link DetectChordOptions}.
+   * @returns Ranked interpretations, each with its chord and its match record.
+   * @example
+   * ```ts
+   * import { Chord } from '@libraz/libcantus';
+   * const [best] = Chord.detectMatches([60, 64, 67]);
+   * best?.match.exact; // true
+   * ```
+   */
+  static detectMatches(pitches, opts) {
+    return detectChord(pitches, opts).map((match) => ({
+      chord: new _Chord(makeChord(match.rootPc, match.quality, match.bassPc)),
+      match
+    }));
   }
-  /** The spelled tonic. */
-  get tonic() {
-    return this.#tonic;
+  /**
+   * The single best chord interpretation of a pitch set.
+   *
+   * @param pitches MIDI pitches or bare pitch classes.
+   * @param opts How to interpret the input; see {@link DetectChordOptions}.
+   * @returns The top-ranked chord, or null when nothing matches.
+   */
+  static detectBest(pitches, opts) {
+    const best = detectChordBest(pitches, opts);
+    return best === null ? null : new _Chord(best);
   }
-  /** The tonic pitch class (0..11). */
+  /** The root pitch class (0..11). */
   get rootPc() {
-    return this.#scale.rootPc;
+    return this.#data.rootPc;
   }
-  /** Whether the scale has a minor third and no major third. */
-  get isMinor() {
-    return isMinorKey(this.#scale);
+  /** The chord quality. */
+  get quality() {
+    return this.#data.quality;
+  }
+  /** A copy of the semitone offsets above the root. */
+  get intervals() {
+    return [...this.#data.intervals];
+  }
+  /** The slash-chord bass pitch class, or undefined in root position. */
+  get bassPc() {
+    return this.#data.bassPc;
   }
   /**
-   * The scale's pitch classes in ascending scale-degree order (degree 0 first).
+   * A copy of the underlying plain chord object, including the spellings
+   * derived from any attached key.
+   */
+  get data() {
+    return this.#data;
+  }
+  /** The carried key context, if any. */
+  get key() {
+    return this.#key;
+  }
+  /**
+   * A copy of this chord carrying the given key context.
    *
-   * @returns One pitch class per scale degree.
+   * Only a spelling the caller supplied (via `Chord.parse`, `Chord.of` with a
+   * named root, or plain data carrying a hint) survives; a spelling that came
+   * from a previously attached key is re-derived, so re-keying a progression
+   * during a modulation does not keep the old key's letters and the order of
+   * `withKey` calls does not affect the result.
+   *
+   * @param key The key context to attach.
+   * @returns The new chord.
+   */
+  withKey(key) {
+    return new _Chord(this.#given, key);
+  }
+  /**
+   * The chord's sorted, deduplicated pitch classes.
+   *
+   * @returns Pitch classes ascending in [0, 11].
    */
   pitchClasses() {
-    return scaleTonesInDegreeOrder(this.#scale);
+    return chordPitchClasses(this.#data);
   }
   /**
-   * The spelled scale, one note per degree (e.g. C D E F G A B for C major).
+   * The chord's Roman numeral in a key.
    *
-   * @returns Spelled octave-less notes in scale-degree order.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns The Roman numeral string.
+   * @throws If no key is given and none is carried.
    */
-  notes() {
-    return spellScale(this.#tonic.data, this.#scale).map((note) => new Note(note));
+  roman(key) {
+    return chordToRoman(this.#data, this.#resolveKey(key).scale);
   }
   /**
-   * Alias of {@link Key.notes}.
+   * The chord's harmonic function (tonic / subdominant / dominant) in a key.
    *
-   * @returns Spelled octave-less notes in scale-degree order.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns The harmonic function.
+   * @throws If no key is given and none is carried.
    */
-  spell() {
-    return this.notes();
+  function(key) {
+    return functionOf(this.#data, this.#resolveKey(key).scale);
   }
   /**
-   * The spelled scale as letter-name strings.
+   * Full functional analysis: function, borrowing, and Roman numeral.
    *
-   * @returns One name per scale degree.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns The chord analysis.
+   * @throws If no key is given and none is carried.
    */
-  noteNames() {
-    return this.notes().map((note) => note.name);
+  analyze(key) {
+    return analyzeChord(this.#data, this.#resolveKey(key).scale);
   }
   /**
-   * Build a chord on a scale degree, carrying this key as context.
+   * Whether the chord is borrowed from the parallel mode (modal interchange).
    *
-   * With an explicit quality the quality's interval template is attached to the
-   * degree's diatonic root; without one the scale-correct diatonic triad is
-   * stacked (e.g. a diminished triad on the leading tone of a major key).
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns True if the chord is borrowed.
+   * @throws If no key is given and none is carried.
+   */
+  isBorrowed(key) {
+    return isBorrowedChord(this.#data, this.#resolveKey(key).scale);
+  }
+  /**
+   * The origin of a non-diatonic chord (parallel mode or Neapolitan), or null.
    *
-   * @param degree 0-based scale degree of the chord root.
-   * @param quality Optional chord quality.
-   * @returns The chord, with this key attached.
+   * @param key Key to analyze in; falls back to the carried context.
+   * @returns The borrowing source, or null.
+   * @throws If no key is given and none is carried.
    */
-  chord(degree, quality) {
-    const data = quality === void 0 ? diatonicTriad(degree, this.#scale) : chordFromDegree(degree, quality, this.#scale);
-    return new Chord(data, this);
+  borrowedSource(key) {
+    return borrowedSource(this.#data, this.#resolveKey(key).scale);
   }
   /**
-   * The diatonic triad on a scale degree, carrying this key as context.
+   * The chord rendered as a lead-sheet symbol (e.g. `'Cmaj7'`, `'F#m7'`, `'C/G'`).
    *
-   * @param degree 0-based scale degree of the chord root.
-   * @returns The triad, with this key attached.
+   * @param opts Set `flats: true` to spell the root/bass with flats.
+   * @returns The chord symbol.
    */
-  diatonicTriad(degree) {
-    return new Chord(diatonicTriad(degree, this.#scale), this);
+  symbol(opts) {
+    return formatChordSymbol(this.#data, opts);
   }
   /**
-   * The diatonic seventh chord on a scale degree, carrying this key as context.
+   * Realize the chord as one MIDI pitch per voice, ascending.
    *
-   * @param degree 0-based scale degree of the chord root.
-   * @returns The seventh chord, with this key attached.
+   * A chord that carries a key passes it to the voicer, so the leading tone is
+   * not doubled; an explicit `opts.key` overrides it.
+   *
+   * @param opts Voicing options; defaults to four SATB voices.
+   * @returns MIDI pitches, ascending, one per voice.
+   * @throws If no voicing fits the given ranges.
    */
-  diatonicSeventh(degree) {
-    return new Chord(diatonicSeventh(degree, this.#scale), this);
+  voice(opts) {
+    const key = opts?.key ?? this.#key?.scale;
+    return voiceChord(this.#data, key === void 0 ? opts : { ...opts, key });
   }
   /**
-   * Build the chord denoted by a Roman numeral in this key (including applied
-   * chords such as `'V7/V'`), carrying this key as context.
+   * Realize the chord as a single styled voicing (`close`, `drop2`, `drop3`,
+   * `shell`, or `rootless`), optionally constraining the top voice.
    *
-   * @param text The Roman numeral.
-   * @returns The chord, with this key attached.
-   * @throws If the numeral is not valid.
+   * @param opts Styled-voicing options; defaults to a close-position voicing.
+   * @returns MIDI pitches, ascending.
    */
-  roman(text) {
-    return new Chord(romanToChord(text, this.#scale), this);
+  styledVoicing(opts) {
+    return voiceChordStyled(this.#data, opts);
   }
   /**
-   * Whether a pitch belongs to the scale.
+   * The negative-harmony mirror of the chord about the key's tonic–dominant
+   * axis (major becomes minor and vice versa).
    *
-   * @param x A MIDI pitch, bare pitch class, or note.
-   * @returns True if the pitch class is a scale tone.
+   * @param key Key providing the reflection axis; falls back to the carried
+   *   context.
+   * @returns The mirrored chord, keeping any key context.
+   * @throws If no key is given and none is carried.
    */
-  contains(x) {
-    return isScaleTone(typeof x === "number" ? x : x.pitchClass, this.#scale);
+  negativeHarmony(key) {
+    const resolved = this.#resolveKey(key);
+    return new _Chord(negativeHarmonyMirror(this.#data, resolved.scale), key ?? this.#key);
   }
   /**
-   * The plain key data, for JSON serialization.
+   * The n-th inversion: a copy whose bass is the chord tone `n` steps above the
+   * root in the interval template (`invert(1)` puts the third in the bass).
+   * `n` wraps around the template length; negative values count backwards.
    *
-   * Private class fields do not serialize, so an explicit `toJSON` keeps
-   * `JSON.stringify(key)` from collapsing to `{}`. The result pairs the
-   * `KeyScale` with the spelled tonic, enough to reconstruct the key via
-   * {@link Key.of}.
+   * `invert(0)` (and any `n` that wraps to it) is root position, so it carries
+   * no slash bass and equals the original chord.
    *
-   * @returns The key/scale and its spelled tonic.
+   * @param n The inversion number.
+   * @returns The inverted chord, keeping any key context.
+   * @throws If the chord has no intervals.
+   */
+  invert(n) {
+    const data = copyChord(this.#given);
+    const intervals = data.intervals;
+    const length = intervals.length;
+    if (length === 0) {
+      throw new InvalidInputError("cannot invert a chord with no intervals");
+    }
+    const index = (n % length + length) % length;
+    delete data.bassSpelling;
+    if (index === 0) {
+      delete data.bassPc;
+    } else {
+      data.bassPc = pitchClassOf(data.rootPc + (intervals[index] ?? 0));
+    }
+    return new _Chord(data, this.#key);
+  }
+  /**
+   * Transpose the chord by a number of semitones.
+   *
+   * The quality and interval template are carried over, so a chord that a
+   * symbol round-trip could not express — a custom interval set, an inversion —
+   * survives. A carried key moves with the chord, so the transposed chord keeps
+   * the same degree and function inside the transposed key.
+   *
+   * @param semitones The signed semitone offset.
+   * @returns The transposed chord, in the transposed key when one is carried.
+   * @example
+   * ```ts
+   * import { Chord } from '@libraz/libcantus';
+   * Chord.parse('C/G').transpose(2).symbol(); // 'D/A'
+   * ```
+   */
+  transpose(semitones) {
+    const moved = transposeChord(this.#given, semitones);
+    return new _Chord(moved, this.#key?.transpose(semitones));
+  }
+  /**
+   * The named scales that fit over this chord, best fit first, rooted on the
+   * chord root.
+   *
+   * @returns The matching scales.
+   */
+  scales() {
+    return chordScales(this.#data);
+  }
+  /**
+   * The available tensions (usable non-chord, non-avoid scale tones) of a
+   * scale over this chord.
+   *
+   * @param scaleName A named scale, rooted on the chord root.
+   * @returns Tension pitch classes, ascending in [0, 11].
+   * @throws If `scaleName` is not a built-in scale.
+   */
+  tensions(scaleName) {
+    return availableTensions(this.#data, scaleName);
+  }
+  /**
+   * The avoid notes (scale tones a semitone above a chord tone) of a scale
+   * over this chord.
+   *
+   * @param scaleName A named scale, rooted on the chord root.
+   * @returns Avoid-note pitch classes, ascending in [0, 11].
+   * @throws If `scaleName` is not a built-in scale.
+   */
+  avoidNotes(scaleName) {
+    return avoidNotes(this.#data, scaleName);
+  }
+  /**
+   * Spell the chord tones with letter names, root first, in the key's spelling.
+   *
+   * A chord that already knows how its root is spelled — one from
+   * `Chord.parse`, or `Chord.of` with a named root — can spell itself with no
+   * key at all; a key is only needed to choose a spelling for a bare pitch
+   * class.
+   *
+   * A slash bass outside the chord tones is appended, so the spelled notes
+   * are the notes the chord sounds — the same set {@link Chord.pitchClasses}
+   * reports.
+   *
+   * @param key Key providing the spelled tonic; falls back to the carried
+   *   context, then to the chord's own root spelling.
+   * @returns Spelled octave-less notes in the chord's own (tertian) order,
+   *   with any foreign slash bass last.
+   * @throws If no key is given, none is carried, and the chord has no root
+   *   spelling of its own.
+   */
+  spell(key) {
+    const data = this.#data;
+    const resolved = key ?? this.#key;
+    let tones;
+    if (resolved === void 0) {
+      const root = data.rootSpelling;
+      if (root === void 0) {
+        throw new InvalidInputError(
+          "chord has no key context and no root spelling; pass a Key, attach one with withKey(), or build the chord from a symbol"
+        );
+      }
+      tones = spellChordFromRoot(data, root);
+    } else {
+      tones = spellChord(data, resolved.tonic.data, resolved.scale);
+    }
+    const bassPc = data.bassPc;
+    const bass = data.bassSpelling;
+    if (bassPc !== void 0 && bass !== void 0 && !tones.some((tone) => pitchClassOf(noteToPitchClass(tone)) === pitchClassOf(bassPc))) {
+      tones = [...tones, { letter: bass.letter, alter: bass.alter }];
+    }
+    return tones.map((note) => new Note(note));
+  }
+  /**
+   * Start a progression with this chord followed by others, carrying this
+   * chord's key context (if any).
+   *
+   * @param others The chords following this one.
+   * @returns The progression.
+   */
+  progressionTo(...others) {
+    return new Progression([this, ...others], this.#key);
+  }
+  /**
+   * Whether another chord has the same root, quality, intervals, and bass.
+   * Key context is not compared.
+   *
+   * @param other The chord to compare.
+   * @returns True if the chord data is identical.
+   */
+  equals(other) {
+    const a = this.#data;
+    const b = other.data;
+    return a.rootPc === b.rootPc && a.quality === b.quality && a.bassPc === b.bassPc && a.intervals.length === b.intervals.length && a.intervals.every((interval, i) => interval === b.intervals[i]);
+  }
+  /**
+   * The plain chord data, for JSON serialization.
+   *
+   * @returns A copy of the underlying plain chord object.
    */
   toJSON() {
-    return { scale: this.scale, tonic: this.#tonic.data };
+    return this.data;
+  }
+  /**
+   * The chord symbol, so a template literal or a log line reads as the chord.
+   *
+   * @returns The symbol, e.g. `'Cmaj7'`.
+   */
+  toString() {
+    return this.symbol();
+  }
+  /** Resolve the key for an analysis method: explicit first, then carried. */
+  #resolveKey(key) {
+    const resolved = key ?? this.#key;
+    if (resolved === void 0) {
+      throw new InvalidInputError(
+        "chord has no key context; pass a Key or attach one with withKey()"
+      );
+    }
+    return resolved;
   }
 };
 
 export {
+  Interval,
   Note,
+  Key,
   Progression,
-  Chord,
-  Interval,
-  Key
+  Chord
 };
-//# sourceMappingURL=chunk-COKTX2G5.js.map
+//# sourceMappingURL=chunk-EHVEBWM5.js.map