@libraz/libcantus 0.9.3 → 0.9.5

package/src/theory/chordscale/index.ts

@@ -1,374 +0,0 @@
-import type { Chord } from '../chord/index.js';
-import { chordPitchClasses } from '../chord/index.js';
-import { NAMED_SCALES } from '../scale/index.js';
-
-/** Reduce a value to a pitch class in [0, 11]. */
-function pitchClass(value: number): number {
-  return ((Math.trunc(value) % 12) + 12) % 12;
-}
-
-/** Count the set bits (scale tones) in a 12-bit mode mask. */
-function popcount12(mask: number): number {
-  let count = 0;
-  for (let n = 0; n < 12; n += 1) {
-    count += (mask >> n) & 1;
-  }
-  return count;
-}
-
-/** Test whether a pitch class belongs to a mode mask rooted on `scaleRootPc`. */
-function maskHasPitchClass(mask: number, scaleRootPc: number, pc: number): boolean {
-  const offset = pitchClass(pc - scaleRootPc);
-  return ((mask >> offset) & 1) === 1;
-}
-
-/**
- * Test whether every chord pitch class is contained in a scale.
- *
- * @param chordPcs The chord's pitch classes (0..11).
- * @param scaleMask The scale's 12-bit mode mask.
- * @param scaleRootPc The pitch class the mask is rooted on.
- * @returns True if the scale is a superset of the chord.
- *
- * @category Scales
- */
-export function scaleMatchesChord(
-  chordPcs: number[],
-  scaleMask: number,
-  scaleRootPc: number,
-): boolean {
-  for (const pc of chordPcs) {
-    if (!maskHasPitchClass(scaleMask, scaleRootPc, pc)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/**
- * A named scale rooted on a pitch class that fits over a chord.
- *
- * @category Scales
- */
-export type ChordScaleMatch = {
-  name: string;
-  rootPc: number;
-};
-
-/**
- * Scale names whose mask duplicates another {@link NAMED_SCALES} entry
- * (major/ionian, naturalMinor/aeolian). Chord-scale analysis conventionally
- * speaks in mode names, so these aliases are skipped and only the modal name
- * is reported.
- */
-const ALIASED_SCALE_NAMES = new Set(['major', 'naturalMinor']);
-
-/** Number of tones in a heptatonic (seven-note) scale. */
-const HEPTATONIC_SIZE = 7;
-
-/**
- * List the scales that fit over a chord, best fit first.
- *
- * Only the chord root is considered as the scale root, matching the
- * conventional chord-scale relationship. Every entry of {@link NAMED_SCALES}
- * whose pitch-class set is a superset of the chord's is returned once per
- * distinct pitch-class set (aliased masks such as major/ionian report only the
- * modal name), ranked by fewest extra scale tones beyond the chord, then by
- * scale size (heptatonic before larger scales), then by scale name. For bare
- * triads and smaller chords, heptatonic scales rank before pentatonics and
- * other sizes: a pentatonic adds no modal color over a triad, so the seven-note
- * modes are the more useful answer. The chromatic scale is only returned as a
- * fallback when no other scale contains the chord.
- *
- * @param chord The chord to fit scales over.
- * @returns The matching scales rooted on the chord root, best fit first.
- *
- * @example
- * ```ts
- * import { makeChord, chordScales } from '@libraz/libcantus';
- * const scales = chordScales(makeChord(0, 'maj7'));
- * // scales for Cmaj7, best fit first; each is { name, rootPc: 0 }
- * ```
- *
- * @category Scales
- */
-export function chordScales(chord: Chord): ChordScaleMatch[] {
-  const chordPcs = chordPitchClasses(chord);
-  const rootPc = pitchClass(chord.rootPc);
-  const ranked: { name: string; extra: number; size: number }[] = [];
-  const seenMasks = new Set<number>();
-  for (const name of Object.keys(NAMED_SCALES)) {
-    if (name === 'chromatic' || ALIASED_SCALE_NAMES.has(name)) {
-      continue;
-    }
-    const mask = NAMED_SCALES[name];
-    if (mask === undefined || seenMasks.has(mask)) {
-      continue;
-    }
-    seenMasks.add(mask);
-    if (scaleMatchesChord(chordPcs, mask, rootPc)) {
-      const size = popcount12(mask);
-      ranked.push({ name, extra: size - chordPcs.length, size });
-    }
-  }
-  if (ranked.length === 0) {
-    // No diatonic-style scale contains the chord; fall back to the chromatic
-    // scale, which trivially contains every pitch class.
-    if (NAMED_SCALES.chromatic !== undefined) {
-      return [{ name: 'chromatic', rootPc }];
-    }
-    return [];
-  }
-  const preferHeptatonic = chordPcs.length <= 3;
-  ranked.sort((a, b) => {
-    if (preferHeptatonic && (a.size === HEPTATONIC_SIZE) !== (b.size === HEPTATONIC_SIZE)) {
-      return a.size === HEPTATONIC_SIZE ? -1 : 1;
-    }
-    if (a.extra !== b.extra) {
-      return a.extra - b.extra;
-    }
-    if (a.size !== b.size) {
-      return a.size - b.size;
-    }
-    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-  });
-  return ranked.map((entry) => ({ name: entry.name, rootPc }));
-}
-
-/**
- * List a scale's avoid notes over a chord.
- *
- * An avoid note is a non-chord scale tone that lies a semitone directly above a
- * chord tone; sounding it against the chord clashes. The scale is rooted on the
- * chord root. If the scale does not contain the chord, no avoid notes exist.
- *
- * @param chord The chord providing the chord tones.
- * @param scaleName A key of {@link NAMED_SCALES}.
- * @returns The avoid-note pitch classes, sorted ascending in [0, 11].
- *
- * @category Scales
- */
-export function avoidNotes(chord: Chord, scaleName: string): number[] {
-  const mask = NAMED_SCALES[scaleName];
-  if (mask === undefined) {
-    return [];
-  }
-  const rootPc = pitchClass(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoid: number[] = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc)) {
-      continue;
-    }
-    if (chordSet.has(pitchClass(pc - 1))) {
-      avoid.push(pc);
-    }
-  }
-  return avoid.sort((a, b) => a - b);
-}
-
-/**
- * List a scale's available tensions over a chord.
- *
- * Available tensions are scale tones that are neither chord tones nor avoid
- * notes, i.e. the usable color tones (typically the 9/11/13 region). The scale
- * is rooted on the chord root. If the scale does not contain the chord, there
- * are no available tensions.
- *
- * @param chord The chord providing the chord tones.
- * @param scaleName A key of {@link NAMED_SCALES}.
- * @returns The available-tension pitch classes, sorted ascending in [0, 11].
- *
- * @example
- * ```ts
- * import { makeChord, availableTensions } from '@libraz/libcantus';
- * availableTensions(makeChord(0, 'maj7'), 'ionian'); // [2, 9] — color tones over Cmaj7
- * ```
- *
- * @category Scales
- */
-export function availableTensions(chord: Chord, scaleName: string): number[] {
-  const mask = NAMED_SCALES[scaleName];
-  if (mask === undefined) {
-    return [];
-  }
-  const rootPc = pitchClass(chord.rootPc);
-  const chordPcs = chordPitchClasses(chord);
-  if (!scaleMatchesChord(chordPcs, mask, rootPc)) {
-    return [];
-  }
-  const chordSet = new Set(chordPcs);
-  const avoidSet = new Set(avoidNotes(chord, scaleName));
-  const tensions: number[] = [];
-  for (let pc = 0; pc < 12; pc += 1) {
-    if (!maskHasPitchClass(mask, rootPc, pc) || chordSet.has(pc) || avoidSet.has(pc)) {
-      continue;
-    }
-    tensions.push(pc);
-  }
-  return tensions.sort((a, b) => a - b);
-}
-
-/**
- * A scale fit over a chord together with its avoid notes and tensions.
- *
- * @category Scales
- */
-export type ChordScaleReportEntry = {
-  name: string;
-  rootPc: number;
-  avoid: number[];
-  tensions: number[];
-};
-
-/**
- * Report the best-fitting scales for a chord with their avoid notes and tensions.
- *
- * Combines {@link chordScales}, {@link avoidNotes}, and {@link availableTensions}
- * into a single ergonomic result, ordered best fit first.
- *
- * @param chord The chord to analyze.
- * @param limit Optional maximum number of scales to report; all by default.
- * @returns One entry per reported scale, best fit first.
- *
- * @category Scales
- */
-export function chordScaleReport(chord: Chord, limit?: number): ChordScaleReportEntry[] {
-  const matches = chordScales(chord);
-  const chosen = limit === undefined ? matches : matches.slice(0, Math.max(0, limit));
-  return chosen.map((match) => ({
-    name: match.name,
-    rootPc: match.rootPc,
-    avoid: avoidNotes(chord, match.name),
-    tensions: availableTensions(chord, match.name),
-  }));
-}
-
-/**
- * A chord paired with the scale chosen for it by {@link scalesForChanges}.
- *
- * @category Scales
- */
-export type ScaleChoice = {
-  chord: Chord;
-  scale: ChordScaleMatch;
-};
-
-/**
- * Small per-candidate penalty added in {@link scalesForChanges} so that, among
- * choices of otherwise-equal transition cost, the tighter best-fit scale wins.
- */
-const RANK_PENALTY = 0.01;
-
-/** Build the pitch-class set of a named scale rooted on `rootPc`. */
-function scalePitchClassSet(name: string, rootPc: number): Set<number> {
-  const mask = NAMED_SCALES[name];
-  const pcs = new Set<number>();
-  if (mask === undefined) {
-    return pcs;
-  }
-  for (let n = 0; n < 12; n += 1) {
-    if (((mask >> n) & 1) === 1) {
-      pcs.add(pitchClass(rootPc + n));
-    }
-  }
-  return pcs;
-}
-
-/** Count pitch classes that belong to exactly one of two sets. */
-function symmetricDifferenceSize(a: Set<number>, b: Set<number>): number {
-  let count = 0;
-  for (const pc of a) {
-    if (!b.has(pc)) {
-      count += 1;
-    }
-  }
-  for (const pc of b) {
-    if (!a.has(pc)) {
-      count += 1;
-    }
-  }
-  return count;
-}
-
-/**
- * Choose one scale per chord across a progression, favoring continuity.
- *
- * Each chord's {@link chordScales} candidates form a stage in a Viterbi-style
- * dynamic program. The transition cost between adjacent choices is the number
- * of pitch classes that differ between their pitch-class sets (the symmetric
- * difference), plus a small penalty for straying from a chord's best-fit scale
- * so that ties break toward the tighter fit. The minimum-total-cost path is
- * returned, one {@link ScaleChoice} per input chord in the original order.
- *
- * @param chords The chord sequence to choose scales for.
- * @returns One scale choice per chord, in input order.
- *
- * @category Scales
- */
-export function scalesForChanges(chords: Chord[]): ScaleChoice[] {
-  if (chords.length === 0) {
-    return [];
-  }
-  const candidateLists = chords.map((chord) => chordScales(chord));
-  const pcSets = candidateLists.map((candidates) =>
-    candidates.map((match) => scalePitchClassSet(match.name, match.rootPc)),
-  );
-
-  const first = candidateLists[0] ?? [];
-  const dp: number[][] = [first.map((_, j) => j * RANK_PENALTY)];
-  const back: number[][] = [first.map(() => -1)];
-
-  for (let i = 1; i < candidateLists.length; i += 1) {
-    const candidates = candidateLists[i] ?? [];
-    const prevCosts = dp[i - 1] ?? [];
-    const prevSets = pcSets[i - 1] ?? [];
-    const curSets = pcSets[i] ?? [];
-    const stageCosts: number[] = [];
-    const stageBack: number[] = [];
-    for (let j = 0; j < candidates.length; j += 1) {
-      let bestCost = Number.POSITIVE_INFINITY;
-      let bestPrev = -1;
-      for (let k = 0; k < prevCosts.length; k += 1) {
-        const transition = symmetricDifferenceSize(
-          prevSets[k] ?? new Set(),
-          curSets[j] ?? new Set(),
-        );
-        const cost = (prevCosts[k] ?? 0) + transition;
-        if (cost < bestCost) {
-          bestCost = cost;
-          bestPrev = k;
-        }
-      }
-      stageCosts.push(bestCost + j * RANK_PENALTY);
-      stageBack.push(bestPrev);
-    }
-    dp.push(stageCosts);
-    back.push(stageBack);
-  }
-
-  const lastCosts = dp[dp.length - 1] ?? [];
-  let bestFinal = 0;
-  for (let j = 1; j < lastCosts.length; j += 1) {
-    if ((lastCosts[j] ?? Number.POSITIVE_INFINITY) < (lastCosts[bestFinal] ?? 0)) {
-      bestFinal = j;
-    }
-  }
-
-  const chosenIndices: number[] = new Array(candidateLists.length);
-  let current = bestFinal;
-  for (let i = candidateLists.length - 1; i >= 0; i -= 1) {
-    chosenIndices[i] = current;
-    current = back[i]?.[current] ?? -1;
-  }
-
-  return chords.map((chord, i) => {
-    const candidates = candidateLists[i] ?? [];
-    const scale = candidates[chosenIndices[i] ?? 0] ?? { name: 'chromatic', rootPc: chord.rootPc };
-    return { chord, scale };
-  });
-}

package/src/theory/counterpoint/index.ts

@@ -1,230 +0,0 @@
-import { isConsonantInterval } from '../../core/interval/index.js';
-import type { KeyScale } from '../../core/types.js';
-
-/** Reduce a MIDI pitch (or pitch class) to a pitch class in [0, 11]. */
-function pitchClass(pitch: number): number {
-  return ((Math.trunc(pitch) % 12) + 12) % 12;
-}
-
-/**
- * Whether an upper voice has crossed below a lower voice.
- *
- * @param upperPitch Pitch of the nominally higher voice.
- * @param lowerPitch Pitch of the nominally lower voice.
- * @returns True when the upper voice sits below the lower voice.
- * @category Voicing & Counterpoint
- */
-export function createsVoiceCrossing(upperPitch: number, lowerPitch: number): boolean {
-  return upperPitch < lowerPitch;
-}
-
-/**
- * Whether two simultaneous pitches form a dissonance.
- *
- * @param a First pitch.
- * @param b Second pitch.
- * @param twoVoice When true, the perfect fourth counts as dissonant.
- * @returns True when the vertical interval is dissonant.
- * @category Voicing & Counterpoint
- */
-export function createsVerticalDissonance(a: number, b: number, twoVoice: boolean): boolean {
-  return !isConsonantInterval(a - b, twoVoice);
-}
-
-/**
- * Whether a melodic move is a forbidden leap: a tritone, either seventh (minor
- * or major), or any leap wider than an octave.
- *
- * Operates on the raw absolute distance, so compound leaps are not reduced to
- * their simple class before the octave check.
- *
- * @param prev Starting pitch.
- * @param cur Ending pitch.
- * @returns True when the leap is forbidden in strict counterpoint.
- * @category Voicing & Counterpoint
- */
-export function isForbiddenMelodicLeap(prev: number, cur: number): boolean {
-  const semis = Math.abs(cur - prev);
-  return semis === 6 || semis === 10 || semis === 11 || semis > 12;
-}
-
-/** Reduce an interval to its simple class in [0, 11]. */
-function simpleClass(semitones: number): number {
-  return Math.abs(semitones) % 12;
-}
-
-/** Whether a simple interval class is a perfect kind (unison/octave or fifth). */
-function isPerfectClass(cls: number): boolean {
-  return cls === 0 || cls === 7;
-}
-
-/** Whether two voices move in the same direction (similar or parallel motion). */
-function similarMotion(aMove: number, bMove: number): boolean {
-  return aMove !== 0 && bMove !== 0 && aMove > 0 === bMove > 0;
-}
-
-/** Whether both voices actually move (neither is stationary — excludes oblique motion). */
-function bothVoicesMove(aMove: number, bMove: number): boolean {
-  return aMove !== 0 && bMove !== 0;
-}
-
-/**
- * Whether two voices move into consecutive perfect intervals of the same kind
- * (fifth-to-fifth, octave-to-octave, unison-to-unison).
- *
- * Both true parallels (similar motion) and anti-parallels — the same perfect
- * class reached by contrary motion, e.g. octave to octave with the voices moving
- * in opposite directions — are flagged, as both are forbidden in strict two-voice
- * counterpoint. The rule requires that both voices actually move: oblique motion
- * (either voice stationary) and the no-change case (identical pitches) are excluded.
- *
- * A fifth expanding to a twelfth counts (same perfect class); a fifth moving to
- * an octave does not (different perfect kinds — the direct/hidden case owned by
- * {@link createsHiddenParallelPerfect}).
- *
- * @category Voicing & Counterpoint
- */
-export function createsParallelPerfect(
-  aPrev: number,
-  aCur: number,
-  bPrev: number,
-  bCur: number,
-): boolean {
-  if (!bothVoicesMove(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  return isPerfectClass(nowClass) && nowClass === prevClass;
-}
-
-/**
- * Whether two voices move in consecutive parallel octaves (or unisons) by
- * similar motion.
- *
- * This is a strict subset of {@link createsParallelPerfect}: a similar-motion
- * octave-to-octave is the perfect-class-zero case that predicate already flags
- * (and it additionally catches the contrary-motion anti-parallel). Callers that
- * tally parallel violations should therefore use {@link createsParallelPerfect}
- * alone to avoid double counting; this predicate remains for callers wanting a
- * dedicated similar-motion octave test.
- *
- * @category Voicing & Counterpoint
- */
-export function createsParallelOctave(
-  aPrev: number,
-  aCur: number,
-  bPrev: number,
-  bCur: number,
-): boolean {
-  if (!similarMotion(aCur - aPrev, bCur - bPrev)) {
-    return false;
-  }
-  return simpleClass(aCur - bCur) === 0 && simpleClass(aPrev - bPrev) === 0;
-}
-
-/**
- * Whether two voices move in consecutive parallel unisons — both landing on the
- * same pitch, having shared a pitch on the previous move.
- *
- * @category Voicing & Counterpoint
- */
-export function createsParallelUnison(
-  aPrev: number,
-  aCur: number,
-  bPrev: number,
-  bCur: number,
-): boolean {
-  if (aCur === aPrev || bCur === bPrev) {
-    return false;
-  }
-  return aCur === bCur && aPrev === bPrev;
-}
-
-/**
- * Whether two voices reach a perfect interval by similar motion from an
- * imperfect one (a hidden/direct fifth or octave).
- *
- * The traditional step exception is applied: the approach is allowed when the
- * upper of the two voices moves by step, so only leaps into the perfect
- * interval are flagged.
- *
- * @category Voicing & Counterpoint
- */
-export function createsHiddenParallelPerfect(
-  aPrev: number,
-  aCur: number,
-  bPrev: number,
-  bCur: number,
-): boolean {
-  const aMove = aCur - aPrev;
-  const bMove = bCur - bPrev;
-  if (!similarMotion(aMove, bMove)) {
-    return false;
-  }
-  const nowClass = simpleClass(aCur - bCur);
-  const prevClass = simpleClass(aPrev - bPrev);
-  // Approaching the same perfect class (e.g. fifth to fifth) is a true parallel
-  // owned by createsParallelPerfect; approaching a different perfect interval
-  // (fifth to octave, or vice versa) is the hidden/direct case flagged here.
-  if (!isPerfectClass(nowClass) || prevClass === nowClass) {
-    return false;
-  }
-  const upperMove = aCur >= bCur ? aMove : bMove;
-  if (Math.abs(upperMove) <= 2) {
-    return false; // upper voice moves by step — direct interval is acceptable
-  }
-  return true;
-}
-
-/**
- * Whether two voices overlap: the upper voice descends below where the lower
- * voice just was, or the lower voice rises above where the upper voice just was.
- * Distinct from a simultaneous voice crossing.
- *
- * @param upperPrev Previous pitch of the upper voice.
- * @param upperCur Current pitch of the upper voice.
- * @param lowerPrev Previous pitch of the lower voice.
- * @param lowerCur Current pitch of the lower voice.
- * @category Voicing & Counterpoint
- */
-export function createsVoiceOverlap(
-  upperPrev: number,
-  upperCur: number,
-  lowerPrev: number,
-  lowerCur: number,
-): boolean {
-  return upperCur < lowerPrev || lowerCur > upperPrev;
-}
-
-/**
- * Whether two adjacent upper voices are spaced more than a maximum apart
- * (commonly an octave). Bass-to-tenor spacing is conventionally exempt, so this
- * is meant for the upper voice pairs.
- *
- * @param upperPitch Pitch of the higher voice.
- * @param lowerPitch Pitch of the lower voice.
- * @param maxSemitones Maximum allowed spacing in semitones (default an octave).
- * @category Voicing & Counterpoint
- */
-export function exceedsSpacing(upperPitch: number, lowerPitch: number, maxSemitones = 12): boolean {
-  return Math.abs(upperPitch - lowerPitch) > maxSemitones;
-}
-
-/**
- * Whether a leading tone resolves correctly upward to the tonic.
- *
- * @param prev The leading-tone pitch.
- * @param cur The following pitch.
- * @param key Key context supplying the tonic.
- * @returns True when `prev` is the leading tone and `cur` is the tonic a step above.
- * @category Voicing & Counterpoint
- */
-export function isLeadingToneResolution(prev: number, cur: number, key: KeyScale): boolean {
-  const tonic = pitchClass(key.rootPc);
-  const leading = (tonic + 11) % 12;
-  if (pitchClass(prev) !== leading || pitchClass(cur) !== tonic) {
-    return false;
-  }
-  return cur > prev && cur - prev <= 2;
-}

package/src/theory/harmony/index.ts

@@ -1,77 +0,0 @@
-import { type Chord, chordToneRole } from '../chord/index.js';
-
-/**
- * Harmonic role a pitch plays within a chord.
- *
- * @category Functional Harmony
- */
-export type HarmonyRole = 'root' | 'third' | 'fifth' | 'sixth' | 'seventh' | 'tension' | 'doubling';
-
-/**
- * How firmly a pitch is locked to the chord's identity.
- *
- * - `identity`: moving it produces a different chord (the root).
- * - `quality`: moving it flips the chord quality (the third).
- * - `voicing`: it can move freely without changing chord identity or quality.
- *
- * @category Functional Harmony
- */
-export type LockLevel = 'identity' | 'quality' | 'voicing';
-
-/**
- * A pitch's role, lock level, and owning chord.
- *
- * @category Functional Harmony
- */
-export type VoicedRole = {
-  role: HarmonyRole;
-  lock: LockLevel;
-  belongsToChordId: number;
-};
-
-/**
- * Classify a pitch's harmonic role and lock level within a chord.
- *
- * The role comes from the pitch's interval class above the chord root: root (0),
- * third (3/4), fifth (6/7/8), seventh (10/11), and 9/11/13 tensions (2/5/9, and
- * the flat ninth 1). The root locks the chord identity, the third locks its
- * quality, and everything else is free voicing. In a suspended chord (a chord
- * whose intervals include a 4th (5) or 2nd (2) but no third), the suspended tone
- * takes the third's place as the quality-defining tone and is locked to
- * `quality`, since moving it changes the chord. Detecting an octave doubling
- * requires the surrounding voicing, which this single-pitch query does not carry,
- * so `doubling` is part of the type but not returned here.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord providing the root reference.
- * @param chordId Identifier stored on the result (defaults to 0).
- * @returns The pitch's role, lock level, and owning chord id.
- * @example
- * ```ts
- * import { roleOf, makeChord } from '@libraz/libcantus';
- * roleOf(64, makeChord(0, 'maj')); // E over C major
- * // { role: 'third', lock: 'quality', belongsToChordId: 0 }
- * ```
- * @category Functional Harmony
- */
-export function roleOf(pitch: number, chord: Chord, chordId = 0): VoicedRole {
-  const interval = (((Math.trunc(pitch) - chord.rootPc) % 12) + 12) % 12;
-  const tones = new Set(chord.intervals.map((i) => ((i % 12) + 12) % 12));
-  const hasThird = tones.has(3) || tones.has(4);
-  const isSuspendedTone =
-    !hasThird && ((interval === 5 && tones.has(5)) || (interval === 2 && tones.has(2)));
-  const chordRole = chordToneRole(pitch, chord);
-  let role: HarmonyRole;
-  let lock: LockLevel;
-  if (isSuspendedTone) {
-    role = 'third'; // suspended tone occupies the third's quality-defining slot
-    lock = 'quality';
-  } else if (chordRole !== null) {
-    role = chordRole;
-    lock = chordRole === 'root' ? 'identity' : chordRole === 'third' ? 'quality' : 'voicing';
-  } else {
-    role = 'tension';
-    lock = 'voicing';
-  }
-  return { role, lock, belongsToChordId: chordId };
-}