@libraz/libcantus 1.2.0 → 1.4.0

package/dist/analyze/index.d.ts

@@ -1,13 +1,12 @@
-import { i as NoteLike, h as NoteEvent, g as Note } from '../index-Cy15oTvh.js';
-export { a as Articulation, I as IntervalData, c as IntervalQualityLabel, e as KeyScale, S as SpelledInterval } from '../index-Cy15oTvh.js';
-export { M as MeterChange, b as MeterLike, c as MeterMap, T as TimeSignature } from '../index-CL4b4gUQ.js';
-import { r as SpelledKeyLike } from '../coerce-DP0vYu-x.js';
-export { b as ChordData, c as ChordLike, d as ChordQuality, e as ChordSegment, g as ChordSpan, i as ChordToneRole, K as KeyLike, j as KeyRelation, k as KeyVariant, N as NoteSafety, l as PitchSpelling, n as ResolvedKey, o as SafetyProfile, s as SpelledKeyScale, V as VoiceSnapshot } from '../coerce-DP0vYu-x.js';
-export { r as ScaleName } from '../masks-Cc7-MzzY.js';
-import { e as ChordTimeline } from '../index-CJBBiAmU.js';
-export { A as AnalyzeChordOptions, a as AnalyzedNote, B as BorrowedSource, C as CadenceHit, b as CadenceResult, c as ChordAnalysis, d as ChordSegmentation, f as ChordTimelineOptions, g as ChordTimelineResult, h as ChordToRomanOptions, D as DetectCadenceOptions, E as ExplainRomanOptions, H as HarmonicFunction, I as IdentifiedVoiceNote, K as KeyContext, i as KeyProfileName, j as KeyProfilePair, k as KeyRegion, l as KeyTimelineOptions, P as PivotChord, R as RejectedCandidate, m as RomanExplanation, S as SuspensionFigure, T as TheoryLabel, V as VoiceNote, n as analyzeChord, o as analyzeVoice, p as assertChordTimeline, q as borrowedSource, r as chordTimelineFromChords, s as chordTimelineFromNotes, t as chordToRoman, u as detectCadence, v as detectCadences, w as detectModulations, x as explainRoman, y as functionOf, z as isBorrowedChord, F as isDiatonic, G as isMinorKey, J as keyTimelineFromNotes, L as pivotChords, M as prevailingKeyOf, N as romanToChord, O as secondaryDominant, Q as secondaryDominantOf, U as toVoiceNotes } from '../index-CJBBiAmU.js';
-import { m as MelodicPhrase } from '../index-BRMbPkHE.js';
-export { A as ArrangementAnalysis, a as ArrangementOptions, b as ArrangementSession, c as ArrangementTrack, d as AugmentedSixthKind, C as ChordMatch, e as Conflict, f as ConflictPartner, g as ContourDirection, D as DetectChordOptions, h as DetectKeyOptions, E as ExtractMotifsOptions, F as FormSection, i as FormSectionOptions, H as Hypermeter, j as HypermeterOptions, K as KeyMatch, M as MODAL_SCALE_NAMES, k as MelodicContour, l as MelodicContourShape, n as ModalCandidate, o as ModalScaleName, p as MotifData, q as MotifOccurrence, r as MotifRelation, s as MotifRelationKind, P as Phrase, t as PhraseOptions, u as PhraseSignal, R as ReduceProgressionOptions, v as ReducedChord, w as ReductionBasis, x as ReductionLevel, S as StructuralCadence, T as TensionPoint, y as TrackAnalysis, z as TrackEdit, B as TrackRole, G as analyzeArrangement, I as analyzePolyphony, J as augmentedSixthChord, L as augmentedSixthFromPitchClasses, N as augmentedSixthKind, O as createArrangementSession, Q as detectChord, U as detectChordBest, V as detectKey, W as detectKeyBest, X as detectKeyFromNotes, Y as extractMotifs, Z as hypermeter, _ as melodicContour, $ as motifFromNotes, a0 as phrasesFromTimeline, a1 as reduceProgression, a2 as relateMotifs, a3 as sectionsFromNotes, a4 as spellAugmentedSixth, a5 as structuralCadences, a6 as tensionCurve, a7 as tensionCurveFrom } from '../index-BRMbPkHE.js';
+import { i as NoteLike, h as NoteEvent, g as Note } from '../index-C9MYbuKS.js';
+export { a as Articulation, I as IntervalData, c as IntervalQualityLabel, e as KeyScale, S as SpelledInterval } from '../index-C9MYbuKS.js';
+export { M as MeterChange, b as MeterLike, c as MeterMap, T as TimeSignature } from '../index-Bf0Sv8a9.js';
+import { r as SpelledKeyLike } from '../coerce-CUhHc3Tu.js';
+export { b as ChordData, c as ChordLike, d as ChordQuality, e as ChordSegment, g as ChordSpan, i as ChordToneRole, K as KeyLike, j as KeyRelation, k as KeyVariant, N as NoteSafety, l as PitchSpelling, n as ResolvedKey, o as SafetyProfile, s as SpelledKeyScale, V as VoiceSnapshot } from '../coerce-CUhHc3Tu.js';
+export { r as ScaleName } from '../masks-tycmkrgs.js';
+import { w as MelodicPhrase, a5 as ReferenceProfile, h as ChordTimeline } from '../types-7mGFwvMm.js';
+export { A as AnalyzeChordOptions, a as AnalyzedNote, B as BarPositionProfile, b as BorrowedSource, C as CADENCE_TYPES, c as CadenceHit, d as CadenceResult, e as CadenceType, f as ChordAnalysis, g as ChordSegmentation, i as ChordTimelineOptions, j as ChordTimelineResult, k as ChordToRomanOptions, l as ContourDirection, D as DetectCadenceOptions, E as ExplainRomanOptions, m as ExtractMotifsOptions, F as FormSection, n as FormSectionOptions, H as HARMONIC_FUNCTIONS, o as HarmonicFunction, I as IdentifiedVoiceNote, K as KeyContext, p as KeyProfileName, q as KeyProfilePair, r as KeyRegion, s as KeyTimelineOptions, M as MELODIC_CONTOUR_SHAPES, t as MOTIF_RELATION_KINDS, u as MelodicContour, v as MelodicContourShape, x as MotifData, y as MotifGraph, z as MotifGraphEdge, G as MotifGraphNode, J as MotifGraphOptions, L as MotifOccurrence, N as MotifRelation, O as MotifRelationKind, P as MotifRelationSummary, Q as PivotChord, R as REDUCTION_LEVELS, S as REFERENCE_PROFILE_VERSION, T as RHYTHM_IOI_BINS, U as ReduceProgressionOptions, V as ReducedChord, W as ReductionBasis, X as ReductionLevel, Y as ReferenceCadence, Z as ReferenceChord, _ as ReferenceForm, $ as ReferenceHarmony, a0 as ReferenceKeyRegion, a1 as ReferenceMelody, a2 as ReferenceMotif, a3 as ReferencePhrase, a4 as ReferencePhraseMelody, a6 as RejectedCandidate, a7 as RhythmAnalysis, a8 as RhythmAnalysisOptions, a9 as RomanExplanation, aa as SuspensionFigure, ab as TheoryLabel, ac as VoiceNote, ad as analyzeChord, ae as analyzeRhythm, af as analyzeVoice, ag as assertChordTimeline, ah as borrowedSource, ai as chordTimelineFromChords, aj as chordTimelineFromNotes, ak as chordToRoman, al as detectCadence, am as detectCadences, an as detectModulations, ao as explainRoman, ap as extractMotifs, aq as functionOf, ar as isBorrowedChord, as as isDiatonic, at as isMinorKey, au as keyTimelineFromNotes, av as melodicContour, aw as motifFromNotes, ax as motifGraph, ay as pivotChords, az as prevailingKeyOf, aA as reduceProgression, aB as relateMotifs, aC as romanToChord, aD as secondaryDominant, aE as secondaryDominantOf, aF as sectionsFromNotes, aG as toVoiceNotes } from '../types-7mGFwvMm.js';
+export { A as ArrangementAnalysis, a as ArrangementOptions, b as ArrangementSession, c as ArrangementTrack, d as AugmentedSixthKind, C as ChordMatch, e as Conflict, f as ConflictPartner, D as DetectChordOptions, g as DetectKeyOptions, H as Hypermeter, h as HypermeterOptions, K as KeyMatch, M as MODAL_SCALE_NAMES, i as ModalCandidate, j as ModalScaleName, P as Phrase, k as PhraseOptions, l as PhraseSignal, R as ReferenceProfileOptions, S as StructuralCadence, T as TensionPoint, m as TrackAnalysis, n as TrackEdit, o as TrackRole, p as analyzeArrangement, q as analyzePolyphony, r as analyzeReference, s as augmentedSixthChord, t as augmentedSixthFromPitchClasses, u as augmentedSixthKind, v as createArrangementSession, w as detectChord, x as detectChordBest, y as detectKey, z as detectKeyBest, B as detectKeyFromNotes, E as hypermeter, F as phrasesFromTimeline, G as spellAugmentedSixth, I as structuralCadences, J as tensionCurve, L as tensionCurveFrom } from '../profile-B4WqcM4H.js';
 
 /**
  * How alike two phrases are, when they stand in no named relation.
@@ -95,6 +94,153 @@ declare function compareMelodies(a: MelodicPhrase, b: MelodicPhrase): MelodicCom
  */
 declare function melodicSimilarity(a: MelodicPhrase, b: MelodicPhrase): number;
 
+/**
+ * Comparing two {@link ReferenceProfile}s dimension by dimension.
+ *
+ * The answer is never folded into one number: each field names the aspect it
+ * measures, so "a different song built the same way" reads as high structural
+ * fields beside a low surface one. Only `melody.surfaceSimilarity` reads the
+ * motifs' intervals; every other field is invariant under transposition, tempo
+ * and a change of motif intervals.
+ */
+
+/**
+ * Options for {@link compareReferences}.
+ *
+ * @category Arrangement & Analysis
+ */
+type ReferenceComparisonOptions = {
+    /**
+     * Upper bound on the cells of the progression alignment.
+     *
+     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
+     */
+    budget?: number;
+};
+/**
+ * How alike two profiled pieces are, one field per aspect.
+ *
+ * Every value is in [0, 1] and symmetric in the two profiles. A value is
+ * `null` when neither profile has anything to measure it on, and 0 when only
+ * one does.
+ *
+ * @category Arrangement & Analysis
+ */
+type ReferenceComparison = {
+    /** Formal layout. */
+    form: {
+        /** Likeness of the section-label sequences. */
+        sectionSequenceSimilarity: number | null;
+        /** Likeness of the phrase-length sequences. */
+        phraseLengthSimilarity: number | null;
+    };
+    /** Harmony. */
+    harmony: {
+        /** Likeness of the structural Roman-numeral progressions. */
+        progressionSimilarity: number | null;
+        /** Likeness of how long each harmonic function is held. */
+        functionSimilarity: number | null;
+        /** Likeness of the phrase-by-phrase cadence sequences. */
+        cadenceSimilarity: number | null;
+        /** Likeness of the key plans, read relative to each piece's first key. */
+        keyPlanSimilarity: number | null;
+        /** Likeness of where in the bar the chords change. */
+        harmonicRhythmOnsetSimilarity: number | null;
+        /** Likeness of how often the chords change. */
+        harmonicRhythmDensitySimilarity: number | null;
+    };
+    /** Melody. */
+    melody: {
+        /** Likeness of the motifs' interval content: the one field that reads the surface. */
+        surfaceSimilarity: number | null;
+        /** Likeness of how the motifs derive from one another. */
+        motifStructureSimilarity: number | null;
+        /** Likeness of the phrases' melodic outlines, each scaled by its own range. */
+        contourSimilarity: number | null;
+        /** Likeness of the phrases' registers, each relative to its piece's melodic mean. */
+        registerSimilarity: number | null;
+    };
+    /** Melodic rhythm. */
+    rhythm: {
+        /** Likeness of where in the bar the melody's onsets fall. */
+        onsetSimilarity: number | null;
+        /** Likeness of the melodies' onsets per bar. */
+        densitySimilarity: number | null;
+        /** Likeness of the melodies' inter-onset-interval distributions. */
+        durationSimilarity: number | null;
+        /** Likeness of the melodies' syncopation. */
+        syncopationSimilarity: number | null;
+    };
+    /** The two most and the two least alike fields, by name. */
+    rationale: string;
+};
+/**
+ * Compare two profiled pieces aspect by aspect: form, harmony, melody and
+ * melodic rhythm.
+ *
+ * Sequences — sections, phrase lengths, cadences, key plans, structural
+ * chords, phrase contours and registers — are aligned by a graded edit
+ * distance; distributions — harmonic function, onset placement, inter-onset
+ * intervals, motif derivations — by histogram intersection. The surface field
+ * compares the motifs' interval cells, so a transposition of the same piece
+ * reads 1 on every field. No aggregate is returned: which aspects agree is the
+ * answer.
+ *
+ * @param a The first profile.
+ * @param b The second profile.
+ * @param opts The work budget.
+ * @returns One likeness per aspect, and a rationale naming the extremes.
+ * @throws {InvalidInputError} If either profile or the options cannot be read.
+ * @throws {BudgetExceededError} If the progression alignment would exceed the budget.
+ * @category Arrangement & Analysis
+ */
+declare function compareReferences(a: ReferenceProfile, b: ReferenceProfile, opts?: ReferenceComparisonOptions): ReferenceComparison;
+
+/**
+ * Boundary validation for {@link ReferenceProfile}: a caller can hand this a
+ * value restored from JSON, a config file, or a plugin host, and every field
+ * is checked before anything downstream reads it. A violation names the path
+ * to the offending field, so a malformed document is diagnosed at the field
+ * that is wrong rather than wherever the first bad read happens to land.
+ */
+
+/**
+ * Reject a value that is not a {@link ReferenceProfile}.
+ *
+ * A profile is the shape a caller's stored JSON, a config file, or a plugin
+ * host most plausibly hands back malformed: a missing field, a distribution
+ * that no longer sums to 1, an index a later edit left dangling, a numeral no
+ * reader can parse. Every field is checked before {@link compareReferences} or
+ * a caller's own code reads it, and a violation names the path to the field
+ * that is wrong.
+ *
+ * @param value The value to check.
+ * @param name What the value is, for the error message.
+ * @returns The same profile.
+ * @throws {InvalidInputError} If the value is not a valid reference profile.
+ * @example
+ * ```ts
+ * import { assertReferenceProfile } from '@libraz/libcantus';
+ * const emptyRhythm = {
+ *   startBeat: 0, endBeat: 0, bars: 0, onsets: 0, onsetDensity: 0,
+ *   barOnsets: [], onsetLevels: [0, 0, 0, 0, 0, 0], barPositions: [],
+ *   interOnsetShares: new Array(17).fill(0), restRatio: 0, syncopation: 0,
+ *   offGridRatio: 0, rationale: 'nothing sounds',
+ * };
+ * const profile = {
+ *   profileVersion: 1,
+ *   span: { startBeat: 0, endBeat: 0, bars: 0 },
+ *   meters: [{ startBeat: 0, ts: { numerator: 4, denominator: 4 } }],
+ *   form: { hypermeter: { groupBars: 1, confidence: 0 }, sections: [], phrases: [] },
+ *   harmony: { keys: [], chords: [], rhythm: emptyRhythm },
+ *   melody: { register: null, shape: null, motifs: [], graph: { nodes: [], edges: [] }, rhythm: emptyRhythm },
+ * };
+ * assertReferenceProfile(profile); // the profile, unchanged
+ * ```
+ * @category Arrangement & Analysis
+ */
+declare function assertReferenceProfile(value: unknown, name?: string): ReferenceProfile;
+
 /**
  * Line spelling: name every note of a melodic line in one pass.
  *
@@ -144,8 +290,9 @@ type SpellLineOptions = {
  * 1. A note the sounding chord names takes that chord's spelling of it, even
  *    when the key spells the pitch otherwise — the seventh of a Db7 reads Cb in
  *    C major, not B.
- * 2. Anything else the key's scale spells keeps its key spelling, exactly as
- *    the note-by-note path keeps it.
+ * 2. Anything else the key spells as its own — a scale tone, or the raised
+ *    sixth and seventh of a minor key — keeps its key spelling, so the leading
+ *    tone of A minor reads G# even where the line falls through it.
  * 3. A chromatic note is spelled so the written intervals around it match the
  *    sounding ones, and then so a rising step carries a sharp and a falling
  *    step a flat.
@@ -190,4 +337,5 @@ type SpellLineOptions = {
  */
 declare function spellLine(notes: readonly NoteEvent[], timeline: ChordTimeline | null, key: SpelledKeyLike, opts?: SpellLineOptions): Note[];
 
-export { ChordTimeline, type MelodicComparison, MelodicPhrase, Note as NoteData, NoteEvent, NoteLike, type SpellLineOptions, SpelledKeyLike, compareMelodies, melodicSimilarity, spellLine };
+export { ChordTimeline, MelodicPhrase, Note as NoteData, NoteEvent, NoteLike, ReferenceProfile, SpelledKeyLike, assertReferenceProfile, compareMelodies, compareReferences, melodicSimilarity, spellLine };
+export type { MelodicComparison, ReferenceComparison, ReferenceComparisonOptions, SpellLineOptions };

package/dist/analyze/index.js

@@ -1,29 +1,33 @@
 import {
   spellLine
-} from "../chunk-NFJ4P6ZZ.js";
+} from "../chunk-UZKQISRF.js";
 import {
   analyzeArrangement,
   analyzePolyphony,
-  compareMelodies,
+  analyzeReference,
+  compareReferences,
   createArrangementSession,
-  extractMotifs,
   hypermeter,
-  melodicContour,
-  melodicSimilarity,
-  motifFromNotes,
   phrasesFromTimeline,
-  reduceProgression,
-  relateMotifs,
   sectionsFromNotes,
   structuralCadences,
   tensionCurve,
   tensionCurveFrom
-} from "../chunk-HYJJ2V2I.js";
+} from "../chunk-UTE5A36R.js";
 import {
+  CADENCE_TYPES,
+  HARMONIC_FUNCTIONS,
+  MELODIC_CONTOUR_SHAPES,
   MODAL_SCALE_NAMES,
+  MOTIF_RELATION_KINDS,
+  REDUCTION_LEVELS,
+  REFERENCE_PROFILE_VERSION,
+  RHYTHM_IOI_BINS,
   analyzeChord,
+  analyzeRhythm,
   analyzeVoice,
   assertChordTimeline,
+  assertReferenceProfile,
   augmentedSixthChord,
   augmentedSixthFromPitchClasses,
   augmentedSixthKind,
@@ -31,6 +35,7 @@ import {
   chordTimelineFromChords,
   chordTimelineFromNotes,
   chordToRoman,
+  compareMelodies,
   detectCadence,
   detectCadences,
   detectChord,
@@ -40,32 +45,49 @@ import {
   detectKeyFromNotes,
   detectModulations,
   explainRoman,
+  extractMotifs,
   functionOf,
   isBorrowedChord,
   isDiatonic,
   isMinorKey,
   keyTimelineFromNotes,
+  melodicContour,
+  melodicSimilarity,
+  motifFromNotes,
+  motifGraph,
   pivotChords,
   prevailingKeyOf,
+  reduceProgression,
+  relateMotifs,
   romanToChord,
   secondaryDominant,
   secondaryDominantOf,
   spellAugmentedSixth,
   toVoiceNotes
-} from "../chunk-H2KJHBW4.js";
-import "../chunk-PUKJP2Z5.js";
+} from "../chunk-FJFULJZE.js";
+import "../chunk-TXFWSU5D.js";
 import {
   NoteSafety
-} from "../chunk-RFIBF2RR.js";
-import "../chunk-AGOVW7U6.js";
+} from "../chunk-H7FVMBUC.js";
+import "../chunk-YYVXRV3V.js";
 export {
+  CADENCE_TYPES,
+  HARMONIC_FUNCTIONS,
+  MELODIC_CONTOUR_SHAPES,
   MODAL_SCALE_NAMES,
+  MOTIF_RELATION_KINDS,
   NoteSafety,
+  REDUCTION_LEVELS,
+  REFERENCE_PROFILE_VERSION,
+  RHYTHM_IOI_BINS,
   analyzeArrangement,
   analyzeChord,
   analyzePolyphony,
+  analyzeReference,
+  analyzeRhythm,
   analyzeVoice,
   assertChordTimeline,
+  assertReferenceProfile,
   augmentedSixthChord,
   augmentedSixthFromPitchClasses,
   augmentedSixthKind,
@@ -74,6 +96,7 @@ export {
   chordTimelineFromNotes,
   chordToRoman,
   compareMelodies,
+  compareReferences,
   createArrangementSession,
   detectCadence,
   detectCadences,
@@ -94,6 +117,7 @@ export {
   melodicContour,
   melodicSimilarity,
   motifFromNotes,
+  motifGraph,
   phrasesFromTimeline,
   pivotChords,
   prevailingKeyOf,

package/dist/{chunk-NB25P3EH.js → chunk-2G5MCGYU.js}

@@ -7,19 +7,21 @@ import {
   namedScaleMask,
   requireScaleMask,
   resolveScaleName,
+  soundsDominantSeventh,
   thirdSlotOf,
   toChordData
-} from "./chunk-RFIBF2RR.js";
+} from "./chunk-H7FVMBUC.js";
 import {
   InvalidInputError,
   assertArray,
   assertFiniteNumber,
   assertGenerationBudget,
+  assertOneOf,
   assertOptions,
   assertPitchClass,
   assertPositiveInt,
   pitchClassOf
-} from "./chunk-AGOVW7U6.js";
+} from "./chunk-YYVXRV3V.js";
 
 // src/theory/chordscale/index.ts
 function requireChordScaleMask(name, label = "scale") {
@@ -54,7 +56,8 @@ function scaleMatchesChord(chordPcs, scaleMask, scaleRootPc) {
   }
   return true;
 }
-var ALIASED_SCALE_NAMES = /* @__PURE__ */ new Set(["major", "naturalMinor"]);
+var ALIASED_SCALE_NAME_LIST = ["major", "naturalMinor"];
+var ALIASED_SCALE_NAMES = new Set(ALIASED_SCALE_NAME_LIST);
 var HEPTATONIC_SIZE = 7;
 var SCALE_PREFERENCE = [
   "ionian",
@@ -90,13 +93,20 @@ function idiomaticRank(chord, name) {
   return index < 0 ? choices.length + 1 : index;
 }
 function isAlteredDominant(chord, scaleName) {
-  return chord.quality === "dom7" && scaleName === "altered";
+  if (scaleName !== "altered" || !soundsDominantSeventh(chord)) {
+    return false;
+  }
+  const mask = namedScaleMask(scaleName);
+  const rootPc = pitchClassOf(chord.rootPc);
+  const fifthPc = pitchClassOf(rootPc + 7);
+  return mask !== void 0 && chordPitchClasses(chord).every((pc) => pc === fifthPc || maskHasPitchClass(mask, rootPc, pc));
 }
 function chordScales(chord) {
   const data = toChordData(chord);
   const chordPcs = chordPitchClasses(data);
   const rootPc = pitchClassOf(data.rootPc);
   const ranked = [];
+  const writesTension = chordPcs.some((pc) => ![0, 4, 7, 10].includes(pitchClassOf(pc - rootPc)));
   const seenMasks = /* @__PURE__ */ new Set();
   for (const name of Object.keys(NAMED_SCALES)) {
     if (name === "chromatic" || ALIASED_SCALE_NAMES.has(name)) {
@@ -113,7 +123,10 @@ function chordScales(chord) {
         name,
         extra: size - chordPcs.length,
         size,
-        avoid: avoidNotes(data, name).length
+        avoid: clashingNotes(data, mask, false).length,
+        // Eligible only through the fifth exemption: a scale that holds every
+        // written tone is the better answer for a chord that writes a tension.
+        borrowed: writesTension && !scaleMatchesChord(chordPcs, mask, rootPc)
       });
     }
   }
@@ -133,6 +146,9 @@ function chordScales(chord) {
     if (preferHeptatonic && a.size === HEPTATONIC_SIZE !== (b.size === HEPTATONIC_SIZE)) {
       return a.size === HEPTATONIC_SIZE ? -1 : 1;
     }
+    if (a.borrowed !== b.borrowed) {
+      return a.borrowed ? 1 : -1;
+    }
     if (a.extra !== b.extra) {
       return a.extra - b.extra;
     }
@@ -152,25 +168,31 @@ function avoidNotes(chord, scaleName, opts = {}) {
   const asked = assertOptions(opts, "opts");
   const mask = requireChordScaleMask(scaleName);
   const data = toChordData(chord);
+  const use = assertOneOf(asked.use ?? "harmonic", ["harmonic", "melodic"], "avoid-note use");
+  if (isAlteredDominant(data, scaleName)) {
+    return [];
+  }
+  return clashingNotes(data, mask, use === "melodic");
+}
+function clashingNotes(data, mask, melodic) {
   const rootPc = pitchClassOf(data.rootPc);
   const chordPcs = chordPitchClasses(data);
-  const alteredDominant = isAlteredDominant(data, scaleName);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {
+  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
     return [];
   }
   const chordSet = new Set(chordPcs);
   const displaced = new Set(displacedThirds(data));
-  const melodic = asked.use === "melodic";
   const semitoneAboveRoot = pitchClassOf(rootPc + 1);
+  const dominantNinth = soundsDominantSeventh(data) ? semitoneAboveRoot : void 0;
   const avoid = [];
   for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
+    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || pc === dominantNinth) {
       continue;
     }
     if (melodic && pc !== semitoneAboveRoot) {
       continue;
     }
-    if (!alteredDominant && (chordSet.has(pitchClassOf(pc - 1)) || displaced.has(pc))) {
+    if (chordSet.has(pitchClassOf(pc - 1)) || displaced.has(pc)) {
       avoid.push(pc);
     }
   }
@@ -360,4 +382,4 @@ export {
   scalesForChanges,
   roleOf
 };
-//# sourceMappingURL=chunk-NB25P3EH.js.map
+//# sourceMappingURL=chunk-2G5MCGYU.js.map

package/dist/chunk-2G5MCGYU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/theory/chordscale/index.ts","../src/theory/harmony/index.ts"],"sourcesContent":["import { InvalidInputError } from '../../core/errors/index.js';\nimport { pitchClassOf as pitchClass } from '../../core/pitch/index.js';\nimport {\n  assertArray,\n  assertGenerationBudget,\n  assertOneOf,\n  assertOptions,\n  assertPitchClass,\n  assertPositiveInt,\n} from '../../core/validation/index.js';\nimport type { Chord } from '../chord/index.js';\nimport { chordPitchClasses, displacedThirds } from '../chord/index.js';\nimport type { ScaleNameInput } from '../scale/index.js';\nimport {\n  assertModeMask,\n  NAMED_SCALES,\n  namedScaleMask,\n  requireScaleMask,\n  resolveScaleName,\n} from '../scale/index.js';\nimport { type ChordLike, toChordData } from '../symbol/index.js';\nimport { soundsDominantSeventh } from '../tendency/index.js';\n\n/**\n * The mask of a scale a chord-scale question may be asked about.\n *\n * Chord-scale theory is a Western practice, so the register of world scales is\n * not a vocabulary these functions answer from: a raga offered as the scale\n * over an altered dominant would read as an answer while being a category\n * error. {@link chordScales} proposes {@link NAMED_SCALES} and nothing else,\n * and the questions asked about one chosen scale accept exactly what it can\n * propose — an alias of a Western scale included, a world scale not.\n *\n * @param name The scale name or alias.\n * @param label What the name is, for the error message.\n * @returns The 12-bit mask.\n * @throws If the name is not a built-in scale, or names a world scale.\n */\nfunction requireChordScaleMask(name: ScaleNameInput, label = 'scale'): number {\n  const canonical = resolveScaleName(name);\n  if (canonical !== undefined && !Object.hasOwn(NAMED_SCALES, canonical)) {\n    throw new InvalidInputError(\n      `${label} must name a scale chord-scale theory ranks; ${String(name)} is a world scale`,\n    );\n  }\n  return requireScaleMask(name, label);\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  // The mask is read with bit operations and a pitch class shifts it, so both\n  // coerce: an entry that is not a pitch class would silently be read as one.\n  assertModeMask(scaleMask, 'scaleMask');\n  assertPitchClass(scaleRootPc, 'scaleRootPc');\n  const pcs = assertArray<number>(chordPcs, 'chord pitch classes');\n  for (let index = 0; index < pcs.length; index += 1) {\n    const pc = assertPitchClass(pcs[index] ?? Number.NaN, `chord pitch classes[${index}]`);\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 */\nexport const ALIASED_SCALE_NAME_LIST: readonly string[] = ['major', 'naturalMinor'];\n\nconst ALIASED_SCALE_NAMES = new Set(ALIASED_SCALE_NAME_LIST);\n\n/** Number of tones in a heptatonic (seven-note) scale. */\nexport const HEPTATONIC_SIZE = 7;\n\n/**\n * Conventional preference among equally-fitting scales, brightest first.\n *\n * Several modes fit a chord that states no third or sixth — a power chord, a\n * suspension — equally well. Alphabetical order made `aeolian` the answer for\n * those, naming a minor mode as the best fit for a mode-neutral chord.\n */\nexport const SCALE_PREFERENCE = [\n  'ionian',\n  'major',\n  'mixolydian',\n  'dorian',\n  'lydian',\n  'aeolian',\n  'naturalMinor',\n  'phrygian',\n  'locrian',\n] as const;\n\n/** Conventional first choices that pure set-fit ranking cannot express. */\nexport const IDIOMATIC_SCALES: Partial<Record<Chord['quality'], readonly string[]>> = {\n  aug: ['wholeTone'],\n  m7b5: ['locrian'],\n  // The diminished scale played over a diminished seventh is the whole-half\n  // octatonic. Its half-whole rotation belongs to the dominant it colours: over\n  // a diminished seventh every one of its non-chord tones lands a semitone\n  // above a chord tone, so it offers no tension at all.\n  dim7: ['octatonicWholeHalf'],\n  minMaj7: ['melodicMinor'],\n};\n\n/** Position of a scale in {@link SCALE_PREFERENCE}, or last when unlisted. */\nfunction conventionalRank(name: string): number {\n  const index = (SCALE_PREFERENCE as readonly string[]).indexOf(name);\n  return index < 0 ? SCALE_PREFERENCE.length : index;\n}\n\n/** Whether this scale is an idiomatic color choice for the chord quality. */\nfunction idiomaticRank(chord: Chord, name: string): number {\n  const choices = IDIOMATIC_SCALES[chord.quality];\n  if (choices === undefined) {\n    return 0;\n  }\n  const index = choices.indexOf(name);\n  return index < 0 ? choices.length + 1 : index;\n}\n\n/**\n * A dominant seventh may use altered colors while retaining its perfect fifth\n * in the voicing. It is read from the tones, as every dominant is: a major\n * third with a minor seventh whose only tones outside the altered scale are the\n * fifth, so `7`, `7alt`, `7b9`, `7#9` and `7b13` all take it while `9` and `13`\n * do not. Lead sheets commonly write the shorter `7` here.\n */\nfunction isAlteredDominant(chord: Chord, scaleName: string): boolean {\n  if (scaleName !== 'altered' || !soundsDominantSeventh(chord)) {\n    return false;\n  }\n  const mask = namedScaleMask(scaleName);\n  const rootPc = pitchClass(chord.rootPc);\n  const fifthPc = pitchClass(rootPc + 7);\n  return (\n    mask !== undefined &&\n    chordPitchClasses(chord).every((pc) => pc === fifthPc || maskHasPitchClass(mask, rootPc, pc))\n  );\n}\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). The chromatic scale is only returned as a fallback when no other\n * scale contains the chord.\n *\n * The ranking applies these keys in order:\n *\n * 1. The idiomatic scales for the chord quality, in the order they are named\n *    there, ahead of every scale that is not one of them.\n * 2. For bare triads and smaller chords, heptatonic scales ahead of pentatonics\n *    and other sizes: a pentatonic adds no modal color over a triad, so the\n *    seven-note modes are the more useful answer.\n * 3. Fewest extra scale tones beyond the chord.\n * 4. Conventional modal preference.\n * 5. Fewest avoid notes, which separates the symmetric and melodic-minor\n *    scales the modal preference does not name.\n * 6. Alphabetical order, so the list is stable.\n *\n * The idiomatic key comes first, so the head of the list is the scale a player\n * would name rather than the tightest fit: over `Cm7b5` the locrian mode leads\n * even though the blues scale adds fewer tones, because locrian is what a\n * half-diminished chord is read as. Read further down the list, or pick by name,\n * when the closest fit is what is wanted; {@link scalesForChanges} makes the\n * choice for a whole progression.\n *\n * @param chord The chord to fit scales over, as a chord symbol, chord data, or\n *   a `Chord`.\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: ChordLike): ChordScaleMatch[] {\n  const data = toChordData(chord);\n  const chordPcs = chordPitchClasses(data);\n  const rootPc = pitchClass(data.rootPc);\n  const ranked: {\n    name: string;\n    extra: number;\n    size: number;\n    avoid: number;\n    borrowed: boolean;\n  }[] = [];\n  // A tone beyond the plain seventh chord is a written alteration or extension.\n  const writesTension = chordPcs.some((pc) => ![0, 4, 7, 10].includes(pitchClass(pc - rootPc)));\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 = namedScaleMask(name);\n    if (mask === undefined || seenMasks.has(mask)) {\n      continue;\n    }\n    seenMasks.add(mask);\n    if (scaleMatchesChord(chordPcs, mask, rootPc) || isAlteredDominant(data, name)) {\n      const size = popcount12(mask);\n      ranked.push({\n        name,\n        extra: size - chordPcs.length,\n        size,\n        avoid: clashingNotes(data, mask, false).length,\n        // Eligible only through the fifth exemption: a scale that holds every\n        // written tone is the better answer for a chord that writes a tension.\n        borrowed: writesTension && !scaleMatchesChord(chordPcs, mask, rootPc),\n      });\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    const idiomaticA = idiomaticRank(data, a.name);\n    const idiomaticB = idiomaticRank(data, b.name);\n    if (idiomaticA !== idiomaticB) {\n      return idiomaticA - idiomaticB;\n    }\n    if (preferHeptatonic && (a.size === HEPTATONIC_SIZE) !== (b.size === HEPTATONIC_SIZE)) {\n      return a.size === HEPTATONIC_SIZE ? -1 : 1;\n    }\n    if (a.borrowed !== b.borrowed) {\n      return a.borrowed ? 1 : -1;\n    }\n    if (a.extra !== b.extra) {\n      return a.extra - b.extra;\n    }\n    const rankA = conventionalRank(a.name);\n    const rankB = conventionalRank(b.name);\n    if (rankA !== rankB) {\n      return rankA - rankB;\n    }\n    // Among scales the modal preference does not name — the symmetric and\n    // melodic-minor scales — the one that clashes with the chord least is the\n    // one a player reaches for. Alphabetical order answered with the rotation\n    // that leaves nothing playable.\n    if (a.avoid !== b.avoid) {\n      return a.avoid - b.avoid;\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 * Which use an avoid note is judged for: sounding it, or passing through it.\n *\n * `'harmonic'` is the Berklee-style rule — a tone that must not be\n * sounded against the chord. `'melodic'` keeps only what a line cannot pass\n * through either, which is the semitone above the root; every other clash\n * resolves as the line moves on. Over a chord that sounds a dominant seventh\n * the semitone above the root is the flat ninth, a tension under either use\n * whichever scale supplies it; the flat thirteenth stays a harmonic avoid note.\n *\n * @category Scales\n */\nexport type AvoidNoteUse = 'harmonic' | 'melodic';\n\n/**\n * Options for {@link avoidNotes}.\n *\n * @category Scales\n */\nexport type AvoidNotesOptions = {\n  use?: AvoidNoteUse;\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, or the third a suspension displaced; sounding it against the\n * chord clashes. The scale is rooted on the chord root. If the scale does not\n * contain the chord, no avoid notes exist.\n *\n * The rule states which tones must not be *sounded* against the chord, which is\n * not the same question as which tones a line may not touch. Pass\n * `{ use: 'melodic' }` for the melodic reading: only the semitone above the\n * root survives it, so the result is always a subset of the harmonic one.\n *\n * @param chord The chord providing the chord tones, as a chord symbol, chord\n *   data, or a `Chord`.\n * @param scaleName A key of {@link NAMED_SCALES}, or an alias of one. A world\n *   scale is not one: chord-scale theory is a Western practice, so a raga named\n *   here is rejected rather than answered with a number.\n * @param opts Set `use: 'melodic'` to judge a line rather than a voicing.\n * @returns The avoid-note pitch classes, sorted ascending in [0, 11].\n * @throws If `scaleName` is not a built-in scale. An empty result already\n *   means \"this scale has no avoid notes over this chord\"; answering a typo\n *   the same way would make the two indistinguishable.\n *\n * @example\n * ```ts\n * import { makeChord, avoidNotes } from '@libraz/libcantus';\n * avoidNotes(makeChord(0, 'maj7'), 'ionian'); // [5] — F clashes with the third\n * avoidNotes(makeChord(0, 'maj7'), 'ionian', { use: 'melodic' }); // [] — a line may pass through it\n * ```\n *\n * @category Scales\n */\nexport function avoidNotes(\n  chord: ChordLike,\n  scaleName: ScaleNameInput,\n  opts: AvoidNotesOptions = {},\n): number[] {\n  const asked = assertOptions(opts, 'opts');\n  const mask = requireChordScaleMask(scaleName);\n  const data = toChordData(chord);\n  const use = assertOneOf(asked.use ?? 'harmonic', ['harmonic', 'melodic'], 'avoid-note use');\n  if (isAlteredDominant(data, scaleName)) {\n    return [];\n  }\n  return clashingNotes(data, mask, use === 'melodic');\n}\n\n/**\n * The scale tones that clash with the chord by the avoid-note rule, whatever\n * function the chord serves: {@link avoidNotes} before the altered dominant's\n * exemption. Empty when the scale does not contain the chord.\n */\nfunction clashingNotes(data: Chord, mask: number, melodic: boolean): number[] {\n  const rootPc = pitchClass(data.rootPc);\n  const chordPcs = chordPitchClasses(data);\n  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {\n    return [];\n  }\n  const chordSet = new Set(chordPcs);\n  // Sounding the third a suspension stands in for is what undoes the\n  // suspension, so it is an avoid note however consonant it is against the\n  // scale. Both thirds are named: a suspension does not say which one it\n  // displaced — that is what suspending is — so meeting either one ends it.\n  const displaced = new Set(displacedThirds(data));\n  const semitoneAboveRoot = pitchClass(rootPc + 1);\n  // The flat ninth is a dominant's own tension, whichever scale supplies it.\n  const dominantNinth = soundsDominantSeventh(data) ? semitoneAboveRoot : undefined;\n  const avoid: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || pc === dominantNinth) {\n      continue;\n    }\n    if (melodic && pc !== semitoneAboveRoot) {\n      continue;\n    }\n    if (chordSet.has(pitchClass(pc - 1)) || displaced.has(pc)) {\n      avoid.push(pc);\n    }\n  }\n  return avoid.sort((a, b) => a - b);\n}\n\n/**\n * Semitones above the root of the colors a dominant takes when it resolves to a\n * minor tonic: the flat ninth, the sharp ninth, and the flat thirteenth.\n *\n * Over a dominant read on its own, the flat ninth is already a tension and the\n * others sit a semitone above a chord tone. Heard as the dominant of a minor key\n * they are the key's own tones, and standard practice, so the function the\n * chord serves is what decides.\n */\nexport const MINOR_RESOLUTION_TENSIONS = [1, 3, 8] as const;\n\n/** Whether this chord is a dominant seventh resolving down a fifth to minor. */\nfunction resolvesToMinorTonic(\n  chord: Chord,\n  chordPcs: number[],\n  target: Chord | undefined,\n): boolean {\n  if (target === undefined) {\n    return false;\n  }\n  const rootPc = pitchClass(chord.rootPc);\n  const sounds = (semitones: number): boolean => chordPcs.includes(pitchClass(rootPc + semitones));\n  if (!sounds(4) || !sounds(10)) {\n    return false;\n  }\n  const targetRootPc = pitchClass(target.rootPc);\n  if (targetRootPc !== pitchClass(rootPc + 5)) {\n    return false;\n  }\n  return chordPitchClasses(target).includes(pitchClass(targetRootPc + 3));\n}\n\n/**\n * Options for {@link availableTensions}.\n *\n * @category Scales\n */\nexport type AvailableTensionsOptions = {\n  /**\n   * The chord this one resolves to, as a chord symbol, chord data, or a\n   * `Chord`.\n   */\n  resolvesTo?: ChordLike;\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 * A tension's availability also depends on what the chord is doing. Pass\n * `resolvesTo` to say which chord this one resolves to: a dominant seventh\n * resolving down a fifth to a minor tonic takes its sharp ninth and flat\n * thirteenth as well as the flat ninth every dominant takes. Only\n * scale tones are ever added, so the result stays within the scale.\n *\n * @param chord The chord providing the chord tones, as a chord symbol, chord\n *   data, or a `Chord`.\n * @param scaleName A key of {@link NAMED_SCALES}, or an alias of one; a world\n *   scale is outside chord-scale theory, as in {@link avoidNotes}.\n * @param opts Set `resolvesTo` to the chord this one resolves to.\n * @returns The available-tension pitch classes, sorted ascending in [0, 11].\n * @throws If `scaleName` is not a built-in scale, as {@link avoidNotes} does.\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 * availableTensions(makeChord(7, 'dom7'), 'phrygianDominant', { resolvesTo: makeChord(0, 'min') });\n * // [3, 8] — the b9, and the b13 the resolution to C minor makes available\n * ```\n *\n * @category Scales\n */\nexport function availableTensions(\n  chord: ChordLike,\n  scaleName: ScaleNameInput,\n  opts: AvailableTensionsOptions = {},\n): number[] {\n  const asked = assertOptions(opts, 'opts');\n  const mask = requireChordScaleMask(scaleName);\n  const data = toChordData(chord);\n  const rootPc = pitchClass(data.rootPc);\n  const chordPcs = chordPitchClasses(data);\n  const alteredDominant = isAlteredDominant(data, scaleName);\n  if (!scaleMatchesChord(chordPcs, mask, rootPc) && !alteredDominant) {\n    return [];\n  }\n  const chordSet = new Set(chordPcs);\n  const avoidSet = alteredDominant ? new Set<number>() : new Set(avoidNotes(data, scaleName));\n  const functional = resolvesToMinorTonic(\n    data,\n    chordPcs,\n    asked.resolvesTo === undefined ? undefined : toChordData(asked.resolvesTo),\n  )\n    ? new Set(MINOR_RESOLUTION_TENSIONS.map((semitones) => pitchClass(rootPc + semitones)))\n    : undefined;\n  const tensions: number[] = [];\n  for (let pc = 0; pc < 12; pc += 1) {\n    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {\n      continue;\n    }\n    if (avoidSet.has(pc) && functional?.has(pc) !== true) {\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, with its non-chord tones sorted by what may be done\n * with them.\n *\n * `avoid`, `passing` and `tensions` partition the scale tones the chord does\n * not state: `avoid` may not be played at all, `passing` may be passed through\n * melodically but not sounded against the chord, and `tensions` may be added\n * freely as color. `avoid` is {@link avoidNotes} under `use: 'melodic'`, and\n * `avoid` together with `passing` is the harmonic reading.\n *\n * @category Scales\n */\nexport type ChordScaleReportEntry = {\n  name: string;\n  rootPc: number;\n  avoid: number[];\n  passing: 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. The report is read as\n * playing advice, so the tones a line may pass through are reported apart from\n * the ones it may not touch; see {@link ChordScaleReportEntry}.\n *\n * @param chord The chord to analyze, as a chord symbol, chord data, or a\n *   `Chord`.\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: ChordLike, limit?: number): ChordScaleReportEntry[] {\n  if (limit !== undefined) {\n    assertPositiveInt(limit, 'chord-scale report limit');\n  }\n  const data = toChordData(chord);\n  const matches = chordScales(data);\n  const chosen = limit === undefined ? matches : matches.slice(0, limit);\n  return chosen.map((match) => {\n    const harmonic = avoidNotes(data, match.name);\n    const melodic = new Set(avoidNotes(data, match.name, { use: 'melodic' }));\n    return {\n      name: match.name,\n      rootPc: match.rootPc,\n      avoid: harmonic.filter((pc) => melodic.has(pc)),\n      passing: harmonic.filter((pc) => !melodic.has(pc)),\n      tensions: availableTensions(data, match.name),\n    };\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 */\nexport const 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 = namedScaleMask(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 * Each choice pairs its scale with the chord exactly as it was handed in, so\n * this takes plain chord data rather than the wider forms the entry points\n * above accept.\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: readonly Chord[]): ScaleChoice[] {\n  assertArray(chords, 'chord-scale changes');\n  assertGenerationBudget(chords.length, 'chord-scale changes');\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","import { pitchClassOf } from '../../core/pitch/index.js';\nimport { assertFiniteNumber } from '../../core/validation/index.js';\nimport { type ChordToneRole, chordToneRole, thirdSlotOf } from '../chord/index.js';\nimport { type ChordLike, toChordData } from '../symbol/index.js';\n\n/**\n * Harmonic role a pitch plays within a chord.\n *\n * @category Functional Harmony\n */\nexport type HarmonyRole = ChordToneRole | 'tension' | 'doubling';\n\n/**\n * How firmly a pitch is locked to the chord's identity.\n *\n * - `identity`: moving it produces a different chord (the root).\n * - `quality`: moving it flips the chord quality (the third).\n * - `voicing`: it can move freely without changing chord identity or quality.\n *\n * @category Functional Harmony\n */\nexport type LockLevel = 'identity' | 'quality' | 'voicing';\n\n/**\n * A pitch's role, lock level, and owning chord.\n *\n * @category Functional Harmony\n */\nexport type VoicedRole = {\n  role: HarmonyRole;\n  lock: LockLevel;\n  belongsToChordId: number;\n};\n\n/**\n * Classify a pitch's harmonic role and lock level within a chord.\n *\n * The role comes from the pitch's interval class above the chord root, read\n * against the chord's own template: root (0), third (3/4), fifth (6/7/8),\n * sixth or seventh (9/10/11). Every pitch the template does not claim is\n * `'tension'` — including one that is simply foreign to the chord, which this\n * single-pitch query cannot tell from a colour tone. The root locks the chord\n * identity, the third locks its quality, and everything else is free voicing.\n * Where a chord has no third, the tone standing in its place — the fourth of a\n * `sus4`, the second of a `sus2`, the eleventh of an eleventh chord — takes the\n * third's slot and is locked to `quality`, since moving it changes the chord.\n * At most one interval class of a chord is ever reported as its third, so a\n * consumer reading `lock: 'quality'` as \"this tone identifies the chord\" gets\n * one answer rather than two. Detecting an octave doubling requires the\n * surrounding voicing, which this query does not carry, so `'doubling'` is part\n * of the type — the shared vocabulary of harmonic roles — but is never returned\n * here.\n *\n * @param pitch MIDI pitch or bare pitch class.\n * @param chord The chord providing the root reference, as a chord symbol, chord\n *   data, or a `Chord`.\n * @param chordId Identifier stored on the result (defaults to 0).\n * @returns The pitch's role, lock level, and owning chord id.\n * @example\n * ```ts\n * import { roleOf, makeChord } from '@libraz/libcantus';\n * roleOf(64, makeChord(0, 'maj')); // E over C major\n * // { role: 'third', lock: 'quality', belongsToChordId: 0 }\n * ```\n * @category Functional Harmony\n */\nexport function roleOf(pitch: number, chord: ChordLike, chordId = 0): VoicedRole {\n  // The id is carried into the result, so a value that is not one would be\n  // reported back as the chord this role belongs to.\n  assertFiniteNumber(chordId, 'chordId');\n  const data = toChordData(chord);\n  const interval = (pitchClassOf(pitch) - pitchClassOf(data.rootPc) + 12) % 12;\n  // What stands in the third's slot is read where the chord is read, not here:\n  // the tone that identifies a chord and the tone the avoid-note rule refuses\n  // against it are two consequences of one fact about the chord.\n  const slot = thirdSlotOf(data);\n  const isSuspendedTone = slot.kind === 'suspension' && interval === slot.interval;\n  const chordRole = chordToneRole(pitch, data);\n  let role: HarmonyRole;\n  let lock: LockLevel;\n  if (isSuspendedTone) {\n    role = 'third'; // suspended tone occupies the third's quality-defining slot\n    lock = 'quality';\n  } else if (chordRole !== null) {\n    role = chordRole;\n    lock = chordRole === 'root' ? 'identity' : chordRole === 'third' ? 'quality' : 'voicing';\n  } else {\n    role = 'tension';\n    lock = 'voicing';\n  }\n  return { role, lock, belongsToChordId: chordId };\n}\n"],"mappings":"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","names":[]}